TAO_Connector Class Reference

Generic Connector interface definitions. More...

#include <Transport_Connector.h>

Inheritance diagram for TAO_Connector:

[legend]Collaboration diagram for TAO_Connector:

[legend]List of all members.

Public Member Functions
	TAO_Connector (CORBA::ULong tag)
	Default constructor.
virtual	~TAO_Connector (void)
	The destructor.
CORBA::ULong	tag (void) const
int	make_mprofile (const char *ior, TAO_MProfile &mprofile)
virtual TAO_Profile *	corbaloc_scan (const char *ior, size_t &len)
virtual int	open (TAO_ORB_Core *orb_core)=0
	Initialize object and register with reactor.
virtual int	close (void)=0
	Shutdown Connector bridge and concrete Connector.
virtual TAO_Transport *	connect (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface *desc, ACE_Time_Value *timeout)
virtual TAO_Transport *	parallel_connect (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface *desc, ACE_Time_Value *timeout)
virtual TAO_Profile *	create_profile (TAO_InputCDR &cdr)=0
virtual int	check_prefix (const char *endpoint)=0
virtual char	object_key_delimiter (void) const=0
	Return the object key delimiter to use or expect.
Protected Member Functions
virtual int	supports_parallel_connects (void) const
virtual TAO_Profile *	make_profile ()=0
	Create a profile with a given endpoint.
virtual int	set_validate_endpoint (TAO_Endpoint *endpoint)=0
virtual TAO_Transport *	make_connection (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *timeout)=0
	Make a connection.
virtual TAO_Transport *	make_parallel_connection (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *timeout)
virtual int	cancel_svc_handler (TAO_Connection_Handler *svc_handler)=0
	Cancel the passed cvs handler from the connector.
virtual int	check_connection_closure (TAO_Connection_Handler *connection_handler)
	Check whether the connection is not closed.
virtual bool	wait_for_connection_completion (TAO::Profile_Transport_Resolver *r, TAO_Transport *&transport, ACE_Time_Value *timeout)
virtual bool	wait_for_connection_completion (TAO::Profile_Transport_Resolver *r, TAO_Transport *&the_winner, TAO_Transport **transport, unsigned int count, TAO_LF_Multi_Event *mev, ACE_Time_Value *timeout)
void	orb_core (TAO_ORB_Core *orb_core)
	Set the ORB Core pointer.
int	create_connect_strategy (void)
	Create a connect strategy.
TAO_ORB_Core *	orb_core (void)
	Return the TAO_ORB_Core pointer.
Protected Attributes
TAO_Connect_Strategy *	active_connect_strategy_
	The (a)synch connect strategy.
Private Attributes
CORBA::ULong const	tag_
	IOP protocol tag.
TAO_ORB_Core *	orb_core_
	Pointer to our ORB core.

---

Detailed Description

Generic Connector interface definitions.

Base class for connector bridge object.

Todo:

Need to rename the class as TAO_Transport_Connector.

Definition at line 71 of file Transport_Connector.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Connector::TAO_Connector (  CORBA::ULong  tag  )

Default constructor. Definition at line 35 of file Transport_Connector.cpp. : active_connect_strategy_ (0), tag_ (tag), orb_core_ (0) { }

TAO_Connector::~TAO_Connector (  void   )  [virtual]

The destructor. Definition at line 42 of file Transport_Connector.cpp. References active_connect_strategy_. { delete this->active_connect_strategy_; }

---

Member Function Documentation

virtual int TAO_Connector::cancel_svc_handler (  TAO_Connection_Handler *  svc_handler  )  [protected, pure virtual]

Cancel the passed cvs handler from the connector. Implemented in TAO_IIOP_Connector. Referenced by check_connection_closure(), and wait_for_connection_completion().

int TAO_Connector::check_connection_closure (  TAO_Connection_Handler *  connection_handler  )  [protected, virtual]

Check whether the connection is not closed. Return values: 0  The connection happens to be not closed, but is now open because an other thread managed to open the handler -1  The connection is closed Definition at line 671 of file Transport_Connector.cpp. References ACE_ASSERT, cancel_svc_handler(), TAO_Connection_Handler::close_handler(), TAO_Connection_Handler::is_closed(), TAO_Connection_Handler::is_connecting(), and TAO_Connection_Handler::is_open(). Referenced by wait_for_connection_completion(). { int result = -1; // Check if the handler has been closed. bool closed = connection_handler->is_closed (); // In case of failures and close() has not be called. if (!closed) { // First, cancel from connector. if (this->cancel_svc_handler (connection_handler) == -1) return -1; // Double check to make sure the handler has not been closed // yet. This double check is required to ensure that the // connection handler was not closed yet by some other // thread since it was still registered with the connector. // Once connector.cancel() has been processed, we are // assured that the connector will no longer open/close this // handler. closed = connection_handler->is_closed (); // If closed, there is nothing to do here. If not closed, // it was either opened or is still pending. if (!closed) { // Check if the handler has been opened. const bool open = connection_handler->is_open (); // Some other thread was able to open the handler even // though wait failed for this thread. if (open) { // Set the result to 0, we have an open connection result = 0; } else { // Assert that it is still connecting. ACE_ASSERT (connection_handler->is_connecting ()); // Force close the handler now. connection_handler->close_handler (); } } } return result; }

virtual int TAO_Connector::check_prefix (  const char *  endpoint  )  [pure virtual]

Check that the prefix of the provided endpoint is valid for use with a given pluggable protocol. Implemented in TAO_IIOP_Connector. Referenced by corbaloc_scan(), and make_mprofile().

virtual int TAO_Connector::close (  void   )  [pure virtual]

Shutdown Connector bridge and concrete Connector. Implemented in TAO_IIOP_Connector. Referenced by TAO_Connector_Registry::close_all().

TAO_Transport * TAO_Connector::connect (  TAO::Profile_Transport_Resolver *  r, TAO_Transport_Descriptor_Interface *  desc, ACE_Time_Value *  timeout )  [virtual]

To support pluggable we need to abstract away the details of the connect () method so it can be called from the invocation code independent of the actual transport protocol in use. Definition at line 325 of file Transport_Connector.cpp. References ACE_DEBUG, ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, TAO_Transport::close_connection(), TAO_Transport_Descriptor_Interface::endpoint(), TAO::Transport_Cache_Manager::find_transport(), TAO_Transport::id(), TAO_Transport::is_connected(), TAO_ORB_Core::lane_resources(), LM_DEBUG, LM_ERROR, make_connection(), TAO_Transport::opened_as(), orb_core(), TAO_Transport::post_connect_hook(), TAO::Transport_Cache_Manager::purge(), TAO_Transport::purge_entry(), TAO_Wait_Strategy::register_handler(), set_validate_endpoint(), TAO_debug_level, TAO_Thread_Lane_Resources::transport_cache(), wait_for_connection_completion(), and TAO_Transport::wait_strategy(). { if (desc == 0 || (this->set_validate_endpoint (desc->endpoint ()) == -1)) return 0; TAO_Transport *base_transport = 0; TAO::Transport_Cache_Manager &tcm = this->orb_core ()->lane_resources ().transport_cache (); // Check the Cache first for connections // If transport found, reference count is incremented on assignment // @@todo: We need to send the timeout value to the cache registry // too. That should be the next step! if (tcm.find_transport (desc, base_transport) != 0) { // @@TODO: This is not the right place for this! // Purge connections (if necessary) tcm.purge (); TAO_Transport* t = this->make_connection (r, *desc, timeout); if (t == 0) return t; t->opened_as (TAO::TAO_CLIENT_ROLE); if (TAO_debug_level > 4) ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) Transport_Connector::connect, ") ACE_TEXT("opening Transport[%d] in TAO_CLIENT_ROLE\n"), t->id ())); // Call post connect hook. If the post_connect_hook () returns // false, just purge the entry. if (!t->post_connect_hook ()) { (void) t->purge_entry (); // Call connect again return this->connect (r, desc, timeout ACE_ENV_ARG_PARAMETER); } return t; } if (TAO_debug_level > 4) { TAO::Connection_Role cr = base_transport->opened_as (); ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Transport_Connector::connect, " "got an existing %s Transport[%d] in role %s\n", base_transport->is_connected () ? "connected" : "unconnected", base_transport->id (), cr == TAO::TAO_SERVER_ROLE ? "TAO_SERVER_ROLE" : cr == TAO::TAO_CLIENT_ROLE ? "TAO_CLIENT_ROLE" : "TAO_UNSPECIFIED_ROLE" )); } // If connected return. if (base_transport->is_connected ()) return base_transport; // It it possible to get a transport from the cache that is not // connected? If not, then the following code is bogus. We cannot // wait for a connection to complete on a transport in the cache. // // (mesnier_p@ociweb.com) It is indeed possible to reach this point. // The AMI_Buffering test does. When using non-blocking connects and // the first request(s) are asynch and may be queued, the connection // establishment may not be completed by the time the invocation is // done with it. In that case it is up to a subsequent invocation to // handle the connection completion. if (!this->wait_for_connection_completion (r, base_transport, timeout)) { if (TAO_debug_level > 2) ACE_ERROR ((LM_ERROR, "TAO (%P|%t) - Transport_Connector::" "connect, " "wait for completion failed\n")); return 0; } if (base_transport->is_connected () && base_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) base_transport->purge_entry (); // Close the handler. (void) base_transport->close_connection (); if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, "TAO (%P|%t) - Transport_Connector [%d]::connect, " "could not register the transport " "in the reactor.\n", base_transport->id ())); return 0; } return base_transport; }

TAO_Profile * TAO_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(). Definition at line 48 of file Transport_Connector.cpp. References ACE_DEBUG, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_TEXT, check_prefix(), LM_DEBUG, make_profile(), ACE_OS::strchr(), ACE_OS::strlen(), and TAO_debug_level. { if (this->check_prefix (str) != 0) return 0; const char *comma_pos = ACE_OS::strchr (str,','); const char *slash_pos = ACE_OS::strchr (str,'/'); if (comma_pos == 0 && slash_pos == 0) { if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) TAO_CONNECTOR::corbaloc_scan warning: ") ACE_TEXT("supplied string contains no comma or slash: %s\n"), str)); len = ACE_OS::strlen (str); } else if (comma_pos == 0 || comma_pos > slash_pos) len = (slash_pos - str); else len = comma_pos - str; return this->make_profile(ACE_ENV_SINGLE_ARG_PARAMETER); }

int TAO_Connector::create_connect_strategy (  void   )  [protected]

Create a connect strategy. Definition at line 653 of file Transport_Connector.cpp. References active_connect_strategy_, TAO_ORB_Core::client_factory(), and TAO_Client_Strategy_Factory::create_connect_strategy(). Referenced by TAO_IIOP_Connector::open(). { if (this->active_connect_strategy_ == 0) { this->active_connect_strategy_ = this->orb_core_->client_factory ()->create_connect_strategy ( this->orb_core_); } if (this->active_connect_strategy_ == 0) { return -1; } return 0; }

virtual TAO_Profile* TAO_Connector::create_profile (  TAO_InputCDR &  cdr  )  [pure virtual]

Create a profile for this protocol and initialize it based on the encapsulation in cdr Implemented in TAO_IIOP_Connector. Referenced by TAO_Connector_Registry::create_profile().

virtual TAO_Transport* TAO_Connector::make_connection (  TAO::Profile_Transport_Resolver *  r, TAO_Transport_Descriptor_Interface &  desc, ACE_Time_Value *  timeout )  [protected, pure virtual]

Make a connection. Implemented in TAO_IIOP_Connector. Referenced by connect().

int TAO_Connector::make_mprofile (  const char *  ior, TAO_MProfile &  mprofile )

Parse a string containing a URL style IOR and return an MProfile. Verify that ior is in the correct format. Definition at line 72 of file Transport_Connector.cpp. References TAO_Profile::_decr_refcnt(), ACE_CHECK_RETURN, ACE_CString, ACE_DEBUG, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_THROW_RETURN, check_prefix(), LM_DEBUG, make_profile(), TAO_Profile::parse_string(), ssize_t, TAO_debug_level, and TAO_MPROFILE_CREATION_ERROR. { // This method utilizes the "Template Method" design pattern to // parse the given URL style IOR for the protocol being used // and create an mprofile from it. // // The methods that must be defined by all Connector sub-classes are: // make_profile // check_prefix // Check for a valid string if (!string || !*string) { ACE_THROW_RETURN (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( 0, EINVAL), CORBA::COMPLETED_NO), -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 (this->check_prefix (string) != 0) { return 1; // Failure: not the correct IOR for this protocol. // DO NOT throw an exception here since the Connector_Registry // should be allowed the opportunity to continue looking for // an appropriate connector. } if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - TAO_Connector::make_mprofile ") ACE_TEXT ("<%s>\n"), ACE_TEXT_CHAR_TO_TCHAR (string))); } ACE_CString ior; ior.set (string, ACE_OS::strlen (string), 1); // Find out where the protocol ends ssize_t ior_index = ior.find ("://"); if (ior_index == ACE_CString::npos) { ACE_THROW_RETURN (CORBA::INV_OBJREF (), -1); // No colon ':' in the IOR! } else { ior_index += 3; // Add the length of the colon and the two forward slashes `://' // to the IOR string index (i.e. 3) } // Find the object key const ssize_t objkey_index = ior.find (this->object_key_delimiter (), ior_index); if (objkey_index == 0 || objkey_index == ACE_CString::npos) { ACE_THROW_RETURN (CORBA::INV_OBJREF (), -1); // Failure: No endpoints specified or no object key specified. } const char endpoint_delimiter = ','; // The delimiter used to seperate inidividual addresses. // Count the number of endpoints in the IOR. This will be the number // of entries in the MProfile. CORBA::ULong profile_count = 1; // Number of endpoints in the IOR (initialized to 1). // Only check for endpoints after the protocol specification and // before the object key. for (ssize_t i = ior_index; i < objkey_index; ++i) { if (ior[i] == endpoint_delimiter) ++profile_count; } // Tell the MProfile object how many Profiles it should hold. // MProfile::set(size) returns the number profiles it can hold. if (mprofile.set (profile_count) != static_cast<int> (profile_count)) { ACE_THROW_RETURN (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO_MPROFILE_CREATION_ERROR, 0), CORBA::COMPLETED_NO), -1); // Error while setting the MProfile size! } // The idea behind the following loop is to split the IOR into several // strings that can be parsed by each profile. // For example, // `1.3@moo,shu,1.1@chicken/arf' // will be parsed into: // `1.3@moo/arf' // `shu/arf' // `1.1@chicken/arf' ssize_t begin = 0; ssize_t end = ior_index - 1; // Initialize the end of the endpoint index for (CORBA::ULong j = 0; j < profile_count; ++j) { begin = end + 1; if (j < profile_count - 1) { end = ior.find (endpoint_delimiter, begin); } else { end = objkey_index; // Handle last endpoint differently } if (end < static_cast<ssize_t> (ior.length ()) && end != ior.npos) { ACE_CString endpoint = ior.substring (begin, end - begin); // Add the object key to the string. endpoint += ior.substring (objkey_index); // The endpoint should now be of the form: // `N.n@endpoint/object_key' // or // `endpoint/object_key' TAO_Profile *profile = this->make_profile (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Failure: Problem during profile creation // Initialize a Profile using the individual endpoint // string. // @@ Not exception safe! We need a TAO_Profile_var! profile->parse_string (endpoint.c_str () ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Give up ownership of the profile. if (mprofile.give_profile (profile) == -1) { profile->_decr_refcnt (); ACE_THROW_RETURN (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO_MPROFILE_CREATION_ERROR, 0), CORBA::COMPLETED_NO), -1); // Failure presumably only occurs when MProfile is full! // This should never happen. } } else { ACE_THROW_RETURN (CORBA::INV_OBJREF (), -1); // Unable to seperate endpoints } } return 0; // Success }

TAO_Transport * TAO_Connector::make_parallel_connection (  TAO::Profile_Transport_Resolver *  r, TAO_Transport_Descriptor_Interface &  desc, ACE_Time_Value *  timeout )  [protected, virtual]

Make a connection using - not a pure virtual since not all protocols support this. Reimplemented in TAO_IIOP_Connector. Definition at line 255 of file Transport_Connector.cpp. Referenced by parallel_connect(). { return 0; }

virtual TAO_Profile* TAO_Connector::make_profile (   )  [protected, pure virtual]

Create a profile with a given endpoint. Implemented in TAO_IIOP_Connector. Referenced by corbaloc_scan(), and make_mprofile().

virtual char TAO_Connector::object_key_delimiter (  void   )  const [pure virtual]

Return the object key delimiter to use or expect. Implemented in TAO_IIOP_Connector.

virtual int TAO_Connector::open (  TAO_ORB_Core *  orb_core  )  [pure virtual]

Initialize object and register with reactor. Implemented in TAO_IIOP_Connector.

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE TAO_ORB_Core * TAO_Connector::orb_core (  void   )  [protected]

Return the TAO_ORB_Core pointer. Definition at line 8 of file Transport_Connector.inl. Referenced by TAO_IIOP_Connector::complete_connection(), connect(), TAO_IIOP_Connector::make_parallel_connection(), TAO_IIOP_Connector::open(), and parallel_connect(). { return this->orb_core_; }

ACE_INLINE void TAO_Connector::orb_core (  TAO_ORB_Core *  orb_core  )  [protected]

Set the ORB Core pointer. Definition at line 14 of file Transport_Connector.inl. { this->orb_core_ = orb_core; }

TAO_Transport * TAO_Connector::parallel_connect (  TAO::Profile_Transport_Resolver *  r, TAO_Transport_Descriptor_Interface *  desc, ACE_Time_Value *  timeout )  [virtual]

A variation on connect that will try simultanious connections on all endpoints listed in the desc. Definition at line 264 of file Transport_Connector.cpp. References ACE_DEBUG, ACE_TEXT, TAO_Transport_Descriptor_Interface::endpoint(), ENOTSUP, TAO::Transport_Cache_Manager::find_transport(), TAO_Transport::id(), TAO_ORB_Core::lane_resources(), LM_DEBUG, make_parallel_connection(), TAO_Endpoint::next_filtered(), orb_core(), set_validate_endpoint(), supports_parallel_connects(), TAO_debug_level, and TAO_Thread_Lane_Resources::transport_cache(). { if (this->supports_parallel_connects() == 0) { errno = ENOTSUP; return 0; } errno = 0; // need to clear errno to ensure a stale enotsup is not set if (desc == 0) return 0; unsigned int endpoint_count = 0; TAO_Endpoint *root_ep = desc->endpoint(); for (TAO_Endpoint *ep = root_ep->next_filtered (this->orb_core(),0); ep != 0; ep = ep->next_filtered(this->orb_core(),root_ep)) if (this->set_validate_endpoint (ep) == 0) ++endpoint_count; if (endpoint_count == 0) return 0; TAO_Transport *base_transport = 0; TAO::Transport_Cache_Manager &tcm = this->orb_core ()->lane_resources ().transport_cache (); // Iterate through the endpoints. Since find_transport takes a // Transport Descriptor rather than an endpoint, we must create a // local TDI for each endpoint. The first one found will be used. for (TAO_Endpoint *ep = root_ep->next_filtered (this->orb_core(),0); ep != 0; ep = ep->next_filtered(this->orb_core(),root_ep)) { TAO_Base_Transport_Property desc2(ep,0); if (tcm.find_transport (&desc2, base_transport) == 0) { if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) TAO_Connector::parallel_connect: ") ACE_TEXT ("found a transport [%d]\n"), base_transport->id())); return base_transport; } } // Now we have searched the cache on all endpoints and come up // empty. We need to initiate connections on each of the // endpoints. Presumably only one will have a route and will succeed, // and the rest will fail. This requires the use of asynch // connection establishment. Maybe a custom wait strategy is needed // at this point to register several potential transports so that // when one succeeds the rest are cancelled or closed. return this->make_parallel_connection (r,*desc,timeout); }

virtual int TAO_Connector::set_validate_endpoint (  TAO_Endpoint *  endpoint  )  [protected, pure virtual]

Set and validate endpoint. We need to do this to initialize our remote *_Addr's which have not been done during IOR decode. Implemented in TAO_IIOP_Connector. Referenced by connect(), and parallel_connect().

int TAO_Connector::supports_parallel_connects (  void   )  const [protected, virtual]

A flag indicating the actual connector supports parallel connection attempts. The base implementation alwayse returns 0. Override to return non-zero if parallel connection attempts may be tried. Reimplemented in TAO_IIOP_Connector. Definition at line 249 of file Transport_Connector.cpp. Referenced by parallel_connect(). { return 0; // by default, we don't support parallel connection attempts; }

ACE_INLINE CORBA::ULong TAO_Connector::tag (  void   )  const

The tag identifying the specific ORB transport layer protocol. For example IOP::TAG_INTERNET_IOP == 0. The tag is used in the IOR to identify the type of profile included. IOR -> {{tag0, profile0} {tag1, profile1} ...}. The IOP module defines the ProfileId typedef to be a CORBA::ULong. Definition at line 20 of file Transport_Connector.inl. { return this->tag_; }

bool TAO_Connector::wait_for_connection_completion (  TAO::Profile_Transport_Resolver *  r, TAO_Transport *&  the_winner, TAO_Transport **  transport, unsigned int  count, TAO_LF_Multi_Event *  mev, ACE_Time_Value *  timeout )  [protected, virtual]

In the case of a parallel connection attempt, we take an array of transports, and wait on any of them. When the first one completes, the rest are closed. Definition at line 544 of file Transport_Connector.cpp. References ACE_DEBUG, ACE_ERROR, ACE_TEXT, active_connect_strategy_, TAO::Profile_Transport_Resolver::blocked_connect(), cancel_svc_handler(), check_connection_closure(), TAO_Transport::connection_handler(), ETIME, TAO_Transport::id(), TAO_Connection_Handler::is_closed(), TAO_Transport::is_connected(), LM_DEBUG, LM_ERROR, TAO_debug_level, TAO_Connection_Handler::transport(), TAO_Connect_Strategy::wait(), and TAO_LF_Multi_Event::winner(). { if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) Transport_Connector::") ACE_TEXT("wait_for_connection_completion, ") ACE_TEXT("waiting for connection completion on ") ACE_TEXT("%d transports, ["), count)); for (unsigned int i = 0; i < count; i++) ACE_DEBUG ((LM_DEBUG, ACE_TEXT("%d%s"),transport[i]->id(), (i < (count -1) ? ", " : "]\n"))); } // If we don't need to block for a transport just set the timeout to // be zero. ACE_Time_Value tmp_zero (ACE_Time_Value::zero); if (!r->blocked_connect ()) { timeout = &tmp_zero; } int result = this->active_connect_strategy_->wait (mev,timeout); the_winner = 0; if (result != -1) { the_winner = mev->winner()->transport(); if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) Transport_Connector::") ACE_TEXT("wait_for_connection_completion, ") ACE_TEXT("transport [%d]\n"), the_winner->id ())); } else if (errno == ETIME) { // this is the most difficult case. In this situation, there is no // nominated by the Multi_Event. The best we can do is pick one of // the pending connections. // Of course, this shouldn't happen in any case, since the wait // strategy is called with a timeout value of 0. for (unsigned int i = 0; i < count; i++) if (!transport[i]->connection_handler()->is_closed()) { the_winner = transport[i]; break; } } // It is possible that we have more than one connection that happened // to complete, or that none completed. Therefore we need to traverse // the list and ensure that all of the losers are closed. for (unsigned int i = 0; i < count; i++) { if (transport[i] != the_winner) this->check_connection_closure (transport[i]->connection_handler()); // since we are doing this on may connections, the result isn't // particularly important. } // In case of errors. if (the_winner == 0) { // Report that making the connection failed, don't print errno // because we touched the reactor and errno could be changed if (TAO_debug_level > 2) ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) Transport_Connector::") ACE_TEXT ("wait_for_connection_completion, failed\n") )); return false; } // Fix for a subtle problem. What happens if we are supposed to do // blocked connect but the transport is NOT connected? Force close // the connections if (r->blocked_connect () && !the_winner->is_connected ()) { if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Transport_Connector::" "wait_for_connection_completion, " "no connected transport for a blocked connection, " "cancelling connections and reverting things \n")); // Forget the return value. We are busted anyway. Try our best // here. (void) this->cancel_svc_handler (the_winner->connection_handler ()); the_winner = 0; return false; } // Connection may not ready for SYNC_NONE cases but we can use this // transport, if we need a connected one we will block later to make // sure it is connected return true; }

bool TAO_Connector::wait_for_connection_completion (  TAO::Profile_Transport_Resolver *  r, TAO_Transport *&  transport, ACE_Time_Value *  timeout )  [protected, virtual]

Wait for connection completion. We have a transport that is not connected yet, wait until it is connected. Return values: true  When we could use transport Returns: false When we can't use the transport Definition at line 450 of file Transport_Connector.cpp. References ACE_DEBUG, ACE_ERROR, active_connect_strategy_, TAO::Profile_Transport_Resolver::blocked_connect(), check_connection_closure(), TAO_Transport::connection_handler(), ETIME, TAO_Transport::id(), LM_DEBUG, LM_ERROR, TAO_debug_level, and TAO_Connect_Strategy::wait(). Referenced by TAO_IIOP_Connector::complete_connection(), and connect(). { if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Transport_Connector::" "wait_for_connection_completion, " "going to wait for connection completion on transport" "[%d]\n", transport->id ())); // If we don't need to block for a transport just set the timeout to // be zero. ACE_Time_Value tmp_zero (ACE_Time_Value::zero); if (!r->blocked_connect ()) { timeout = &tmp_zero; } // Wait until the connection is ready, when non-blocking we just do a wait // with zero time int result = this->active_connect_strategy_->wait ( transport, timeout); if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Transport_Connector::" "wait_for_connection_completion, " "transport [%d], wait done result = %d\n", transport->id (), result)); // There are three possibilities when wait() returns: (a) // connection succeeded; (b) connection failed; (c) wait() // failed because of some other error. It is easy to deal with // (a) and (b). (c) is tricky since the connection is still // pending and may get completed by some other thread. The // following method deals with (c). if (result == -1) { if (!r->blocked_connect () && errno == ETIME) { if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Transport_Connector::" "wait_for_connection_completion, " "transport [%d], timeout, resetting state.\n", transport->id ())); transport->connection_handler()-> reset_state(TAO_LF_Event::LFS_CONNECTION_WAIT); // If we did a non blocking connect, just ignore // any timeout errors result = 0; } else { // When we need to get a connected transport result = this->check_connection_closure ( transport->connection_handler ()); } // In case of errors. if (result == -1) { // Report that making the connection failed, don't print errno // because we touched the reactor and errno could be changed if (TAO_debug_level > 2) ACE_ERROR ((LM_ERROR, "TAO (%P|%t) - Transport_Connector::" "wait_for_connection_completion, " "transport [%d], wait for completion failed\n", transport->id())); // Set transport to zero, it is not usable, and the reference // count we added above was decremented by the base connector // handling the connection failure. transport = 0; return false; } } // Connection not ready yet but we can use this transport, if // we need a connected one we will block later to make sure // it is connected return true; }

---

Member Data Documentation

TAO_Connect_Strategy* TAO_Connector::active_connect_strategy_ [protected]

The (a)synch connect strategy. Definition at line 221 of file Transport_Connector.h. Referenced by create_connect_strategy(), wait_for_connection_completion(), and ~TAO_Connector().

TAO_ORB_Core* TAO_Connector::orb_core_ [private]

Pointer to our ORB core. Definition at line 229 of file Transport_Connector.h.

CORBA::ULong const TAO_Connector::tag_ [private]

IOP protocol tag. Definition at line 226 of file Transport_Connector.h.

---

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

• Transport_Connector.h
• Transport_Connector.cpp
• Transport_Connector.inl

---