TAO/tao/IORInterceptor/IORInterceptor_Adapter_Impl.cpp

   1 // -*- C++ -*-
   2 #include "tao/IORInterceptor/IORInterceptor_Adapter_Impl.h"
   3 #include "tao/IORInterceptor/IORInfo.h"
   4 #include "tao/debug.h"
   5 #include "tao/ORB_Constants.h"
   6 #include "tao/PI/PI.h"
   7 #include "tao/PortableServer/Root_POA.h"
   8 #include "tao/PortableServer/Non_Servant_Upcall.h"
   9
  10 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 TAO_IORInterceptor_Adapter_Impl::~TAO_IORInterceptor_Adapter_Impl ()
  13 {
  14 }
  15
  16 void
  17 TAO_IORInterceptor_Adapter_Impl::add_interceptor (
  18     PortableInterceptor::IORInterceptor_ptr i)
  19 {
  20   this->ior_interceptor_list_.add_interceptor (i);
  21 }
  22
  23 void
  24 TAO_IORInterceptor_Adapter_Impl::add_interceptor (
  25     PortableInterceptor::IORInterceptor_ptr i,
  26     const CORBA::PolicyList& policies)
  27 {
  28   this->ior_interceptor_list_.add_interceptor (i, policies);
  29 }
  30
  31 void
  32 TAO_IORInterceptor_Adapter_Impl::destroy_interceptors ()
  33 {
  34   this->ior_interceptor_list_.destroy_interceptors ();
  35
  36   delete this;
  37 }
  38
  39 void
  40 TAO_IORInterceptor_Adapter_Impl::establish_components (TAO_Root_POA* poa)
  41 {
  42   size_t const interceptor_count = this->ior_interceptor_list_.size ();
  43
  44   if (interceptor_count == 0)
  45     return;
  46
  47   TAO_IORInfo *tao_info = 0;
  48   ACE_NEW_THROW_EX (tao_info,
  49                     TAO_IORInfo (poa),
  50                     CORBA::NO_MEMORY (
  51                        CORBA::SystemException::_tao_minor_code (
  52                           TAO::VMCID,
  53                           ENOMEM),
  54                        CORBA::COMPLETED_NO));
  55
  56   PortableInterceptor::IORInfo_var info = tao_info;
  57
  58   // Release the POA during IORInterceptor calls to avoid potential
  59   // deadlocks.
  60   TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*poa);
  61   ACE_UNUSED_ARG (non_servant_upcall);
  62
  63   for (size_t i = 0; i < interceptor_count; ++i)
  64     {
  65       try
  66         {
  67           this->ior_interceptor_list_.interceptor (i)->establish_components (
  68             info.in ());
  69         }
  70       catch (const ::CORBA::Exception& ex)
  71         {
  72           // According to the Portable Interceptors specification,
  73           // IORInterceptor::establish_components() must not throw an
  74           // exception.  If it does, then the ORB is supposed to
  75           // ignore it and continue processing the remaining
  76           // IORInterceptors.
  77           if (TAO_debug_level > 1)
  78             {
  79               CORBA::String_var name =
  80                 this->ior_interceptor_list_.interceptor (i)->name ();
  81               // @@ What do we do if we get an exception here?
  82
  83               if (name.in () != 0)
  84                 {
  85                   TAOLIB_DEBUG ((LM_WARNING,
  86                               "(%P|%t) Exception thrown while processing "
  87                               "IORInterceptor \"%C\">\n",
  88                               name.in ()));
  89                 }
  90
  91               ex._tao_print_exception (
  92                 "Ignoring exception in "
  93                 "IORInterceptor::establish_components");
  94             }
  95         }
  96     }
  97
  98   tao_info->components_established ();
  99
 100   this->components_established (info.in ());
 101
 102   // The IORInfo instance is no longer valid.  Invalidate it to
 103   // prevent the user from peforming "illegal" operations.
 104   tao_info->invalidate ();
 105 }
 106
 107 void
 108 TAO_IORInterceptor_Adapter_Impl::components_established (
 109   PortableInterceptor::IORInfo_ptr info)
 110 {
 111   // Iterate over the registered IOR interceptors so that they may be
 112   // given the opportunity to add tagged components to the profiles
 113   // for this servant.
 114   size_t const interceptor_count = this->ior_interceptor_list_.size ();
 115
 116   // All the establish_components() interception points have been
 117   // invoked. Now call the components_established() interception point
 118   // on all the IORInterceptors.
 119   for (size_t j = 0; j < interceptor_count; ++j)
 120     {
 121       try
 122         {
 123           PortableInterceptor::IORInterceptor_ptr ior_interceptor =
 124             this->ior_interceptor_list_.interceptor (j);
 125
 126           PortableInterceptor::IORInterceptor_3_0_var ior_3_interceptor =
 127             PortableInterceptor::IORInterceptor_3_0::_narrow (ior_interceptor);
 128           if (!CORBA::is_nil (ior_3_interceptor.in ()))
 129             {
 130               ior_3_interceptor->components_established (info);
 131             }
 132         }
 133       catch (const ::CORBA::Exception&)
 134         {
 135           throw ::CORBA::OBJ_ADAPTER (CORBA::OMGVMCID | 6,
 136                                       CORBA::COMPLETED_NO);
 137         }
 138     }
 139 }
 140
 141 void
 142 TAO_IORInterceptor_Adapter_Impl::adapter_state_changed (
 143       const TAO::ObjectReferenceTemplate_Array &array_obj_ref_template,
 144       PortableInterceptor::AdapterState state)
 145 {
 146   size_t const interceptor_count = this->ior_interceptor_list_.size ();
 147
 148   if (interceptor_count == 0)
 149     return;
 150
 151   PortableInterceptor::ObjectReferenceTemplateSeq seq_obj_ref_template;
 152
 153   seq_obj_ref_template.length (
 154     static_cast <CORBA::ULong> (array_obj_ref_template.size()));
 155
 156   for (size_t counter = 0; counter < array_obj_ref_template.size(); ++counter)
 157     {
 158       PortableInterceptor::ObjectReferenceTemplate *member =
 159         array_obj_ref_template[counter];
 160
 161       CORBA::add_ref (member);
 162
 163       seq_obj_ref_template[static_cast<CORBA::ULong> (counter)] = member;
 164     }
 165
 166   for (size_t i = 0; i < interceptor_count; ++i)
 167     {
 168       PortableInterceptor::IORInterceptor_ptr ior_interceptor =
 169         this->ior_interceptor_list_.interceptor (i);
 170
 171       PortableInterceptor::IORInterceptor_3_0_var ior_3_interceptor =
 172         PortableInterceptor::IORInterceptor_3_0::_narrow (ior_interceptor);
 173       if (!CORBA::is_nil (ior_3_interceptor.in ()))
 174         {
 175           ior_3_interceptor->adapter_state_changed (seq_obj_ref_template, state);
 176         }
 177     }
 178 }
 179
 180 void
 181 TAO_IORInterceptor_Adapter_Impl::adapter_manager_state_changed (
 182       const char * id,
 183       PortableInterceptor::AdapterState state)
 184 {
 185   /// Whenever the POAManager state is changed, the
 186   /// adapter_manager_state_changed method is to be invoked on all the IOR
 187   ///  Interceptors.
 188   size_t const interceptor_count = this->ior_interceptor_list_.size ();
 189
 190   if (interceptor_count == 0)
 191     return;
 192
 193   for (size_t i = 0; i < interceptor_count; ++i)
 194     {
 195       PortableInterceptor::IORInterceptor_ptr ior_interceptor =
 196         this->ior_interceptor_list_.interceptor (i);
 197
 198       PortableInterceptor::IORInterceptor_3_0_var ior_3_interceptor =
 199         PortableInterceptor::IORInterceptor_3_0::_narrow (ior_interceptor);
 200       if (!CORBA::is_nil (ior_3_interceptor.in ()))
 201         {
 202           ior_3_interceptor->adapter_manager_state_changed (id, state);
 203         }
 204     }
 205 }
 206
 207 TAO_END_VERSIONED_NAMESPACE_DECL