// This function does what TAO does in order to get a transport.
CORBA::Boolean
first_request_flag (CORBA::Object_ptr obj)
{
TAO_Stub *const stub = obj->_stubobj ();
if (0 == stub)
{
ACE_ERROR_RETURN ((LM_DEBUG,
"CORBA::Object has stub = 0\n"),
1);
}
TAO::Profile_Transport_Resolver resolver (obj, stub, true);
resolver.resolve (0);
TAO_Transport *transport = resolver.transport ();
if (0 == transport)
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Transport is 0\n"),
1);
}
return transport->first_request ();
}
TAO_IIOP_Connection_Handler::~TAO_IIOP_Connection_Handler (void)
{
if (TAO_debug_level > 9)
{
TAO_Transport *tport = this->transport ();
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::")
ACE_TEXT("~IIOP_Connection_Handler, ")
ACE_TEXT("this=%@, transport=%@\n"),
tport != 0 ? tport->id () : 0,
this,
tport));
}
delete this->transport ();
int const result =
this->release_os_resources ();
if (result == -1 && TAO_debug_level)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler::")
ACE_TEXT("~IIOP_Connection_Handler, ")
ACE_TEXT("release_os_resources() failed %m\n")));
}
}
void
TAO_FIFO_Connection_Purging_Strategy::update_item (TAO_Transport& transport)
{
// FIFO, so only update the purging order if this
// item has not been cached yet.
if (transport.purging_order () == 0)
{
transport.purging_order (this->order_++);
}
}
ACE_Event_Handler::Reference_Count
TAO_IIOP_Connection_Handler::remove_reference (void)
{
TAO_Transport *tport = this->transport ();
Reference_Count rc = TAO_IIOP_SVC_HANDLER::remove_reference ();
if (TAO_debug_level > 9)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::")
ACE_TEXT("remove_reference, down to %d\n"),
tport != 0 ? tport->id () : 0,
rc));
}
return rc;
}
int
TAO_Codeset_Service_Context_Handler::generate_service_context (
TAO_Stub *,
TAO_Transport& transport,
TAO_Operation_Details &opdetails,
TAO_Target_Specification &,
TAO_OutputCDR &)
{
if (transport.first_request ())
{
TAO_Codeset_Manager * const csm = transport.orb_core ()->codeset_manager ();
if (csm)
{
csm->generate_service_context (opdetails, transport);
}
}
return 0;
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
#ifdef TAO_LOG_CH_REF_COUNTS
ACE_Event_Handler::Reference_Count
TAO_IIOP_Connection_Handler::add_reference (void)
{
Reference_Count rc = TAO_IIOP_SVC_HANDLER::add_reference ();
if (TAO_debug_level > 9)
{
TAO_Transport *tport = this->transport ();
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::")
ACE_TEXT("add_reference, up to %d\n"),
tport != 0 ? tport->id () : 0,
rc));
}
return rc;
}
int
TAO_BiDIR_Service_Context_Handler::generate_service_context (
TAO_Stub *,
TAO_Transport& transport,
TAO_Operation_Details &opdetails,
TAO_Target_Specification &,
TAO_OutputCDR &msg)
{
if (transport.orb_core ()->bidir_giop_policy () &&
transport.messaging_object ()->is_ready_for_bidirectional (msg) &&
transport.bidirectional_flag () < 0)
{
transport.set_bidir_context_info (opdetails);
// Set the flag to 1 (i.e., originating side)
transport.bidirectional_flag (1);
// At the moment we enable BiDIR giop we have to get a new
// request id to make sure that we follow the even/odd rule
// for request id's. We only need to do this when enabled
// it, after that the Transport Mux Strategy will make sure
// that the rule is followed
opdetails.request_id (transport.tms ()->request_id ());
}
return 0;
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
int
TAO_BiDIR_Service_Context_Handler::process_service_context (
TAO_Transport& transport,
const IOP::ServiceContext& context,
TAO_ServerRequest * /*request*/)
{
TAO_InputCDR cdr (reinterpret_cast<const char*> (
context.context_data.get_buffer ()),
context.context_data.length ());
return transport.tear_listen_point_list (cdr);
}
TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler (
TAO_ORB_Core *orb_core)
: TAO_IIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0),
TAO_Connection_Handler (orb_core),
dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2)
{
TAO_IIOP_Transport* specific_transport = 0;
ACE_NEW (specific_transport,
TAO_IIOP_Transport (this, orb_core));
if (TAO_debug_level > 9)
{
TAO_Transport *tport = static_cast<TAO_Transport *> (specific_transport);
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::")
ACE_TEXT("IIOP_Connection_Handler, ")
ACE_TEXT("this=%@\n"),
tport != 0 ? tport->id () : 0,
this));
}
// store this pointer (indirectly increment ref count)
this->transport (specific_transport);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
if (CORBA::is_nil (policy_current.in ()))
{
ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n"));
return 1;
}
CORBA::Any scope_as_any;
scope_as_any <<= Messaging::SYNC_NONE;
CORBA::PolicyList policies (1); policies.length (1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
if (parse_args (argc, argv) != 0)
return 1;
// Get the sender reference..
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Sender_var sender =
Test::Sender::_narrow(tmp.in ());
if (CORBA::is_nil (sender.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil coordinator reference <%s>\n",
ior),
1);
}
Client_Task client_task (orb.in(),
sender.in (),
ACE_Thread_Manager::instance (),
number_of_oneways);
Server_Task server_task (orb.in (),
ACE_Thread_Manager::instance ());
// Before creating threads we will let the sender know that we
// will have two threads that would make invocations..
// this is the first oneway we do, so after this we would have a queue
// on one of the transports
sender->active_objects ((CORBA::Short) number_of_client_tasks);
TAO::Transport_Cache_Manager& manager = orb->orb_core()->lane_resources ().transport_cache ();
TAO::Transport_Cache_Manager::HASH_MAP& cachemap = manager.map();
TAO::Transport_Cache_Manager::HASH_MAP_ITER end_iter = cachemap.end ();
bool tranportwithqueue = false;
for (TAO::Transport_Cache_Manager::HASH_MAP_ITER iter = cachemap.begin ();
iter != end_iter;
++iter)
{
TAO_Transport* transport = (*iter).int_id_.transport ();
if (transport->queue_is_empty() == 0 && transport->is_connected() == false)
{
tranportwithqueue = true;
break;
}
}
if (!tranportwithqueue)
{
ACE_ERROR ((LM_ERROR, "(%P|%t) Error: expect a not connected transport with a queue\n"));
}
else
{
ACE_DEBUG((LM_DEBUG, "(%P|%t) Found not connected transport with a queue\n"));
}
if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 2,1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating server task\n"));
}
if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, number_of_client_tasks, 1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating client task\n"));
}
ACE_Thread_Manager::instance ()->wait ();
ACE_DEBUG ((LM_DEBUG,
"Event Loop finished\n"));
orb->destroy ();
if (tranportwithqueue == false)
{
return 1;
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
TAO_Transport *
TAO_UIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *r,
TAO_Transport_Descriptor_Interface &desc,
ACE_Time_Value *max_wait_time)
{
if (TAO_debug_level > 0)
TAOLIB_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)
TAOLIB_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)
TAOLIB_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)
TAOLIB_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)
TAOLIB_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)
{
TAOLIB_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)
TAOLIB_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_Transport *
TAO::IIOP_SSL_Connector::make_connection (
TAO::Profile_Transport_Resolver *r,
TAO_Transport_Descriptor_Interface &desc,
ACE_Time_Value *max_wait_time)
{
TAO_IIOP_Endpoint *iiop_endpoint =
dynamic_cast<TAO_IIOP_Endpoint *> (desc.endpoint ());
if (iiop_endpoint == 0)
return 0;
const ACE_INET_Addr &remote_address =
iiop_endpoint->object_addr ();
if (TAO_debug_level > 4)
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) IIOP_SSL_Connector::connect ")
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);
// 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 ())
{
synch_options.timeout (ACE_Time_Value::zero);
max_wait_time = &tmp_zero;
}
IIOP_SSL_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)
ORBSVCS_ERROR ((LM_ERROR, "TAO (%P|%t) - IIOP_SSL_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)
{
ORBSVCS_DEBUG ((LM_ERROR,
"TAO (%P|%t) - IIOP_SSL_Connector::make_connection, "
"connection to <%s:%d> failed (%p)\n",
iiop_endpoint->host (), iiop_endpoint->port (),
"errno"));
}
return 0;
}
if (svc_handler->keep_waiting (this->orb_core ()->leader_follower ()))
{
svc_handler->connection_pending ();
}
// At this point, the connection has be successfully connected.
// #REFCOUNT# is one.
if (TAO_debug_level > 2)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - IIOP_SSL_Connector::make_connection, "
"new connection to <%s:%d> on Transport[%d]\n",
iiop_endpoint->host (), iiop_endpoint->port (),
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)
{
ORBSVCS_ERROR ((LM_ERROR,
"TAO (%P|%t) - IIOP_SSL_Connector::make_connection, "
"could not add the new connection to cache\n"));
}
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)
ORBSVCS_ERROR ((LM_ERROR,
"TAO (%P|%t) - IIOP_SSL_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_Transport *
TAO_SHMIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
TAO_Transport_Descriptor_Interface &desc,
ACE_Time_Value *timeout)
{
if (TAO_debug_level > 0)
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - SHMIOP_Connector::make_connection, ")
ACE_TEXT ("looking for SHMIOP connection.\n")));
TAO_SHMIOP_Endpoint *shmiop_endpoint =
this->remote_endpoint (desc.endpoint ());
if (shmiop_endpoint == 0)
return 0;
const ACE_INET_Addr &remote_address =
shmiop_endpoint->object_addr ();
if (TAO_debug_level > 2)
TAOLIB_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - SHMIOP_Connector::make_connection, "
"making a new connection to <%C:%d>\n",
shmiop_endpoint->host (),
shmiop_endpoint->port ()));
// Get the right synch options
ACE_Synch_Options synch_options;
this->active_connect_strategy_->synch_options (timeout,
synch_options);
TAO_SHMIOP_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);
// In case of errors.
if (result == -1)
{
// Give users a clue to the problem.
if (TAO_debug_level > 0)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - SHMIOP_Connector::make_connection, ")
ACE_TEXT ("connection to <%C:%u> failed (%p)\n"),
shmiop_endpoint->host (),
shmiop_endpoint->port (),
ACE_TEXT ("errno")));
}
return 0;
}
if (svc_handler->keep_waiting ())
{
svc_handler->connection_pending ();
}
if (svc_handler->error_detected ())
{
svc_handler->cancel_pending_connection ();
}
TAO_Transport *transport =
svc_handler->transport ();
// At this point, the connection has be successfully connected.
// #REFCOUNT# is one.
if (TAO_debug_level > 2)
TAOLIB_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - SHMIOP_Connector::make_connection, "
"new %C connection to <%C:%d> on Transport[%d]\n",
transport->is_connected() ? "connected" : "not connected",
shmiop_endpoint->host (),
shmiop_endpoint->port (),
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)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT("TAO (%P|%t) - SHMIOP_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)
TAOLIB_ERROR ((LM_ERROR,
"TAO (%P|%t) - SHMIOP_Connector [%d]::make_connection, "
"could not register the transport in the reactor.\n",
transport->id ()));
return 0;
}
svc_handler_auto_ptr.release ();
return transport;
}
void
TAO_LFU_Connection_Purging_Strategy::update_item (TAO_Transport& transport)
{
transport.purging_order (transport.purging_order () + 1);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, "test");
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp = orb->string_to_object(ior);
if (CORBA::is_nil (tmp.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR, "Invalid IOR.\n")
,1);
}
{
// Set the Synch Scopes
CORBA::Any scope_as_any;
if (synch_none == true)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying SYNC_NONE.\n"));
scope_as_any <<= Messaging::SYNC_NONE;
}
else if (synch_delayed == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying SYNC_DELAYED_BUFFERING.\n"));
scope_as_any <<= TAO::SYNC_DELAYED_BUFFERING;
}
CORBA::PolicyList policies (1);
policies.length (1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
if (level_thread == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying Synch Scope at thread level.\n"));
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
policy_current->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
}
else if (level_orb == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying Synch Scope at orb level.\n"));
CORBA::Object_var obj =
orb->resolve_initial_references("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow(obj.in());
policy_manager->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
}
else if (level_obj == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying Synch Scope at Object level.\n"));
tmp = tmp->_set_policy_overrides (policies, CORBA::SET_OVERRIDE);
}
policies[0]->destroy ();
}
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
// If a blocking connection is initiated in the next step
// the test will get an exception indicating test failure.
// Be sure you IOR is for the localhost endpoint, else
// grab a book and wait around for timeout.
hello->get_string ();
TAO::Transport_Cache_Manager &tcm =
hello->orb_core ()->lane_resources ().transport_cache ();
TAO_Base_Transport_Property desc (hello->_stubobj ()->profile_in_use ()->endpoint ());
if (tcm.current_size() == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"The Transport Cache shouldn't be empty here.\n"),
1);
}
size_t busy_count = 0;
TAO_Transport *transport = 0;
TAO::Transport_Cache_Manager::Find_Result find_result =
tcm.find_transport (&desc, transport, busy_count);
// We don't need this transport any more. Release the ownership.
transport->remove_reference ();
switch (find_result){
case TAO::Transport_Cache_Manager::CACHE_FOUND_NONE:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Expected to find a transport in the cache.\n")
),1);
}
case TAO::Transport_Cache_Manager::CACHE_FOUND_CONNECTING:
{
ACE_DEBUG (( LM_DEBUG,
ACE_TEXT ("Transport Cache contains connecting entry as expected.\n")
));
break; // that's what we expected
}
case TAO::Transport_Cache_Manager::CACHE_FOUND_BUSY:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Cached Transport is busy. Should not happen because there's no server.\n")
),1);
}
case TAO::Transport_Cache_Manager::CACHE_FOUND_AVAILABLE:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Cached Transport is available. Should not happen because there's no server.\n")
),1);
}
default:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Transport_Cache::find returned unknown status.\n")
),1);
}
}
orb->destroy ();
}
catch (const CORBA::Exception &ex)
{
ACE_ERROR ((LM_ERROR, "ERROR: Exception caught: %s\"%s\"\n"
, ex._name(), ex._rep_id ()));
return 1;
}
return 0;
}
