UIOP-specific Connector bridge for pluggable protocols. More...
#include <UIOP_Connector.h>
Public Types | |
| typedef TAO_Connect_Concurrency_Strategy < TAO_UIOP_Connection_Handler > | TAO_UIOP_CONNECT_CONCURRENCY_STRATEGY |
| typedef TAO_Connect_Creation_Strategy < TAO_UIOP_Connection_Handler > | TAO_UIOP_CONNECT_CREATION_STRATEGY |
| typedef ACE_Connect_Strategy < TAO_UIOP_Connection_Handler, ACE_LSOCK_CONNECTOR > | TAO_UIOP_CONNECT_STRATEGY |
| typedef ACE_Strategy_Connector < TAO_UIOP_Connection_Handler, ACE_LSOCK_CONNECTOR > | TAO_UIOP_BASE_CONNECTOR |
Public Member Functions | |
| TAO_UIOP_Connector (void) | |
| ~TAO_UIOP_Connector (void) | |
| Destructor. | |
The TAO_Connector Methods | |
Please check the documentation in Transport_Connector.h for details. | |
| int | open (TAO_ORB_Core *orb_core) |
| Initialize object and register with reactor. | |
| int | close (void) |
| Shutdown Connector bridge and concrete Connector. | |
| TAO_Profile * | create_profile (TAO_InputCDR &cdr) |
| virtual int | check_prefix (const char *endpoint) |
| virtual TAO_Profile * | corbaloc_scan (const char *str, size_t &len) |
| virtual char | object_key_delimiter (void) const |
| Return the object key delimiter to use or expect. | |
| virtual int | cancel_svc_handler (TAO_Connection_Handler *svc_handler) |
| Cancel the passed cvs handler from the connector. | |
Protected Member Functions | |
More TAO_Connector methods | |
Please check the documentation in Transport_Connector.h. | |
| int | set_validate_endpoint (TAO_Endpoint *endpoint) |
| TAO_Transport * | make_connection (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *timeout=0) |
| Make a connection. | |
| virtual TAO_Profile * | make_profile (void) |
| Create a profile with a given endpoint. | |
Private Member Functions | |
| TAO_UIOP_Endpoint * | remote_endpoint (TAO_Endpoint *ep) |
| Return the remote endpoint, a helper function. | |
Private Attributes | |
| TAO_UIOP_CONNECT_STRATEGY | connect_strategy_ |
| Our connect strategy. | |
| TAO_UIOP_BASE_CONNECTOR | base_connector_ |
| The connector initiating connection requests for UIOP. | |
UIOP-specific Connector bridge for pluggable protocols.
Definition at line 49 of file UIOP_Connector.h.
| typedef ACE_Strategy_Connector<TAO_UIOP_Connection_Handler, ACE_LSOCK_CONNECTOR> TAO_UIOP_Connector::TAO_UIOP_BASE_CONNECTOR |
Definition at line 99 of file UIOP_Connector.h.
| typedef TAO_Connect_Concurrency_Strategy<TAO_UIOP_Connection_Handler> TAO_UIOP_Connector::TAO_UIOP_CONNECT_CONCURRENCY_STRATEGY |
Definition at line 88 of file UIOP_Connector.h.
| typedef TAO_Connect_Creation_Strategy<TAO_UIOP_Connection_Handler> TAO_UIOP_Connector::TAO_UIOP_CONNECT_CREATION_STRATEGY |
Definition at line 91 of file UIOP_Connector.h.
| typedef ACE_Connect_Strategy<TAO_UIOP_Connection_Handler, ACE_LSOCK_CONNECTOR> TAO_UIOP_Connector::TAO_UIOP_CONNECT_STRATEGY |
Definition at line 95 of file UIOP_Connector.h.
| TAO_UIOP_Connector::TAO_UIOP_Connector | ( | void | ) |
Constructor. @ Do we want to pass in the tag here or should it be statically defined?
Definition at line 26 of file UIOP_Connector.cpp.
: TAO_Connector (TAO_TAG_UIOP_PROFILE), connect_strategy_ (), base_connector_ () { }
| TAO_UIOP_Connector::~TAO_UIOP_Connector | ( | void | ) |
| int TAO_UIOP_Connector::cancel_svc_handler | ( | TAO_Connection_Handler * | svc_handler | ) | [virtual] |
Cancel the passed cvs handler from the connector.
Implements TAO_Connector.
Definition at line 379 of file UIOP_Connector.cpp.
{
TAO_UIOP_Connection_Handler* handler=
dynamic_cast<TAO_UIOP_Connection_Handler*> (svc_handler);
if (handler)
// Cancel from the connector
return this->base_connector_.cancel (handler);
return -1;
}
| int TAO_UIOP_Connector::check_prefix | ( | const char * | endpoint | ) | [virtual] |
Check that the prefix of the provided endpoint is valid for use with a given pluggable protocol.
Our activation strategy
Implements TAO_Connector.
Definition at line 327 of file UIOP_Connector.cpp.
{
// Check for a valid string
if (!endpoint || !*endpoint)
return -1; // Failure
static const char *protocol[] = { "uiop", "uioploc" };
const size_t slot = ACE_OS::strchr (endpoint, ':') - endpoint;
const size_t len0 = ACE_OS::strlen (protocol[0]);
const size_t len1 = ACE_OS::strlen (protocol[1]);
// Check for the proper prefix in the IOR. If the proper prefix
// isn't in the IOR then it is not an IOR we can use.
if (slot == len0
&& ACE_OS::strncasecmp (endpoint,
protocol[0],
len0) == 0)
return 0;
else if (slot == len1
&& ACE_OS::strncasecmp (endpoint,
protocol[1],
len1) == 0)
return 0;
return -1;
// Failure: not an UIOP IOR DO NOT throw an exception here.
}
| int TAO_UIOP_Connector::close | ( | void | ) | [virtual] |
Shutdown Connector bridge and concrete Connector.
Our activation strategy
Implements TAO_Connector.
Definition at line 69 of file UIOP_Connector.cpp.
{
// Zap the creation strategy that we created earlier.
delete this->base_connector_.creation_strategy ();
delete this->base_connector_.concurrency_strategy ();
return this->base_connector_.close ();
}
| TAO_Profile * TAO_UIOP_Connector::corbaloc_scan | ( | const char * | ior, | |
| size_t & | len | |||
| ) | [virtual] |
Helper function to assist corbaloc parsing. The default simply validates the protocol identifyier and scans up to the next comma or slash. Any protocol that has a specific need, such as uiop, can override this method to provide a custom scanner. The profile returned is either null if this the ior does not match or an empty profile of the correct type, obtained from make_profile().
Our activation strategy
Reimplemented from TAO_Connector.
Definition at line 79 of file UIOP_Connector.cpp.
{
if (this->check_prefix (str) != 0)
return 0;
const char *separator = ACE_OS::strchr (str,'|');
if (separator == 0)
{
if (TAO_debug_level)
ACE_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - TAO_UIOP_CONNECTOR::corbaloc_scan error: "
"explicit terminating charactor '|' is missing from <%C>",
str));
return 0;
}
len = (separator - str) + 1;
return this->make_profile ();
}
| TAO_Profile * TAO_UIOP_Connector::create_profile | ( | TAO_InputCDR & | cdr | ) | [virtual] |
Create a profile for this protocol and initialize it based on the encapsulation in cdr
Our activation strategy
Implements TAO_Connector.
Definition at line 293 of file UIOP_Connector.cpp.
{
TAO_Profile *pfile;
ACE_NEW_RETURN (pfile,
TAO_UIOP_Profile (this->orb_core ()),
0);
const int r = pfile->decode (cdr);
if (r == -1)
{
pfile->_decr_refcnt ();
pfile = 0;
}
return pfile;
}
| TAO_Transport * TAO_UIOP_Connector::make_connection | ( | TAO::Profile_Transport_Resolver * | r, | |
| TAO_Transport_Descriptor_Interface & | desc, | |||
| ACE_Time_Value * | timeout = 0 | |||
| ) | [protected, virtual] |
Make a connection.
Implements TAO_Connector.
Definition at line 131 of file UIOP_Connector.cpp.
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - UIUP_Connector::make_connection, ")
ACE_TEXT ("looking for UIOP connection.\n")));
TAO_UIOP_Endpoint *uiop_endpoint =
this->remote_endpoint (desc.endpoint ());
if (uiop_endpoint == 0)
return 0;
const ACE_UNIX_Addr &remote_address =
uiop_endpoint->object_addr ();
if (TAO_debug_level > 2)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - UIUP_Connector::make_connection, ")
ACE_TEXT ("making a new connection\n")));
// Get the right synch options
ACE_Synch_Options synch_options;
this->active_connect_strategy_->synch_options (max_wait_time,
synch_options);
// The code used to set the timeout to zero, with the intent of
// polling the reactor for connection completion. However, the side-effect
// was to cause the connection to timeout immediately.
TAO_UIOP_Connection_Handler *svc_handler = 0;
// Connect.
int result =
this->base_connector_.connect (svc_handler,
remote_address,
synch_options);
// Make sure that we always do a remove_reference
ACE_Event_Handler_var svc_handler_auto_ptr (svc_handler);
TAO_Transport *transport =
svc_handler->transport ();
if (result == -1)
{
// No immediate result, wait for completion
if (errno == EWOULDBLOCK)
{
// Try to wait until connection completion. Incase we block, then we
// get a connected transport or not. In case of non block we get
// a connected or not connected transport
if (!this->wait_for_connection_completion (r,
desc,
transport,
max_wait_time))
{
if (TAO_debug_level > 2)
ACE_ERROR ((LM_ERROR, "TAO (%P|%t) - UIOP_Connector::"
"make_connection, "
"wait for completion failed\n"));
}
}
else
{
// Transport is not usable
transport = 0;
}
}
// In case of errors transport is zero
if (transport == 0)
{
// Give users a clue to the problem.
if (TAO_debug_level > 3)
ACE_ERROR ((LM_ERROR,
"TAO (%P|%t) - UIOP_Connector::make_connection, "
"connection to <%C> failed (%p)\n",
uiop_endpoint->rendezvous_point (),
ACE_TEXT("errno")));
return 0;
}
if (svc_handler->keep_waiting ())
{
svc_handler->connection_pending ();
}
if (svc_handler->error_detected ())
{
svc_handler->cancel_pending_connection ();
}
// At this point, the connection has be successfully created
// connected or not connected, but we have a connection.
if (TAO_debug_level > 2)
ACE_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - UIOP_Connector::make_connection, "
"new %C connection to <%C> on Transport[%d]\n",
transport->is_connected() ? "connected" : "not connected",
uiop_endpoint->rendezvous_point (),
svc_handler->peer ().get_handle ()));
// Add the handler to Cache
int retval =
this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc,
transport);
// Failure in adding to cache.
if (retval == -1)
{
// Close the handler.
svc_handler->close ();
if (TAO_debug_level > 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - UIOP_Connector::make_connection, ")
ACE_TEXT ("could not add the new connection to Cache\n")));
}
return 0;
}
if (svc_handler->error_detected ())
{
svc_handler->cancel_pending_connection ();
transport->purge_entry();
return 0;
}
if (transport->is_connected () &&
transport->wait_strategy ()->register_handler () != 0)
{
// Registration failures.
// Purge from the connection cache, if we are not in the cache, this
// just does nothing.
(void) transport->purge_entry ();
// Close the handler.
(void) transport->close_connection ();
if (TAO_debug_level > 0)
ACE_ERROR ((LM_ERROR,
"TAO (%P|%t) - UIOP_Connector [%d]::make_connection, "
"could not register the transport "
"in the reactor.\n",
transport->id ()));
return 0;
}
svc_handler_auto_ptr.release ();
return transport;
}
| TAO_Profile * TAO_UIOP_Connector::make_profile | ( | void | ) | [protected, virtual] |
Create a profile with a given endpoint.
Implements TAO_Connector.
Definition at line 311 of file UIOP_Connector.cpp.
{
TAO_Profile *profile = 0;
ACE_NEW_THROW_EX (profile,
TAO_UIOP_Profile (this->orb_core ()),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
return profile;
}
| char TAO_UIOP_Connector::object_key_delimiter | ( | void | ) | const [virtual] |
Return the object key delimiter to use or expect.
Our activation strategy
Implements TAO_Connector.
Definition at line 358 of file UIOP_Connector.cpp.
{
return TAO_UIOP_Profile::object_key_delimiter_;
}
| int TAO_UIOP_Connector::open | ( | TAO_ORB_Core * | orb_core | ) | [virtual] |
Initialize object and register with reactor.
Our activation strategy
Implements TAO_Connector.
Definition at line 38 of file UIOP_Connector.cpp.
{
this->orb_core (orb_core);
// Create our connect strategy
if (this->create_connect_strategy () == -1)
return -1;
// Our connect creation strategy
TAO_UIOP_CONNECT_CREATION_STRATEGY *connect_creation_strategy = 0;
ACE_NEW_RETURN (connect_creation_strategy,
TAO_UIOP_CONNECT_CREATION_STRATEGY
(orb_core->thr_mgr (),
orb_core),
-1);
/// Our activation strategy
TAO_UIOP_CONNECT_CONCURRENCY_STRATEGY *concurrency_strategy = 0;
ACE_NEW_RETURN (concurrency_strategy,
TAO_UIOP_CONNECT_CONCURRENCY_STRATEGY (orb_core),
-1);
return this->base_connector_.open (this->orb_core ()->reactor (),
connect_creation_strategy,
&this->connect_strategy_,
concurrency_strategy);
}
| TAO_UIOP_Endpoint * TAO_UIOP_Connector::remote_endpoint | ( | TAO_Endpoint * | ep | ) | [private] |
Return the remote endpoint, a helper function.
Definition at line 364 of file UIOP_Connector.cpp.
{
if (endpoint->tag () != TAO_TAG_UIOP_PROFILE)
return 0;
TAO_UIOP_Endpoint *uiop_endpoint =
dynamic_cast<TAO_UIOP_Endpoint *> (endpoint);
if (uiop_endpoint == 0)
return 0;
return uiop_endpoint;
}
| int TAO_UIOP_Connector::set_validate_endpoint | ( | TAO_Endpoint * | endpoint | ) | [protected, virtual] |
Set and validate endpoint. We need to do this to initialize our remote *_Addr's which have not been done during IOR decode.
Implements TAO_Connector.
Definition at line 100 of file UIOP_Connector.cpp.
{
TAO_UIOP_Endpoint *uiop_endpoint = this->remote_endpoint (endpoint);
if (uiop_endpoint == 0)
return -1;
const ACE_UNIX_Addr &remote_address = uiop_endpoint->object_addr ();
// @@ Note, POSIX.1g renames AF_UNIX to AF_LOCAL.
// Verify that the remote ACE_UNIX_Addr was initialized properly.
// Failure can occur if hostname lookup failed when initializing the
// remote ACE_INET_Addr.
if (remote_address.get_type () != AF_UNIX)
{
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - UIOP failure.\n")
ACE_TEXT ("TAO (%P|%t) - This is most likely ")
ACE_TEXT ("due to a hostname lookup ")
ACE_TEXT ("failure.\n")));
}
return -1;
}
return 0;
}
The connector initiating connection requests for UIOP.
Definition at line 130 of file UIOP_Connector.h.
Our connect strategy.
Definition at line 127 of file UIOP_Connector.h.
1.7.0