TAO/tao/PI/ORBInitializer_Registry_Impl.cpp

   1 #include "tao/PI/ORBInitializer_Registry_Impl.h"
   2 #include "tao/PI/ORBInitInfo.h"
   3 #include "tao/PI/PICurrent.h"
   4 #include "tao/PI/PI_ORBInitializer.h"
   5 #include "tao/PI/ClientRequestInterceptor_Factory_Impl.h"
   6 #include "tao/PI/PICurrent_Loader.h"
   7 #include "tao/PI/PolicyFactory_Loader.h"
   8
   9 #include "tao/ORB_Core.h"
  10 #include "tao/ORB_Constants.h"
  11
  12 #include "ace/Static_Object_Lock.h"
  13 #include "ace/Recursive_Thread_Mutex.h"
  14 #include "ace/Log_Msg.h"
  15 #include "ace/CORBA_macros.h"
  16
  17 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 TAO::ORBInitializer_Registry::ORBInitializer_Registry ()
  20   : lock_ (),
  21     initializers_ ()
  22 {
  23 }
  24
  25 int
  26 TAO::ORBInitializer_Registry::init (int, ACE_TCHAR *[])
  27 {
  28 #if !defined (TAO_AS_STATIC_LIBS) && (TAO_HAS_INTERCEPTORS == 1)
  29   ACE_Service_Config::process_directive
  30     (ace_svc_desc_TAO_ClientRequestInterceptor_Adapter_Factory_Impl);
  31
  32   ACE_Service_Config::process_directive
  33     (ace_svc_desc_TAO_PICurrent_Loader);
  34
  35   PortableInterceptor::ORBInitializer_ptr temp_orb_initializer =
  36     PortableInterceptor::ORBInitializer::_nil ();
  37
  38   PortableInterceptor::ORBInitializer_var orb_initializer;
  39
  40   try
  41     {
  42       /// Register the PI ORBInitializer.
  43
  44       ACE_NEW_THROW_EX (temp_orb_initializer,
  45                         TAO_PI_ORBInitializer,
  46                         CORBA::NO_MEMORY (
  47                           CORBA::SystemException::_tao_minor_code (
  48                             TAO::VMCID,
  49                             ENOMEM),
  50                           CORBA::COMPLETED_NO));
  51
  52       orb_initializer = temp_orb_initializer;
  53
  54       this->register_orb_initializer (orb_initializer.in ());
  55     }
  56   catch (const ::CORBA::Exception& ex)
  57     {
  58       if (TAO_debug_level > 0)
  59         {
  60           ex._tao_print_exception ("(%P|%t) Caught exception:");
  61         }
  62       return -1;
  63     }
  64 #endif /* !TAO_AS_STATIC_LIBS  && TAO_HAS_INTERCEPTORS == 1 */
  65   return 0;
  66 }
  67
  68 int
  69 TAO::ORBInitializer_Registry::fini ()
  70 {
  71   ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX,
  72                     guard,
  73                     this->lock_,
  74                     -1);
  75
  76   // Release all initializers in the array
  77   size_t const initializer_count (this->initializers_.size ());
  78   for (size_t i = initializer_count; i > 0;)
  79     {
  80       --i;
  81       if (TAO_debug_level > 8)
  82         {
  83           TAOLIB_DEBUG((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - ORBInitializer_Registry::fini clearing %d @%@\n"),
  84             i, this->initializers_[i].operator->()
  85             ));
  86         }
  87       this->initializers_[i] = PortableInterceptor::ORBInitializer::_nil();
  88     }
  89
  90   return 0;
  91 }
  92
  93 void
  94 TAO::ORBInitializer_Registry::register_orb_initializer (
  95   PortableInterceptor::ORBInitializer_ptr init)
  96 {
  97   if (!CORBA::is_nil (init))
  98     {
  99       ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX,
 100                  guard,
 101                  this->lock_);
 102
 103       // Increase the length of the ORBInitializer array by one.
 104       size_t const cur_len = this->initializers_.size ();
 105       size_t const new_len = cur_len + 1;
 106       if (this->initializers_.size (new_len) != 0)
 107         throw ::CORBA::INTERNAL ();
 108
 109       // Add the given ORBInitializer to the sequence.
 110       if (TAO_debug_level > 8)
 111         {
 112           TAOLIB_DEBUG((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - ORBInitializer_Registry::register_orb_initializer %d @%@\n"),
 113             cur_len, init
 114             ));
 115         }
 116
 117       this->initializers_[cur_len] =
 118         PortableInterceptor::ORBInitializer::_duplicate (init);
 119     }
 120   else
 121     throw ::CORBA::INV_OBJREF (
 122                  CORBA::SystemException::_tao_minor_code (
 123                    0,
 124                    EINVAL),
 125                  CORBA::COMPLETED_NO);
 126 }
 127
 128 size_t
 129 TAO::ORBInitializer_Registry::pre_init (
 130   TAO_ORB_Core *orb_core,
 131   int argc,
 132   char *argv[],
 133   PortableInterceptor::SlotId &slotid)
 134 {
 135   ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX,
 136                     guard,
 137                     this->lock_,
 138                     0);
 139
 140   size_t const initializer_count (this->initializers_.size ());
 141
 142   if (initializer_count > 0)
 143     {
 144       TAO_ORBInitInfo * orb_init_info_temp = 0;
 145
 146       ACE_NEW_THROW_EX (orb_init_info_temp,
 147                         TAO_ORBInitInfo (orb_core,
 148                                          argc,
 149                                          argv,
 150                                          slotid),
 151                         CORBA::NO_MEMORY (
 152                           CORBA::SystemException::_tao_minor_code (
 153                             0,
 154                             ENOMEM),
 155                           CORBA::COMPLETED_NO));
 156
 157       TAO_ORBInitInfo_var orb_init_info_ = orb_init_info_temp;
 158
 159       for (size_t i = 0; i < initializer_count; ++i)
 160         {
 161           this->initializers_[i]->pre_init (orb_init_info_.in ());
 162         }
 163
 164       slotid = orb_init_info_temp->slot_count ();
 165
 166       // Invalidate the ORBInitInfo instance to prevent future
 167       // modifications to the ORB.  This behavior complies with the
 168       // PortableInterceptor specification.
 169       orb_init_info_temp->invalidate ();
 170     }
 171
 172   return initializer_count;
 173 }
 174
 175 void
 176 TAO::ORBInitializer_Registry::post_init (
 177   size_t pre_init_count,
 178   TAO_ORB_Core *orb_core,
 179   int argc,
 180   char *argv[],
 181   PortableInterceptor::SlotId slotid)
 182 {
 183   if (pre_init_count > 0)
 184     {
 185       ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX,
 186                  guard,
 187                  this->lock_);
 188
 189       TAO_ORBInitInfo * orb_init_info_temp = 0;
 190
 191       ACE_NEW_THROW_EX (orb_init_info_temp,
 192                         TAO_ORBInitInfo (orb_core,
 193                                          argc,
 194                                          argv,
 195                                          slotid),
 196                         CORBA::NO_MEMORY (
 197                           CORBA::SystemException::_tao_minor_code (
 198                             0,
 199                             ENOMEM),
 200                           CORBA::COMPLETED_NO));
 201
 202       TAO_ORBInitInfo_var orb_init_info_ = orb_init_info_temp;
 203
 204       for (size_t i = 0; i < pre_init_count; ++i)
 205         {
 206           this->initializers_[i]->post_init (orb_init_info_.in ());
 207         }
 208
 209 #if TAO_HAS_INTERCEPTORS == 1
 210       CORBA::Object_ptr picurrent_ptr = orb_core->pi_current ();
 211       PortableInterceptor::SlotId slot_count = orb_init_info_->slot_count ();
 212
 213       if (CORBA::is_nil (picurrent_ptr) && slot_count != 0)
 214         {
 215           // Force instantiation of the PICurrent object. If we do not do it
 216           // now, the slot count will be lost.
 217           CORBA::Object_var tmp = orb_core->resolve_picurrent ();
 218           picurrent_ptr = orb_core->pi_current ();
 219         }
 220
 221       if (!CORBA::is_nil (picurrent_ptr))
 222         {
 223           TAO::PICurrent *pi = dynamic_cast <TAO::PICurrent*> (picurrent_ptr);
 224
 225           if (pi)
 226             {
 227               pi->initialize (slot_count);
 228             }
 229         }
 230 #endif /* TAO_HAS_INTERCEPTORS == 1 */
 231
 232       // Invalidate the ORBInitInfo instance to prevent future
 233       // modifications to the ORB.  This behavior complies with the
 234       // PortableInterceptor specification.
 235       orb_init_info_temp->invalidate ();
 236     }
 237 }
 238
 239 ACE_STATIC_SVC_DEFINE (ORBInitializer_Registry,
 240                        ACE_TEXT ("ORBInitializer_Registry"),
 241                        ACE_SVC_OBJ_T,
 242                        &ACE_SVC_NAME (ORBInitializer_Registry),
 243                        ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ,
 244                        0)
 245
 246 ACE_FACTORY_NAMESPACE_DEFINE (TAO_PI, ORBInitializer_Registry, TAO::ORBInitializer_Registry)
 247
 248 TAO_END_VERSIONED_NAMESPACE_DECL
 249