TAO::LocateRequest_Invocation Class Reference

Object created by TAO::LocateRequest_Invocation_Adapter to create and send LocateRequest invocation. More...

#include <LocateRequest_Invocation.h>

Inheritance diagram for TAO::LocateRequest_Invocation:

[legend]Collaboration diagram for TAO::LocateRequest_Invocation:

[legend]List of all members.

Public Member Functions
	LocateRequest_Invocation (CORBA::Object_ptr otarget, Profile_Transport_Resolver &resolver, TAO_Operation_Details &detail)
Invocation_Status	invoke (ACE_Time_Value *max_wait_time)
	Start the invocation.
Private Member Functions
Invocation_Status	check_reply (TAO_Synch_Reply_Dispatcher &rd)
	Helper to check the reply status.

---

Detailed Description

Object created by TAO::LocateRequest_Invocation_Adapter to create and send LocateRequest invocation.

Definition at line 40 of file LocateRequest_Invocation.h.

---

Constructor & Destructor Documentation

TAO::LocateRequest_Invocation::LocateRequest_Invocation	(	CORBA::Object_ptr	otarget,
		Profile_Transport_Resolver &	resolver,
		TAO_Operation_Details &	detail
	)

Parameters:

	otarget	The target on which this invocation was started.
	resolver	Container of the profile and transport on which this invocation is on
	detail	Operation details of the invocation on target. This is of no practical importance since it is not used in this class. This is just to keep our base class happy.

Definition at line 23 of file LocateRequest_Invocation.cpp.

    : Synch_Twoway_Invocation (otarget,
                               resolver,
                               detail)
  {
  }

---

Member Function Documentation

Invocation_Status TAO::LocateRequest_Invocation::check_reply

(

TAO_Synch_Reply_Dispatcher &

rd

)

[private]

Helper to check the reply status.

Definition at line 97 of file LocateRequest_Invocation.cpp.

References TAO_Transport::assign_translators(), CORBA::COMPLETED_MAYBE, CORBA::COMPLETED_YES, TAO_Reply_Dispatcher::locate_reply_status(), TAO::Profile_Transport_Resolver::profile(), ACE_InputCDR::read_short(), TAO_Synch_Reply_Dispatcher::reply_cdr(), TAO::TAO_INVOKE_RESTART, TAO::TAO_INVOKE_SUCCESS, TAO::Profile_Transport_Resolver::transport(), and TAO::VMCID.

Referenced by invoke().

  {
    TAO_InputCDR &cdr = rd.reply_cdr ();

    // Set the translators
    this->resolver_.transport ()->assign_translators (&cdr, 0);

    switch (rd.locate_reply_status ())
      {
      case GIOP::OBJECT_HERE:
        break;
      case GIOP::UNKNOWN_OBJECT:
        throw ::CORBA::OBJECT_NOT_EXIST (TAO::VMCID, CORBA::COMPLETED_YES);
      case GIOP::OBJECT_FORWARD:
      case GIOP::OBJECT_FORWARD_PERM:
        return this->location_forward (cdr);
      case GIOP::LOC_SYSTEM_EXCEPTION:
        {
          // Pull the exception from the stream.
          CORBA::String_var buf;

          if ((cdr >> buf.inout ()) == 0)
            {
              // Could not demarshal the exception id, raise a local
              // CORBA::MARSHAL exception.
              throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_MAYBE);
            }

          // This kind of exception shouldn't happen with locate requests,
          // but if it does, we turn it into a CORBA::UNKNOWN exception.
          throw ::CORBA::UNKNOWN (TAO::VMCID, CORBA::COMPLETED_YES);
        }
      case GIOP::LOC_NEEDS_ADDRESSING_MODE:
        {
          // We have received an exception with a request to change the
          // addressing mode. First let us read the mode that the
          // server/agent asks for.
          CORBA::Short addr_mode = 0;

          if (cdr.read_short (addr_mode) == 0)
            {
              // Could not demarshal the addressing disposition, raise a local
              // CORBA::MARSHAL exception.
              throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_MAYBE);
            }

          // Now set this addressing mode in the profile, so that
          // the next invocation need not go through this.
          this->resolver_.profile ()->addressing_mode (addr_mode);

          // Restart the invocation.
          return TAO_INVOKE_RESTART;
        }
      }

    return TAO_INVOKE_SUCCESS;
  }

Invocation_Status TAO::LocateRequest_Invocation::invoke

(

ACE_Time_Value *

max_wait_time

)

Start the invocation.

Definition at line 35 of file LocateRequest_Invocation.cpp.

References check_reply(), CORBA::COMPLETED_NO, TAO_Transport::generate_locate_request(), TAO_Transport::out_stream(), TAO_Operation_Details::reply_service_info(), TAO::TAO_INVOKE_FAILURE, TAO::TAO_INVOKE_SUCCESS, TAO_Transport::TAO_TWOWAY_REQUEST, TAO_Transport::tms(), TAO::Profile_Transport_Resolver::transport(), ACE_Countdown_Time::update(), and TAO::VMCID.

  {
    ACE_Countdown_Time countdown (max_wait_time);

    TAO_Synch_Reply_Dispatcher rd (this->resolver_.stub ()->orb_core (),
                                   this->details_.reply_service_info ());

    // Register a reply dispatcher for this invocation. Use the
    // preallocated reply dispatcher.
    TAO_Bind_Dispatcher_Guard dispatch_guard (this->details_.request_id (),
                                              &rd,
                                              this->resolver_.transport ()->tms ());

    if (dispatch_guard.status () != 0)
      {
        // @@ What is the right way to handle this error? Do we need
        // to call the interceptors in this case?
        this->resolver_.transport ()->close_connection ();

        throw ::CORBA::INTERNAL (TAO::VMCID, CORBA::COMPLETED_NO);
      }

    TAO_Target_Specification tspec;
    this->init_target_spec (tspec);

    TAO_Transport *transport = this->resolver_.transport ();

    TAO_OutputCDR &cdr = transport->out_stream ();

    if (transport->generate_locate_request (tspec, this->details_, cdr) == -1)
      return TAO_INVOKE_FAILURE;

    countdown.update ();

    Invocation_Status s =
      this->send_message (cdr, TAO_Transport::TAO_TWOWAY_REQUEST, max_wait_time);

    if (s != TAO_INVOKE_SUCCESS)
      return s;

    countdown.update ();

    // For some strategies one may want to release the transport
    // back to  cache. If the idling is successfull let the
    // resolver about that.
    if (this->resolver_.transport ()->idle_after_send ())
      this->resolver_.transport_released ();

    s = this->wait_for_reply (max_wait_time, rd, dispatch_guard);

    s = this->check_reply (rd);

    // For some strategies one may want to release the transport
    // back to  cache after receiving the reply. If the idling is
    // successfull let the resolver about that.
    if (this->resolver_.transport ()->idle_after_reply ())
      this->resolver_.transport_released ();

    return s;
  }

---

The documentation for this class was generated from the following files:

• LocateRequest_Invocation.h
• LocateRequest_Invocation.cpp

---