LocateRequest_Invocation_Adapter.cpp

Go to the documentation of this file.
00001 #include "tao/LocateRequest_Invocation_Adapter.h"
00002 #include "tao/Profile_Transport_Resolver.h"
00003 #include "tao/operation_details.h"
00004 #include "tao/LocateRequest_Invocation.h"
00005 #include "tao/Transport.h"
00006 #include "tao/Transport_Mux_Strategy.h"
00007 #include "tao/GIOP_Utils.h"
00008 #include "tao/ORB_Core.h"
00009 #include "tao/Stub.h"
00010 #include "tao/SystemException.h"
00011 #include "ace/Service_Config.h"
00012 
00013 ACE_RCSID (tao,
00014            LocateRequest_Invocation_Adapter,
00015            "$Id: LocateRequest_Invocation_Adapter.cpp 81632 2008-05-07 09:19:05Z vzykov $")
00016 
00017 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00018 
00019 namespace TAO
00020 {
00021   LocateRequest_Invocation_Adapter::LocateRequest_Invocation_Adapter (
00022     CORBA::Object_ptr target)
00023     : target_ (target)
00024     , list_ (0)
00025   {
00026   }
00027 
00028   void
00029   LocateRequest_Invocation_Adapter::invoke (void)
00030   {
00031     CORBA::Object_var effective_target =
00032       CORBA::Object::_duplicate (this->target_);
00033 
00034     TAO_Stub * const stub =
00035       this->target_->_stubobj ();
00036     if (stub == 0)
00037       throw ::CORBA::INTERNAL (
00038                      CORBA::SystemException::_tao_minor_code (
00039                        0,
00040                          EINVAL),
00041                         CORBA::COMPLETED_NO);
00042 
00043     // The invocation has got to be within the context of the
00044     // corresponding ORB's configuration. Otherwise things like
00045     // timeout hooks, etc may not work as expected. Especially if
00046     // there are multiple ORB instances in the process, each with its
00047     // own, local configuration.
00048     ACE_Service_Config_Guard scg (stub->orb_core ()->configuration ());
00049 
00050     ACE_Time_Value tmp_wait_time;
00051     ACE_Time_Value *max_wait_time = 0;
00052 
00053     if (this->get_timeout (tmp_wait_time))
00054       max_wait_time = &tmp_wait_time;
00055 
00056     Invocation_Status s = TAO_INVOKE_START;
00057 
00058     while (s == TAO_INVOKE_START ||
00059            s == TAO_INVOKE_RESTART)
00060       {
00061         Profile_Transport_Resolver resolver (effective_target.in (), stub, true);
00062 
00063         try
00064           {
00065             resolver.init_inconsistent_policies ();
00066 
00067             resolver.resolve (max_wait_time);
00068 
00069             if (!resolver.transport ())
00070               {
00071                 // We failed to find a profile we could connect to.
00072                 throw CORBA::TRANSIENT (CORBA::OMGVMCID | 2, CORBA::COMPLETED_NO);
00073               }
00074 
00075             // Dummy operation details that is used to instantiate the
00076             // LocateRequest class.
00077             TAO_Operation_Details op (0, 0);
00078 
00079             op.request_id (resolver.transport ()->tms ()->request_id ());
00080             TAO::LocateRequest_Invocation synch (this->target_, resolver, op);
00081 
00082             s = synch.invoke (max_wait_time);
00083             if (s == TAO_INVOKE_RESTART &&
00084                 (synch.reply_status () == GIOP::LOCATION_FORWARD ||
00085                  synch.reply_status () == GIOP::LOCATION_FORWARD_PERM))
00086               {
00087                 CORBA::Boolean const is_permanent_forward =
00088                   (synch.reply_status () == GIOP::LOCATION_FORWARD_PERM);
00089 
00090                 effective_target = synch.steal_forwarded_reference ();
00091 
00092                 this->object_forwarded (effective_target,
00093                                         resolver.stub (),
00094                                         is_permanent_forward);
00095               }
00096           }
00097         catch (const ::CORBA::INV_POLICY&)
00098           {
00099             this->list_ = resolver.steal_inconsistent_policies ();
00100             throw;
00101           }
00102       }
00103 
00104     return;
00105   }
00106 
00107   CORBA::PolicyList *
00108   LocateRequest_Invocation_Adapter::get_inconsistent_policies (void)
00109   {
00110     return this->list_._retn ();
00111   }
00112 
00113   bool
00114   LocateRequest_Invocation_Adapter::get_timeout (ACE_Time_Value &timeout)
00115   {
00116     bool has_timeout = false;
00117     this->target_->orb_core ()->call_timeout_hook (this->target_->_stubobj (),
00118                                                    has_timeout,
00119                                                    timeout);
00120 
00121     return has_timeout;
00122   }
00123 
00124   void
00125   LocateRequest_Invocation_Adapter::object_forwarded (
00126     CORBA::Object_var &effective_target,
00127     TAO_Stub *stub,
00128     CORBA::Boolean permanent_forward)
00129   {
00130     // The object pointer has to be changed to a TAO_Stub pointer
00131     // in order to obtain the profiles.
00132     TAO_Stub *stubobj = 0;
00133 
00134     bool nil_forward_ref = false;
00135     if (CORBA::is_nil (effective_target.in ()))
00136       nil_forward_ref = true;
00137     else
00138       {
00139         stubobj =
00140           effective_target->_stubobj ();
00141 
00142         if (stubobj && stubobj->base_profiles ().size () == 0)
00143           nil_forward_ref = true;
00144       }
00145 
00146     if (nil_forward_ref)
00147       throw ::CORBA::TRANSIENT (
00148         CORBA::SystemException::_tao_minor_code (
00149           TAO_INVOCATION_LOCATION_FORWARD_MINOR_CODE,
00150           errno),
00151         CORBA::COMPLETED_NO);
00152 
00153     if (stubobj == 0)
00154       throw ::CORBA::INTERNAL (
00155         CORBA::SystemException::_tao_minor_code (
00156           TAO_INVOCATION_LOCATION_FORWARD_MINOR_CODE,
00157           errno),
00158         CORBA::COMPLETED_NO);
00159 
00160     // Reset the profile in the stubs
00161     stub->add_forward_profiles (stubobj->base_profiles (), permanent_forward);
00162 
00163     if (stub->next_profile () == 0)
00164       throw ::CORBA::TRANSIENT (
00165         CORBA::SystemException::_tao_minor_code (
00166           TAO_INVOCATION_LOCATION_FORWARD_MINOR_CODE,
00167           errno),
00168         CORBA::COMPLETED_NO);
00169 
00170     return;
00171   }
00172 
00173 } // End namespace TAO
00174 
00175 TAO_END_VERSIONED_NAMESPACE_DECL

Generated on Tue Feb 2 17:37:52 2010 for TAO by  doxygen 1.4.7