TAO/tao/LocateRequest_Invocation.cpp

   1 // -*- C++ -*-
   2 #include "tao/LocateRequest_Invocation.h"
   3 #include "tao/Profile_Transport_Resolver.h"
   4 #include "tao/operation_details.h"
   5 #include "tao/Stub.h"
   6 #include "tao/Bind_Dispatcher_Guard.h"
   7 #include "tao/Transport.h"
   8 #include "tao/Synch_Reply_Dispatcher.h"
   9 #include "tao/GIOP_Utils.h"
  10 #include "tao/Profile.h"
  11 #include "tao/ORB_Constants.h"
  12 #include "tao/SystemException.h"
  13 #include "ace/Intrusive_Auto_Ptr.h"
  14
  15 #include "tao/ORB_Time_Policy.h"
  16
  17 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 namespace TAO
  20 {
  21   /**
  22    * @class First_Request_Guard
  23    *
  24    * @brief Unique pointer like class for first_request flag in transport.
  25    *
  26    * Since codeset service context is only sent in the first request it might
  27    * happen that after LocateRequest (which doesn't include service context)
  28    * no codeset negotiation happens in subsequent calls. In this respect
  29    * LocateRequest is not the first request and thus First_Request_Guard
  30    * restores first_request in transport to its original state.
  31    */
  32   class First_Request_Guard
  33   {
  34   public:
  35     First_Request_Guard (TAO_Transport &transport);
  36
  37     ~First_Request_Guard ();
  38
  39   private:
  40     /// The transport that we guard.
  41     TAO_Transport &transport_;
  42
  43     /// Original value of first_request from transport.
  44     bool is_first_;
  45   };
  46
  47   First_Request_Guard::First_Request_Guard (TAO_Transport &transport)
  48     : transport_ (transport)
  49   {
  50     this->is_first_ = this->transport_.first_request ();
  51   }
  52
  53   First_Request_Guard::~First_Request_Guard ()
  54   {
  55     this->transport_.first_request_sent (this->is_first_);
  56   }
  57
  58   LocateRequest_Invocation::LocateRequest_Invocation (
  59       CORBA::Object_ptr otarget,
  60       Profile_Transport_Resolver &resolver,
  61       TAO_Operation_Details &detail
  62     )
  63     : Synch_Twoway_Invocation (otarget,
  64                                resolver,
  65                                detail)
  66   {
  67   }
  68
  69   Invocation_Status
  70   LocateRequest_Invocation::invoke (ACE_Time_Value *max_wait_time)
  71   {
  72     TAO::ORB_Countdown_Time countdown (max_wait_time);
  73
  74     TAO_Synch_Reply_Dispatcher *rd_p =
  75       new (std::nothrow) TAO_Synch_Reply_Dispatcher (this->resolver_.stub ()->orb_core (),
  76                                                      this->details_.reply_service_info ());
  77     if (!rd_p)
  78       {
  79         throw ::CORBA::NO_MEMORY ();
  80       }
  81
  82     ACE_Intrusive_Auto_Ptr<TAO_Synch_Reply_Dispatcher> rd(rd_p, false);
  83
  84     // Register a reply dispatcher for this invocation. Use the
  85     // preallocated reply dispatcher.
  86     TAO_Bind_Dispatcher_Guard dispatch_guard (this->details_.request_id (),
  87                                               rd.get (),
  88                                               this->resolver_.transport ()->tms ());
  89
  90     if (dispatch_guard.status () != 0)
  91       {
  92         // @@ What is the right way to handle this error? Do we need
  93         // to call the interceptors in this case?
  94         this->resolver_.transport ()->close_connection ();
  95
  96         throw ::CORBA::INTERNAL (TAO::VMCID, CORBA::COMPLETED_NO);
  97       }
  98
  99     TAO_Transport *transport = this->resolver_.transport ();
 100
 101     Invocation_Status s = TAO_INVOKE_FAILURE;
 102     {
 103       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon,
 104                         transport->output_cdr_lock (), TAO_INVOKE_FAILURE);
 105       TAO_OutputCDR &cdr = transport->out_stream ();
 106
 107       // This must restore first_request flag after message is sent.
 108       First_Request_Guard fr_quard (*transport);
 109
 110       TAO_Target_Specification tspec;
 111       this->init_target_spec (tspec, cdr);
 112
 113       if (transport->generate_locate_request (tspec, this->details_, cdr) == -1)
 114         return TAO_INVOKE_FAILURE;
 115
 116       countdown.update ();
 117
 118       s = this->send_message (cdr, TAO_Message_Semantics (), max_wait_time);
 119     }
 120
 121     if (s != TAO_INVOKE_SUCCESS)
 122       return s;
 123
 124     countdown.update ();
 125
 126     // For some strategies one may want to release the transport
 127     // back to cache. If the idling is successful let the
 128     // resolver about that.
 129     if (this->resolver_.transport ()->idle_after_send ())
 130       this->resolver_.transport_released ();
 131
 132     s = this->wait_for_reply (max_wait_time, *rd.get (), dispatch_guard);
 133
 134     s = this->check_reply (*rd.get ());
 135
 136     // For some strategies one may want to release the transport
 137     // back to  cache after receiving the reply. If the idling is
 138     // successful let the resolver about that.
 139     if (this->resolver_.transport ()->idle_after_reply ())
 140       this->resolver_.transport_released ();
 141
 142     return s;
 143   }
 144
 145   Invocation_Status
 146   LocateRequest_Invocation::check_reply (TAO_Synch_Reply_Dispatcher &rd)
 147   {
 148     TAO_InputCDR &cdr = rd.reply_cdr ();
 149
 150     // Set the translators
 151     this->resolver_.transport ()->assign_translators (&cdr, nullptr);
 152
 153     switch (rd.locate_reply_status ())
 154       {
 155       case GIOP::OBJECT_HERE:
 156         break;
 157       case GIOP::UNKNOWN_OBJECT:
 158         throw ::CORBA::OBJECT_NOT_EXIST (TAO::VMCID, CORBA::COMPLETED_YES);
 159       case GIOP::OBJECT_FORWARD:
 160       case GIOP::OBJECT_FORWARD_PERM:
 161         return this->location_forward (cdr);
 162       case GIOP::LOC_SYSTEM_EXCEPTION:
 163         {
 164           // Pull the exception from the stream.
 165           CORBA::String_var buf;
 166
 167           if ((cdr >> buf.inout ()) == 0)
 168             {
 169               // Could not demarshal the exception id, raise a local
 170               // CORBA::MARSHAL exception.
 171               throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_MAYBE);
 172             }
 173
 174           // This kind of exception shouldn't happen with locate requests,
 175           // but if it does, we turn it into a CORBA::UNKNOWN exception.
 176           throw ::CORBA::UNKNOWN (TAO::VMCID, CORBA::COMPLETED_YES);
 177         }
 178       case GIOP::LOC_NEEDS_ADDRESSING_MODE:
 179         {
 180           // We have received an exception with a request to change the
 181           // addressing mode. First let us read the mode that the
 182           // server/agent asks for.
 183           CORBA::Short addr_mode = 0;
 184
 185           if (cdr.read_short (addr_mode) == 0)
 186             {
 187               // Could not demarshal the addressing disposition, raise a local
 188               // CORBA::MARSHAL exception.
 189               throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_MAYBE);
 190             }
 191
 192           // Now set this addressing mode in the profile, so that
 193           // the next invocation need not go through this.
 194           this->resolver_.profile ()->addressing_mode (addr_mode);
 195
 196           // Restart the invocation.
 197           return TAO_INVOKE_RESTART;
 198         }
 199       }
 200
 201     return TAO_INVOKE_SUCCESS;
 202   }
 203 }
 204
 205 TAO_END_VERSIONED_NAMESPACE_DECL