Created attachment 888 [details]
Test program used to recreate the problem with ACE/TAO code only.

Attaching a test program used to reproduce the bug.  Running with no arguments should do it.  The -m option verifies the code works from main, while -i disables registration of the ORB initializer.

Can you retest with the x.6.2 release that is available later today. Iliyan, this looks service gestalt related, can you also have a look?

Can you rework the regression test to not use anything of std::, else we just can't easily merge it into the repository?

Also please remove the following includes
#include <sstream>
#include <stdexcept>

Comment on attachment 888 [details]
Test program used to recreate the problem with ACE/TAO code only.

#include "ace/Get_Opt.h"
#include "ace/Task.h"
#include <tao/corba.h>
#include <tao/Utils/ORB_Manager.h>
#include <tao/AnyTypeCode/Any.h>
#include <tao/Messaging/Messaging.h>
#include <tao/ORBInitializer_Registry.h>
#include <tao/PI/PI.h>

int g_nthreads = 1;
bool g_setTimeout = true;
bool g_registerORBinitializer = true;
bool g_initInMain = false;
int g_argc;
char ** g_argv;

int initORB(int threadID);

int
parse_args (int argc, char *argv[])
{
  ACE_Get_Opt get_opts (argc, argv, "min:");
  int c;

  while ((c = get_opts ()) != -1)
    switch (c)
      {
      case 'm':
        g_initInMain = true;
        break;

      case 'i':
        g_registerORBinitializer = false;
        break;

      case 'n':
        g_nthreads = ACE_OS::atoi (get_opts.opt_arg ());
        break;

      case '?':
      default:
        ACE_ERROR_RETURN ((LM_ERROR,
                           "usage:  %s "
                           "-m (Initialize an ORB from the main thread first) "
                           "-i (Do not register ORB initializer) "
                           "-n <numberOfThreads>"
                           "\n",
                           argv [0]),
                          -1);
      }
  // Indicates sucessful parsing of the command line
  return 0;
}

class Worker : public ACE_Task_Base
{
public:
  Worker ();

  virtual int svc (void);

private:
};

class MyORBinitializer
  : public PortableInterceptor::ORBInitializer
{
public:
  MyORBinitializer( ACE_CString orbID )
    : orbID_( orbID ) {};

  virtual
  void
  pre_init( PortableInterceptor::ORBInitInfo_ptr )
  {
    ACE_DEBUG ((LM_DEBUG, 
                "MyORBinitializer::pre_init() called for ORB \"%s\"\n",
                orbID_.c_str()));
  };

  virtual
  void
  post_init( PortableInterceptor::ORBInitInfo_ptr )
  {
    ACE_DEBUG ((LM_DEBUG, 
                "MyORBinitializer::post_init() called for ORB \"%s\"\n",
                orbID_.c_str()));
  };

  private:
    ACE_CString orbID_;
};

int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
  g_argc = argc;
  g_argv = argv;

  try
  {
    if (parse_args (argc, argv) != 0)
      return 1;
   
    if ( g_initInMain )
    {
      initORB(0);
    }
//  Run in both main and background thread
//    else
    {
      Worker worker;
      if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
                           g_nthreads) != 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot activate ORB thread(s)\n"),
                          1);

      worker.thr_mgr ()->wait ();

    }
    ACE_DEBUG ((LM_DEBUG, "Event loop finished\n"));
  }
  catch (const CORBA::Exception& ex)
  {
    ex._tao_print_exception ("Exception caught:");
    return 1;
  }

  return 0;
}

// ****************************************************************

Worker::Worker ()
{
}

int
Worker::svc (void)
{
  static int threadID = 0;

  initORB(++threadID);

  return 0;
}

int
initORB(int threadID)
{
  try
  {
    char ORBid[10];
    ACE_OS::sprintf (ORBid, "ORB_%d", threadID);

    ACE_DEBUG ((LM_DEBUG, "Initializing ORB \"%s\"\n", ORBid));

    if ( g_registerORBinitializer )
    {
      ACE_DEBUG ((LM_DEBUG, "Creating ORB initializer\n"));
      PortableInterceptor::ORBInitializer_var rCOI(
        new MyORBinitializer( ORBid ) );
      PortableInterceptor::register_orb_initializer( rCOI.in() );
    }

    ACE_DEBUG ((LM_DEBUG, "Creating TAO_ORB_Manager\n"));
    TAO_ORB_Manager* pORBmgr = new TAO_ORB_Manager;

    if ( -1 == pORBmgr->init( g_argc, g_argv, ORBid ) )
    {
      ACE_DEBUG ((LM_DEBUG, "Failed to initialize ORB \"%s\"\n", ORBid));
      throw CORBA::INTERNAL();
    }

    ACE_DEBUG ((LM_DEBUG, "ORB \"%s\" initialized\n", ORBid));

    if ( g_setTimeout )
    {
      ACE_DEBUG ((LM_DEBUG, 
                  "Setting connection timeout policy for ORB \"%s\"\n", 
                  ORBid));

      CORBA::PolicyList policyList;

      CORBA::ORB_var orb = pORBmgr->orb();
    
      TimeBase::TimeT connectionTimeout = 100*10000;
      CORBA::Any any;
      any <<= connectionTimeout;

      CORBA::ULong l( policyList.length() );
      policyList.length( l+1 );

      policyList[l] = orb->create_policy(
        TAO::CONNECTION_TIMEOUT_POLICY_TYPE,
        any );

      ACE_DEBUG ((LM_DEBUG, "Connection timeout policy set for ORB \"%s\"\n", 
                  ORBid));
    }

    pORBmgr->fini();

    delete pORBmgr;
  }
  catch (const CORBA::Exception& ex)
  {
    ACE_ERROR ((LM_ERROR, "Caught exception: %s\n", ex._info().c_str()));
    return 1;
  }

  return 0;
}

Sorry, that didn't work quite the way I expected.  I tried to edit the attachment in place, but submitted as a comment by mistake.  I'll attach the new file.

BTW, I tried TAO 1.6.2 and it still fails.  Actually, it now seg faults when attempting to destroy the ORB in the background thread.

Created attachment 889 [details]
Test program without std namespace usage

Tue Dec 18 10:45:12 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>

        * tests/Bug_3171_Regression/*:
          New regression provided by Joe Seward <joseph dot f dot seward at saic dot com>
          for providing this test. This bug is not fixed yet.

also scoreboard shows that things are broken at this moment

The problem is being addressed with the changes at this branch: https://svn.dre.vanderbilt.edu/DOC/Middleware/branches/iliyan-gestalt. It is tracking the HEAD (>1 a week). I am currently testing it for compatibility on the many platforms supported by TAO. With the changes this particular bug is no longer failing on my linux build. Joe, could you please test with the above branch and post your observations here?

I'll hopefully be able to retest in a day or two.  Is there any chance this change will be included in the upcoming TAO 1.6.3 release?  Thanks.

the x.6.3 is schedule to go out very soon, this will not make it into that version. Iliyan is working on this issue in his spare private time. 

Do you have a public access account for the subversion repository?  Seems it wants a username/password.

(In reply to comment #12)
> Do you have a public access account for the subversion repository?  Seems it
> wants a username/password.
> 

Try svn: instead of https:

see also the TAO Programmers Guide which you can download from http://www.theaceorb.nl for instructions how to use the svn version

I built the iliyan-gestalt TAO branch and tested with the submitted test.  This appears to have fixed the issue.  What I haven't been able to do is test with the TENA middleware itself.  I believe the problem is sufficiently isolated from TENA to say it *should* work.  After our current beta release is out, I should have time to test further.

Iliyan has fixed this on svn head