TAO/tao/Invocation_Base.cpp

   1 #include "tao/Invocation_Base.h"
   2 #include "tao/Stub.h"
   3 #include "tao/operation_details.h"
   4 #include "tao/ORB_Core.h"
   5 #include "tao/SystemException.h"
   6 #include "tao/PortableInterceptor.h"  /* Must always be visible. */
   7
   8 #include "ace/Dynamic_Service.h"
   9
  10 #if TAO_HAS_INTERCEPTORS == 1
  11 # include "tao/PortableInterceptorC.h"
  12 #endif /* TAO_HAS_INTERCEPTORS == 1 */
  13
  14 #if !defined (__ACE_INLINE__)
  15 # include "tao/Invocation_Base.inl"
  16 #endif /* __ACE_INLINE__ */
  17
  18 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  19
  20 namespace
  21 {
  22   // Exception used to represent non-CORBA exceptions.  A global
  23   // instance is used since it will never be modified.
  24   CORBA::UNKNOWN /* const */ unknown_exception;
  25 }
  26
  27 namespace TAO
  28 {
  29   Invocation_Base::Invocation_Base (CORBA::Object_ptr ot,
  30                                     CORBA::Object_ptr t,
  31                                     TAO_Stub *stub,
  32                                     TAO_Operation_Details &details,
  33                                     bool response_expected,
  34                                     bool TAO_INTERCEPTOR (request_is_remote))
  35     : details_ (details)
  36     , forwarded_to_ (nullptr)
  37     , response_expected_ (response_expected)
  38     , reply_status_ (GIOP::NO_EXCEPTION)
  39     , otarget_ (ot)
  40     , target_ (t)
  41     , stub_ (stub)
  42 #if TAO_HAS_INTERCEPTORS == 1
  43     , cri_adapter_ (stub_->orb_core ()->clientrequestinterceptor_adapter ())
  44     , sri_adapter_ (stub_->orb_core ()->serverrequestinterceptor_adapter ())
  45     , stack_size_ (0)
  46     , invoke_status_ (TAO_INVOKE_START)
  47     , caught_exception_ (nullptr)
  48     , is_remote_request_ (request_is_remote)
  49 #endif /* TAO_HAS_INTERCEPTORS == 1 */
  50   {
  51   }
  52
  53   Invocation_Base::~Invocation_Base ()
  54   {
  55     TAO_INTERCEPTOR (cri_adapter_= nullptr);
  56     TAO_INTERCEPTOR (sri_adapter_= nullptr);
  57   }
  58
  59   TAO_Service_Context &
  60   Invocation_Base::request_service_context ()
  61   {
  62     return this->details_.request_service_context ();
  63   }
  64
  65   TAO_Service_Context &
  66   Invocation_Base::reply_service_context ()
  67   {
  68     return this->details_.reply_service_context ();
  69   }
  70
  71 #if TAO_HAS_INTERCEPTORS == 1
  72   Invocation_Status
  73   Invocation_Base::send_request_interception ()
  74   {
  75     if (cri_adapter_)
  76       {
  77         try
  78           {
  79             // This is a begin interception point
  80             this->cri_adapter_->send_request (*this);
  81           }
  82         catch ( ::CORBA::Exception& ex)
  83           {
  84             (void) this->handle_any_exception (&ex);
  85             throw;
  86           }
  87         catch (...)
  88           {
  89             (void) this->handle_all_exception ();
  90             throw;
  91           }
  92
  93         if (this->reply_status_ == GIOP::LOCATION_FORWARD)
  94           return TAO_INVOKE_RESTART;
  95
  96         this->cri_adapter_->pushTSC (this->stub_->orb_core ());
  97       }
  98     else if (sri_adapter_)
  99       {
 100         this->sri_adapter_->pushTSC (this->stub_->orb_core ());
 101       }
 102
 103     // What are the other cases??
 104     return TAO_INVOKE_SUCCESS;
 105   }
 106
 107   Invocation_Status
 108   Invocation_Base::receive_reply_interception ()
 109   {
 110     if (cri_adapter_)
 111       {
 112         try
 113           {
 114             this->cri_adapter_->popTSC (this->stub_->orb_core ());
 115             this->cri_adapter_->receive_reply (*this);
 116           }
 117         catch ( ::CORBA::Exception& ex)
 118           {
 119             (void) this->handle_any_exception (&ex);
 120             throw;
 121           }
 122         catch (...)
 123           {
 124             (void) this->handle_all_exception ();
 125             throw;
 126           }
 127
 128         if (this->reply_status_ == GIOP::LOCATION_FORWARD)
 129           return TAO_INVOKE_RESTART;
 130       }
 131     else if (sri_adapter_)
 132       {
 133         this->sri_adapter_->popTSC (this->stub_->orb_core ());
 134       }
 135
 136     return TAO_INVOKE_SUCCESS;
 137   }
 138
 139   Invocation_Status
 140   Invocation_Base::receive_other_interception ()
 141   {
 142     if (cri_adapter_)
 143       {
 144         try
 145           {
 146             this->cri_adapter_->popTSC (this->stub_->orb_core ());
 147             this->cri_adapter_->receive_other (*this);
 148           }
 149         catch ( ::CORBA::Exception& ex)
 150           {
 151             (void) this->handle_any_exception (&ex);
 152             throw;
 153           }
 154         catch (...)
 155           {
 156             (void) this->handle_all_exception ();
 157             throw;
 158           }
 159
 160         if (this->reply_status_ == GIOP::LOCATION_FORWARD)
 161           return TAO_INVOKE_RESTART;
 162       }
 163     else if (sri_adapter_)
 164       {
 165         this->sri_adapter_->popTSC (this->stub_->orb_core ());
 166       }
 167
 168     return TAO_INVOKE_SUCCESS;
 169   }
 170
 171   PortableInterceptor::ReplyStatus
 172   Invocation_Base::handle_any_exception (CORBA::Exception *ex)
 173   {
 174     this->exception (ex);
 175
 176     PortableInterceptor::ReplyStatus status =
 177       PortableInterceptor::SYSTEM_EXCEPTION;
 178
 179     if (cri_adapter_)
 180       {
 181         this->cri_adapter_->popTSC (this->stub_->orb_core ());
 182         this->cri_adapter_->receive_exception (*this);
 183
 184         if (this->reply_status_ == GIOP::LOCATION_FORWARD)
 185           {
 186             status = PortableInterceptor::LOCATION_FORWARD;
 187           }
 188         else
 189           {
 190             status = this->cri_adapter_->pi_reply_status (*this);
 191           }
 192       }
 193     else if (sri_adapter_)
 194       {
 195         this->sri_adapter_->popTSC (this->stub_->orb_core ());
 196       }
 197
 198     return status;
 199   }
 200
 201   PortableInterceptor::ReplyStatus
 202   Invocation_Base::handle_all_exception ()
 203   {
 204     this->exception (&unknown_exception);
 205
 206     PortableInterceptor::ReplyStatus status =
 207       PortableInterceptor::SYSTEM_EXCEPTION;
 208
 209     if (cri_adapter_)
 210       {
 211         this->cri_adapter_->popTSC (this->stub_->orb_core ());
 212         this->cri_adapter_->receive_exception (*this);
 213
 214         status = this->cri_adapter_->pi_reply_status (*this);
 215       }
 216     else if (sri_adapter_)
 217       {
 218         this->sri_adapter_->popTSC (this->stub_->orb_core ());
 219       }
 220
 221     return status;
 222   }
 223
 224   void
 225   Invocation_Base::exception (CORBA::Exception *exception)
 226   {
 227     if (CORBA::SystemException::_downcast (exception) != nullptr)
 228       this->invoke_status_ = TAO::TAO_INVOKE_SYSTEM_EXCEPTION;
 229     else if (CORBA::UserException::_downcast (exception) != nullptr)
 230       this->invoke_status_ = TAO::TAO_INVOKE_USER_EXCEPTION;
 231
 232     this->forwarded_to_ = CORBA::Object::_nil ();
 233     this->reply_status_ = GIOP::NO_EXCEPTION;
 234     this->caught_exception_ = exception;
 235   }
 236
 237   PortableInterceptor::ReplyStatus
 238   Invocation_Base::pi_reply_status () const
 239   {
 240     if (cri_adapter_)
 241       {
 242         return this->cri_adapter_->pi_reply_status (*this);
 243       }
 244     else
 245       {
 246         return -1;
 247       }
 248   }
 249 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 250 }
 251
 252 TAO_END_VERSIONED_NAMESPACE_DECL