Generic interface for the invocation object visible to the IDL compiler. More...
#include <Invocation_Adapter.h>
Public Member Functions | |
| Invocation_Adapter (CORBA::Object_ptr target, Argument **args, int arg_number, const char *operation, size_t op_len, Collocation_Proxy_Broker *cpb, TAO::Invocation_Type type=TAO_TWOWAY_INVOCATION, TAO::Invocation_Mode mode=TAO_SYNCHRONOUS_INVOCATION) | |
| virtual | ~Invocation_Adapter (void) |
| virtual void | invoke (TAO::Exception_Data *ex, unsigned long ex_count) |
| Invoke the target, and used by the generated code. | |
Protected Member Functions | |
| virtual void | invoke_i (TAO_Stub *stub, TAO_Operation_Details &details) |
| bool | get_timeout (TAO_Stub *stub, ACE_Time_Value &val) |
| TAO_Stub * | get_stub (void) const |
| Helper method that extracts TAO_Stub from the target object. | |
| void | object_forwarded (CORBA::Object_var &effective_target, TAO_Stub *stub, CORBA::Boolean permanent_forward) |
| void | set_response_flags (TAO_Stub *stub, TAO_Operation_Details &details) |
| Helper method to set the response flags within details. | |
Helper methods for making different types of invocations. | |
| virtual Invocation_Status | invoke_remote_i (TAO_Stub *stub, TAO_Operation_Details &details, CORBA::Object_var &effective_target, ACE_Time_Value *&max_wait_time) |
| virtual Invocation_Status | invoke_collocated_i (TAO_Stub *stub, TAO_Operation_Details &details, CORBA::Object_var &effective_target, Collocation_Strategy strat) |
| Make a collocated call. | |
| virtual Invocation_Status | invoke_twoway (TAO_Operation_Details &details, CORBA::Object_var &effective_target, Profile_Transport_Resolver &r, ACE_Time_Value *&max_wait_time) |
| Helper method to make a two way invocation. | |
| virtual Invocation_Status | invoke_oneway (TAO_Operation_Details &details, CORBA::Object_var &effective_target, Profile_Transport_Resolver &r, ACE_Time_Value *&max_wait_time) |
| Helper method to make a one way invocation. | |
Protected Attributes | |
| CORBA::Object_ptr | target_ |
| The target object on which this invocation is carried out. | |
| Argument **const | args_ |
| Array of arguments for this operation. | |
| int const | number_args_ |
| Number of arguments for this operation. | |
| char const * | operation_ |
| Name of the operation. | |
| size_t const | op_len_ |
| String length of the operation name. | |
| Collocation_Proxy_Broker *const | cpb_ |
| Collocation proxy broker for this operation. | |
| Invocation_Type const | type_ |
| The invocation type. | |
| Invocation_Mode const | mode_ |
| The invocation mode. | |
Private Member Functions | |
| Invocation_Adapter (void) | |
| Dont allow default initializations. | |
| Invocation_Adapter (Invocation_Adapter const &) | |
| Invocation_Adapter & | operator= (const Invocation_Adapter &) |
Generic interface for the invocation object visible to the IDL compiler.
The main objective of this class is to adapt the type and invocation specific information declared in the IDL by the application and convert them as CORBA invocations to the target object. Implementation of this class knows how to make invocations on a collocated or a remote object.
This adapter class serves as the base class for various types of invocations like AMI, DII, DSI etc. Adapter classes for AMI, DII, DSI inherit from this class and their local behavioural information before kicking off an invocation.
@ More info.. Wafer thin inclusions All stuff created on stack Only handles starts and restarts
Definition at line 75 of file Invocation_Adapter.h.
| TAO::Invocation_Adapter::Invocation_Adapter | ( | CORBA::Object_ptr | target, | |
| Argument ** | args, | |||
| int | arg_number, | |||
| const char * | operation, | |||
| size_t | op_len, | |||
| Collocation_Proxy_Broker * | cpb, | |||
| TAO::Invocation_Type | type = TAO_TWOWAY_INVOCATION, |
|||
| TAO::Invocation_Mode | mode = TAO_SYNCHRONOUS_INVOCATION | |||
| ) |
The only constructor used by the IDL compiler, and only way to create this adapter.
| target | Points to the object on which this invocation is being invoked. | |
| args | Array of pointers to the argument list in the operation declaration. This includes the return, inout and out arguments. | |
| arg_number | Number of arguments in the above array. This is the number of elements in the above array. | |
| operation | The name of the operation being invoked. | |
| op_len | Number of charecters in the operation name. This is an optimization which helps us to avoid calling strlen () while creating a message format. | |
| cpb | The collocation proxy broker for the target if one exists. This is useful especially to route the call to the collocated target. | |
| type | The operation type which could be a oneway or two way operation. This information is available in the IDL file. | |
| mode | Invocation mode. This information is also available in the IDL file and in the generated code. |
| TAO::Invocation_Adapter::~Invocation_Adapter | ( | void | ) | [virtual] |
Definition at line 32 of file Invocation_Adapter.cpp.
{
}
| TAO::Invocation_Adapter::Invocation_Adapter | ( | void | ) | [private] |
Dont allow default initializations.
| TAO::Invocation_Adapter::Invocation_Adapter | ( | Invocation_Adapter const & | ) | [private] |
| TAO_Stub * TAO::Invocation_Adapter::get_stub | ( | void | ) | const [protected] |
Helper method that extracts TAO_Stub from the target object.
Definition at line 137 of file Invocation_Adapter.cpp.
{
TAO_Stub * const stub = this->target_->_stubobj ();
if (stub == 0)
throw ::CORBA::INTERNAL (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
EINVAL),
CORBA::COMPLETED_NO);
return stub;
}
| bool TAO::Invocation_Adapter::get_timeout | ( | TAO_Stub * | stub, | |
| ACE_Time_Value & | val | |||
| ) | [protected] |
Helper function that extracts the roundtrip timeout policies set in the ORB.
Definition at line 128 of file Invocation_Adapter.cpp.
{
bool has_timeout = false;
this->target_->orb_core ()->call_timeout_hook (stub, has_timeout, timeout);
return has_timeout;
}
| void TAO::Invocation_Adapter::invoke | ( | TAO::Exception_Data * | ex, | |
| unsigned long | ex_count | |||
| ) | [virtual] |
Invoke the target, and used by the generated code.
The implementation decides whether the target is remote or collocated and takes the right decision.
| ex | Array of exception data declared by the application in their IDL. | |
| ex_count | Number of elements in the array. |
Reimplemented in TAO::DII_Invocation_Adapter, TAO::DII_Deferred_Invocation_Adapter, and TAO::Asynch_Invocation_Adapter.
Definition at line 37 of file Invocation_Adapter.cpp.
{
// Should stub object be refcounted here?
TAO_Stub *stub = this->get_stub ();
TAO_Operation_Details op_details (this->operation_,
this->op_len_,
this->args_,
this->number_args_,
ex_data,
ex_count);
this->invoke_i (stub, op_details);
}
| Invocation_Status TAO::Invocation_Adapter::invoke_collocated_i | ( | TAO_Stub * | stub, | |
| TAO_Operation_Details & | details, | |||
| CORBA::Object_var & | effective_target, | |||
| Collocation_Strategy | strat | |||
| ) | [protected, virtual] |
Make a collocated call.
This method creates an object that takes care of making collocated invocations and calls invoke () on it. If the invoke () returns with a location forwarded reply we return a restart
| stub | The stub object on which the invocation is made. | |
| details | The operations details of the operation that is being invoked. |
Reimplemented in TAO::DII_Invocation_Adapter, TAO::DII_Deferred_Invocation_Adapter, TAO::DII_Oneway_Invocation_Adapter, and TAO::Asynch_Invocation_Adapter.
Definition at line 152 of file Invocation_Adapter.cpp.
{
// To make a collocated call we must have a collocated proxy broker, the
// invoke_i() will make sure that we only come here when we have one
ACE_ASSERT (cpb_ != 0
|| (strat == TAO_CS_THRU_POA_STRATEGY
&& effective_target->_servant () != 0));
// Initial state
TAO::Invocation_Status status = TAO_INVOKE_START;
Collocated_Invocation coll_inv (this->target_,
effective_target.in (),
stub,
details,
this->type_ == TAO_TWOWAY_INVOCATION);
status = coll_inv.invoke (this->cpb_, strat);
if (status == TAO_INVOKE_RESTART &&
(coll_inv.reply_status () == GIOP::LOCATION_FORWARD ||
coll_inv.reply_status () == GIOP::LOCATION_FORWARD_PERM))
{
CORBA::Boolean const is_permanent_forward =
(coll_inv.reply_status () == GIOP::LOCATION_FORWARD_PERM);
effective_target = coll_inv.steal_forwarded_reference ();
this->object_forwarded (effective_target, stub, is_permanent_forward);
}
return status;
}
| void TAO::Invocation_Adapter::invoke_i | ( | TAO_Stub * | stub, | |
| TAO_Operation_Details & | details | |||
| ) | [protected, virtual] |
The stub pointer passed to this call has all the details about the object to which the invocation needs to be routed to. The implementation of this method looks if we are collocated or not and takes care of reinvoking the target if it receives forwarding information or if the first invocation fails for some reason, like a loss of connection during send () etc.
Definition at line 54 of file Invocation_Adapter.cpp.
{
// The invocation has got to be within the context of the
// corresponding ORB's configuration. Otherwise things like
// timeout hooks, etc may not work as expected. Especially if
// there are multiple ORB instances in the process, each with its
// own, local configuration.
ACE_Service_Config_Guard scg (stub->orb_core ()->configuration ());
// Cache the target to a local variable.
CORBA::Object_var effective_target =
CORBA::Object::_duplicate (this->target_);
// Initial state
TAO::Invocation_Status status = TAO_INVOKE_START;
ACE_Time_Value *max_wait_time = 0;
ACE_Time_Value tmp_wait_time = ACE_Time_Value::zero;
if (this->get_timeout (stub, tmp_wait_time))
{
max_wait_time= &tmp_wait_time;
}
while (status == TAO_INVOKE_START || status == TAO_INVOKE_RESTART)
{
// Default we go to remote
Collocation_Strategy strat = TAO_CS_REMOTE_STRATEGY;
// If we have a collocated proxy broker we look if we maybe
// can use a collocated invocation. Similarly, if the
// target object reference contains a pointer to a servant,
// the object reference also refers to a collocated object.
if (cpb_ != 0 || effective_target->_servant () != 0)
{
strat = TAO_ORB_Core::collocation_strategy (effective_target.in ());
}
if (strat == TAO_CS_REMOTE_STRATEGY || strat == TAO_CS_LAST)
{
status =
this->invoke_remote_i (stub,
details,
effective_target,
max_wait_time);
}
else
{
if (strat == TAO_CS_THRU_POA_STRATEGY)
{
(void) this->set_response_flags (stub, details);
}
status =
this->invoke_collocated_i (stub,
details,
effective_target,
strat);
}
if (status == TAO_INVOKE_RESTART)
{
details.reset_request_service_info ();
details.reset_reply_service_info ();
if (TAO_debug_level > 2)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT("TAO (%P|%t) - Invocation_Adapter::invoke_i, ")
ACE_TEXT("handling forwarded locations\n")));
}
}
}
}
| Invocation_Status TAO::Invocation_Adapter::invoke_oneway | ( | TAO_Operation_Details & | details, | |
| CORBA::Object_var & | effective_target, | |||
| Profile_Transport_Resolver & | r, | |||
| ACE_Time_Value *& | max_wait_time | |||
| ) | [protected, virtual] |
Helper method to make a one way invocation.
This method creates a synchronous oneway invocation object to which the actual task of request handling is delegated. Once the invocation returns this method checks whether the request is forwarded to a new location to take appropriate action.
Definition at line 319 of file Invocation_Adapter.cpp.
{
TAO::Synch_Oneway_Invocation synch (this->target_, r, details);
Invocation_Status const s = synch.remote_oneway (max_wait_time);
if (s == TAO_INVOKE_RESTART &&
(synch.reply_status () == GIOP::LOCATION_FORWARD ||
synch.reply_status () == GIOP::LOCATION_FORWARD_PERM))
{
CORBA::Boolean const is_permanent_forward =
(synch.reply_status () == GIOP::LOCATION_FORWARD_PERM);
effective_target = synch.steal_forwarded_reference ();
this->object_forwarded (effective_target,
r.stub (),
is_permanent_forward);
}
return s;
}
| Invocation_Status TAO::Invocation_Adapter::invoke_remote_i | ( | TAO_Stub * | stub, | |
| TAO_Operation_Details & | details, | |||
| CORBA::Object_var & | effective_target, | |||
| ACE_Time_Value *& | max_wait_time | |||
| ) | [protected, virtual] |
Helper method that prepares the necessary stuff for a remote invocation.
Definition at line 224 of file Invocation_Adapter.cpp.
{
(void) this->set_response_flags (stub, details);
CORBA::Octet const rflags = details.response_flags ();
bool const block_connect =
rflags != static_cast<CORBA::Octet> (Messaging::SYNC_NONE)
&& rflags != static_cast<CORBA::Octet> (TAO::SYNC_DELAYED_BUFFERING);
// Create the resolver which will pick (or create) for us a
// transport and a profile from the effective_target.
Profile_Transport_Resolver resolver (
effective_target.in (),
stub,
block_connect);
resolver.resolve (max_wait_time);
if (TAO_debug_level)
{
if (max_wait_time && *max_wait_time == ACE_Time_Value::zero)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - Invocation_Adapter::invoke_remote_i, ")
ACE_TEXT ("max wait time consumed during transport resolution\n")));
}
// Update the request id now that we have a transport
if (resolver.transport ())
{
details.request_id (resolver.transport ()->tms ()->request_id ());
}
switch (this->type_)
{
case TAO_ONEWAY_INVOCATION:
{
return this->invoke_oneway (details,
effective_target,
resolver,
max_wait_time);
}
case TAO_TWOWAY_INVOCATION:
{
return this->invoke_twoway (details,
effective_target,
resolver,
max_wait_time);
}
}
return TAO_INVOKE_FAILURE;
}
| Invocation_Status TAO::Invocation_Adapter::invoke_twoway | ( | TAO_Operation_Details & | details, | |
| CORBA::Object_var & | effective_target, | |||
| Profile_Transport_Resolver & | r, | |||
| ACE_Time_Value *& | max_wait_time | |||
| ) | [protected, virtual] |
Helper method to make a two way invocation.
This method creates a synchronous twoway invocation object to which the actual task of request handling is delegated. Once the invocation returns this method checks whether the request is forwarded to a new location.
Reimplemented in TAO::DII_Invocation_Adapter, TAO::DII_Deferred_Invocation_Adapter, TAO::DII_Asynch_Invocation_Adapter, and TAO::Asynch_Invocation_Adapter.
Definition at line 281 of file Invocation_Adapter.cpp.
{
// Simple sanity check
if (this->mode_ != TAO_SYNCHRONOUS_INVOCATION ||
this->type_ != TAO_TWOWAY_INVOCATION)
{
throw ::CORBA::INTERNAL (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
EINVAL),
CORBA::COMPLETED_NO);
}
TAO::Synch_Twoway_Invocation synch (this->target_, r, details);
Invocation_Status const status = synch.remote_twoway (max_wait_time);
if (status == TAO_INVOKE_RESTART &&
(synch.reply_status () == GIOP::LOCATION_FORWARD ||
synch.reply_status () == GIOP::LOCATION_FORWARD_PERM))
{
CORBA::Boolean const is_permanent_forward =
(synch.reply_status () == GIOP::LOCATION_FORWARD_PERM);
effective_target = synch.steal_forwarded_reference ();
this->object_forwarded (effective_target,
r.stub (),
is_permanent_forward);
}
return status;
}
| void TAO::Invocation_Adapter::object_forwarded | ( | CORBA::Object_var & | effective_target, | |
| TAO_Stub * | stub, | |||
| CORBA::Boolean | permanent_forward | |||
| ) | [protected] |
Helper method that takes care of setting the profiles within the stub object if the target gets forwarded
Definition at line 346 of file Invocation_Adapter.cpp.
{
// The object pointer has to be changed to a TAO_Stub pointer
// in order to obtain the profiles.
TAO_Stub *stubobj = 0;
bool nil_forward_ref = false;
if (CORBA::is_nil (effective_target.in ()))
nil_forward_ref = true;
else
{
stubobj =
effective_target->_stubobj ();
if (stubobj && stubobj->base_profiles ().size () == 0)
nil_forward_ref = true;
}
if (nil_forward_ref)
throw ::CORBA::TRANSIENT (
CORBA::SystemException::_tao_minor_code (
TAO_INVOCATION_LOCATION_FORWARD_MINOR_CODE,
errno),
CORBA::COMPLETED_NO);
if (stubobj == 0)
throw ::CORBA::INTERNAL (
CORBA::SystemException::_tao_minor_code (
TAO_INVOCATION_LOCATION_FORWARD_MINOR_CODE,
errno),
CORBA::COMPLETED_NO);
// Reset the profile in the stubs
stub->add_forward_profiles (stubobj->base_profiles (), permanent_forward);
if (stub->next_profile () == 0)
throw ::CORBA::TRANSIENT (
CORBA::SystemException::_tao_minor_code (
TAO_INVOCATION_LOCATION_FORWARD_MINOR_CODE,
errno),
CORBA::COMPLETED_NO);
}
| Invocation_Adapter& TAO::Invocation_Adapter::operator= | ( | const Invocation_Adapter & | ) | [private] |
| void TAO::Invocation_Adapter::set_response_flags | ( | TAO_Stub * | stub, | |
| TAO_Operation_Details & | details | |||
| ) | [protected] |
Helper method to set the response flags within details.
Definition at line 190 of file Invocation_Adapter.cpp.
{
switch (this->type_)
{
case TAO_ONEWAY_INVOCATION:
{
// Grab the syncscope policy from the ORB.
Messaging::SyncScope sync_scope;
bool has_synchronization = false;
stub->orb_core ()->call_sync_scope_hook (stub,
has_synchronization,
sync_scope);
if (has_synchronization)
details.response_flags (CORBA::Octet (sync_scope));
else
details.response_flags (
CORBA::Octet (Messaging::SYNC_WITH_TRANSPORT));
break;
}
case TAO_TWOWAY_INVOCATION:
{
// @@note: Need to change this to something better. Too many
// hash defines meaning the same things.
details.response_flags (TAO_TWOWAY_RESPONSE_FLAG);
break;
}
}
}
Argument** const TAO::Invocation_Adapter::args_ [protected] |
Array of arguments for this operation.
Definition at line 245 of file Invocation_Adapter.h.
Collocation_Proxy_Broker* const TAO::Invocation_Adapter::cpb_ [protected] |
Collocation proxy broker for this operation.
Definition at line 260 of file Invocation_Adapter.h.
Invocation_Mode const TAO::Invocation_Adapter::mode_ [protected] |
The invocation mode.
Definition at line 266 of file Invocation_Adapter.h.
int const TAO::Invocation_Adapter::number_args_ [protected] |
Number of arguments for this operation.
This includes the return values too
Definition at line 251 of file Invocation_Adapter.h.
size_t const TAO::Invocation_Adapter::op_len_ [protected] |
String length of the operation name.
Definition at line 257 of file Invocation_Adapter.h.
char const* TAO::Invocation_Adapter::operation_ [protected] |
Name of the operation.
Definition at line 254 of file Invocation_Adapter.h.
CORBA::Object_ptr TAO::Invocation_Adapter::target_ [protected] |
The target object on which this invocation is carried out.
Definition at line 242 of file Invocation_Adapter.h.
Invocation_Type const TAO::Invocation_Adapter::type_ [protected] |
The invocation type.
Definition at line 263 of file Invocation_Adapter.h.
1.7.0