TAO/tests/Bug_3171_Regression/server.cpp

   1 #include "ace/Get_Opt.h"
   2 #include "ace/Task.h"
   3 #include "tao/corba.h"
   4 #include "tao/Utils/ORB_Manager.h"
   5 #include "tao/AnyTypeCode/Any.h"
   6 #include "tao/Messaging/Messaging.h"
   7 #include "tao/ORBInitializer_Registry.h"
   8 #include "tao/PI/PI.h"
   9 #include "tao/LocalObject.h"
  10
  11 int g_nthreads = 1;
  12 bool g_setTimeout = true;
  13 bool g_registerORBinitializer = true;
  14 bool g_initInMain = false;
  15 int g_argc;
  16 ACE_TCHAR ** g_argv;
  17
  18 int initORB(int threadID);
  19
  20 int
  21 parse_args (int argc, ACE_TCHAR *argv[])
  22 {
  23   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("min:"));
  24   int c;
  25
  26   while ((c = get_opts ()) != -1)
  27     switch (c)
  28       {
  29       case 'm':
  30         g_initInMain = true;
  31         break;
  32
  33       case 'i':
  34         g_registerORBinitializer = false;
  35         break;
  36
  37       case 'n':
  38         g_nthreads = ACE_OS::atoi (get_opts.opt_arg ());
  39         break;
  40
  41       case '?':
  42       default:
  43         ACE_ERROR_RETURN ((LM_ERROR,
  44                            "usage:  %s "
  45                            "-m (Initialize an ORB from the main thread first) "
  46                            "-i (Do not register ORB initializer) "
  47                            "-n <numberOfThreads>"
  48                            "\n",
  49                            argv [0]),
  50                           -1);
  51       }
  52   // Indicates successful parsing of the command line
  53   return 0;
  54 }
  55
  56 class Worker : public ACE_Task_Base
  57 {
  58 public:
  59   Worker ();
  60
  61   virtual int svc (void);
  62
  63 private:
  64 };
  65
  66 class MyORBinitializer
  67   : public virtual PortableInterceptor::ORBInitializer
  68   , public virtual CORBA::LocalObject
  69 {
  70 public:
  71   MyORBinitializer( ACE_CString orbID )
  72     : orbID_( orbID ) {};
  73
  74   virtual
  75   void
  76   pre_init( PortableInterceptor::ORBInitInfo_ptr )
  77   {
  78     ACE_DEBUG ((LM_DEBUG,
  79                 "MyORBinitializer::pre_init() called for ORB \"%C\"\n",
  80                 orbID_.c_str()));
  81   };
  82
  83   virtual
  84   void
  85   post_init( PortableInterceptor::ORBInitInfo_ptr )
  86   {
  87     ACE_DEBUG ((LM_DEBUG,
  88                 "MyORBinitializer::post_init() called for ORB \"%C\"\n",
  89                 orbID_.c_str()));
  90   };
  91
  92   private:
  93     ACE_CString orbID_;
  94 };
  95
  96 int
  97 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  98 {
  99   g_argc = argc;
 100   g_argv = argv;
 101
 102   try
 103   {
 104     if (parse_args (argc, argv) != 0)
 105       return 1;
 106
 107     if ( g_initInMain )
 108     {
 109       initORB(0);
 110     }
 111 //  Run in both main and background thread
 112 //    else
 113     {
 114       Worker worker;
 115       if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
 116                            g_nthreads) != 0)
 117         ACE_ERROR_RETURN ((LM_ERROR,
 118                            "Cannot activate ORB thread(s)\n"),
 119                           1);
 120
 121       worker.thr_mgr ()->wait ();
 122
 123     }
 124     ACE_DEBUG ((LM_DEBUG, "Event loop finished\n"));
 125   }
 126   catch (const CORBA::Exception& ex)
 127   {
 128     ex._tao_print_exception ("Exception caught:");
 129     return 1;
 130   }
 131
 132   return 0;
 133 }
 134
 135 // ****************************************************************
 136
 137 Worker::Worker ()
 138 {
 139 }
 140
 141 int
 142 Worker::svc (void)
 143 {
 144   static int threadID = 0;
 145
 146   initORB(++threadID);
 147
 148   return 0;
 149 }
 150
 151 int
 152 initORB(int threadID)
 153 {
 154   try
 155   {
 156     char ORBid[10];
 157     ACE_OS::sprintf (ORBid, "ORB_%d", threadID);
 158
 159     ACE_DEBUG ((LM_DEBUG, "Initializing ORB \"%C\"\n", ORBid));
 160
 161     if ( g_registerORBinitializer )
 162     {
 163       ACE_DEBUG ((LM_DEBUG, "Creating ORB initializer\n"));
 164       PortableInterceptor::ORBInitializer_var rCOI(
 165         new MyORBinitializer( ORBid ) );
 166       PortableInterceptor::register_orb_initializer( rCOI.in() );
 167     }
 168
 169     ACE_DEBUG ((LM_DEBUG, "Creating TAO_ORB_Manager\n"));
 170     TAO_ORB_Manager* pORBmgr = new TAO_ORB_Manager;
 171
 172     if ( -1 == pORBmgr->init( g_argc, g_argv, ORBid ) )
 173     {
 174       ACE_DEBUG ((LM_DEBUG, "Failed to initialize ORB \"%C\"\n", ORBid));
 175       throw CORBA::INTERNAL();
 176     }
 177
 178     ACE_DEBUG ((LM_DEBUG, "ORB \"%C\" initialized\n", ORBid));
 179
 180     if ( g_setTimeout )
 181     {
 182       ACE_DEBUG ((LM_DEBUG,
 183                   "Setting connection timeout policy for ORB \"%C\"\n",
 184                   ORBid));
 185
 186       CORBA::PolicyList policyList;
 187
 188       CORBA::ORB_var orb = pORBmgr->orb();
 189
 190       TimeBase::TimeT connectionTimeout = 100*10000;
 191       CORBA::Any any;
 192       any <<= connectionTimeout;
 193
 194       CORBA::ULong l( policyList.length() );
 195       policyList.length( l+1 );
 196
 197       policyList[l] = orb->create_policy(
 198         TAO::CONNECTION_TIMEOUT_POLICY_TYPE,
 199         any );
 200
 201       ACE_DEBUG ((LM_DEBUG, "Connection timeout policy set for ORB \"%C\"\n",
 202                   ORBid));
 203     }
 204
 205     pORBmgr->fini();
 206
 207     delete pORBmgr;
 208   }
 209   catch (const CORBA::Exception& ex)
 210   {
 211     ACE_ERROR ((LM_ERROR, "Caught exception: %C\n", ex._info().c_str()));
 212     return 1;
 213   }
 214
 215   return 0;
 216 }
 217