diff options
Diffstat (limited to 'TAO/tao/IIOP_Connector.cpp')
| -rw-r--r-- | TAO/tao/IIOP_Connector.cpp | 564 |
1 files changed, 138 insertions, 426 deletions
diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp index e4e96e2716f..408f745549b 100644 --- a/TAO/tao/IIOP_Connector.cpp +++ b/TAO/tao/IIOP_Connector.cpp @@ -1,6 +1,7 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ + #include "tao/IIOP_Connector.h" #include "tao/IIOP_Profile.h" #include "tao/debug.h" @@ -9,319 +10,73 @@ #include "tao/Environment.h" #include "ace/Auto_Ptr.h" #include "tao/RT_Policy_i.h" +#include "tao/Base_Connection_Property.h" +#include "ace/Strategies_T.h" ACE_RCSID(tao, IIOP_Connector, "$Id$") -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) -int -TAO_IIOP_Connector::purge_connections (void) -{ - return this->cached_connect_strategy_->purge_connections (); -} - -#define TAO_HANDLER TAO_IIOP_Client_Connection_Handler -#define TAO_SVC_TUPLE ACE_Svc_Tuple<TAO_HANDLER> -#define TAO_ADDR TAO_IIOP_Connector::TAO_IADDR -#define TAO_HASH_KEY TAO_IIOP_Connector::TAO_HASH_KEY -#define TAO_COMPARE_KEYS TAO_IIOP_Connector::TAO_COMPARE_KEYS -#define TAO_ATTRIBUTES TAO_IIOP_Connector::TAO_ATTRIBUTES -#define TAO_CACHED_HANDLER TAO_IIOP_Connector::TAO_CACHED_HANDLER -#define TAO_HASH_MAP TAO_IIOP_Connector::TAO_HASH_MAP -#define TAO_HASH_MAP_ITERATOR TAO_IIOP_Connector::TAO_HASH_MAP_ITERATOR -#define TAO_HASH_MAP_REVERSE_ITERATOR TAO_IIOP_Connector::TAO_HASH_MAP_REVERSE_ITERATOR -#define TAO_CACHING_UTILITY TAO_IIOP_Connector::TAO_CACHING_UTILITY -#define TAO_CACHING_STRATEGY TAO_IIOP_Connector::TAO_CACHING_STRATEGY -#define TAO_CACHED_CONNECT_STRATEGY TAO_IIOP_Connector::TAO_CACHED_CONNECT_STRATEGY - -typedef ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> - TAO_IIOP_LRU_CACHING_STRATEGY; - -#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES) || (TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 1) -typedef TAO_IIOP_LRU_CACHING_STRATEGY - TAO_IIOP_CACHING_STRATEGY; -#else -#if (TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 0) -typedef ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> - TAO_IIOP_CACHING_STRATEGY; -typedef ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> - TAO_IIOP_LFU_CACHING_STRATEGY; -typedef ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> - TAO_IIOP_FIFO_CACHING_STRATEGY; -typedef ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> - TAO_IIOP_NULL_CACHING_STRATEGY; -typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LRU_CACHING_STRATEGY> - TAO_IIOP_LRU_CACHING_STRATEGY_ADAPTER; -typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LFU_CACHING_STRATEGY> - TAO_IIOP_LFU_CACHING_STRATEGY_ADAPTER; -typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_FIFO_CACHING_STRATEGY> - TAO_IIOP_FIFO_CACHING_STRATEGY_ADAPTER; -typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_NULL_CACHING_STRATEGY> - TAO_IIOP_NULL_CACHING_STRATEGY_ADAPTER; -#endif /* TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY = 0*/ -#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES or TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY*/ - -int -TAO_IIOP_Connector::make_caching_strategy (void) -{ - TAO_Resource_Factory *resource_factory = - this->orb_core_->resource_factory (); - -#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES) || (TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 1) - ACE_NEW_RETURN (this->caching_strategy_, - TAO_IIOP_CACHING_STRATEGY, - -1); -#else -#if (TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 0) - switch (resource_factory->connection_caching_strategy_type ()) - { - case TAO_Resource_Factory::NOOP: - ACE_NEW_RETURN (this->caching_strategy_, - TAO_IIOP_NULL_CACHING_STRATEGY_ADAPTER, - -1); - break; - - default: - case TAO_Resource_Factory::LRU: - ACE_NEW_RETURN (this->caching_strategy_, - TAO_IIOP_LRU_CACHING_STRATEGY_ADAPTER, - -1); - break; - - case TAO_Resource_Factory::LFU: - ACE_NEW_RETURN (this->caching_strategy_, - TAO_IIOP_LFU_CACHING_STRATEGY_ADAPTER, - -1); - break; - - case TAO_Resource_Factory::FIFO: - ACE_NEW_RETURN (this->caching_strategy_, - TAO_IIOP_FIFO_CACHING_STRATEGY_ADAPTER, - -1); - break; - } -#endif /* TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 0*/ -#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES or - TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 1*/ - - this->caching_strategy_->purge_percent (resource_factory->purge_percentage ()); - return 0; -} -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ - -// The TAO_Cached_Connector_Lock template instantiations are in -// Resource_Factory.cpp. - -#if !defined (TAO_USES_ROBUST_CONNECTION_MGMT) -#define TAO_SVC_TUPLE ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler> -#define CACHED_CONNECT_STRATEGY ACE_Cached_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR, TAO_Cached_Connector_Lock> -#define TAO_ADDR ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> -#define TAO_HANDLER TAO_IIOP_Client_Connection_Handler -#define TAO_HASH_KEY ACE_Hash<TAO_ADDR> -#define TAO_COMPARE_KEYS ACE_Equal_To<TAO_ADDR> -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ - -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ - defined (ACE_HAS_GNU_REPO) - -template class ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr>; -template class ACE_Auto_Basic_Array_Ptr<TAO_IIOP_Client_Connection_Handler*>; -template class auto_ptr<TAO_IIOP_Connect_Creation_Strategy>; -template class ACE_Auto_Basic_Ptr<TAO_IIOP_Connect_Creation_Strategy>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) template class ACE_Node<ACE_INET_Addr>; template class ACE_Unbounded_Stack<ACE_INET_Addr>; -template class ACE_Unbounded_Stack_Iterator<ACE_INET_Addr>; - -#if !defined (TAO_USES_ROBUST_CONNECTION_MGMT) -template class CACHED_CONNECT_STRATEGY; -template class TAO_ADDR; -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ - -template class ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>; template class ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>; -template class ACE_NOOP_Creation_Strategy<TAO_HANDLER>; -template class ACE_Concurrency_Strategy<TAO_HANDLER>; -template class ACE_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR>; -template class ACE_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR>; -template class ACE_Creation_Strategy<TAO_HANDLER>; -template class ACE_Hash_Map_Entry<TAO_ADDR, TAO_HANDLER *>; -template class ACE_Hash<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> >; +template class ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr>; +template class ACE_Hash<ARHR<ACE_INET_Addr> >; template class ACE_Equal_To<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> >; -template class ACE_Map_Entry<ACE_HANDLE, TAO_SVC_TUPLE *>; -template class ACE_Map_Manager<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>; -template class ACE_Map_Iterator_Base<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>; -template class ACE_Map_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>; -template class ACE_Map_Reverse_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>; -template class ACE_NOOP_Concurrency_Strategy<TAO_HANDLER>; -template class ACE_Recycling_Strategy<TAO_HANDLER>; -template class ACE_Strategy_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR>; -template class TAO_SVC_TUPLE; - -template class ACE_Hash_Map_Manager<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>; -template class ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; - -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) -template class ACE_Pair<TAO_HANDLER *, TAO_ATTRIBUTES>; -template class ACE_Reference_Pair<TAO_ADDR, TAO_HANDLER *>; -template class ACE_Hash_Map_Entry<TAO_ADDR, TAO_CACHED_HANDLER>; - -template class ACE_Hash_Map_Manager<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>; -template class ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>; - -// = Caching_Strategy -template class ACE_Hash_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>; - -template class ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>; - -#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES) -#if (TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 0) -template class ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>; -template class ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>; -template class ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>; -template class ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>; - -template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LRU_CACHING_STRATEGY>; -template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LFU_CACHING_STRATEGY>; -template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_FIFO_CACHING_STRATEGY>; -template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_NULL_CACHING_STRATEGY>; - -template class ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>; -template class ACE_Cache_Map_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>; -template class ACE_Cache_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>; -#endif /*TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 0*/ -#else - -template class ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>; - -#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES*/ - -template class ACE_Cached_Connect_Strategy_Ex<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES, TAO_Cached_Connector_Lock>; -template class ACE_Cached_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_Cached_Connector_Lock>; - -template class ACE_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>; -template class ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>; -template class ACE_Refcounted_Recyclable_Handler_Caching_Utility<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_ATTRIBUTES>; -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ -#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +template class ACE_NOOP_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler>; +template class ACE_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler>; +template class ACE_Creation_Strategy<TAO_IIOP_Client_Connection_Handler>; +template class ACE_Strategy_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>; +template class ACE_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>; +template class ACE_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>; +template class ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>; + +template class ACE_Map_Manager<int, ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler> *, ACE_SYNCH_RW_MUTEX>; +template class ACE_Map_Iterator_Base<int, ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler> *, ACE_SYNCH_RW_MUTEX>; +template class ACE_Map_Entry<int,ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>*>; +template class ACE_Map_Iterator<int,ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>*,ACE_SYNCH_RW_MUTEX>; +template class ACE_Map_Reverse_Iterator<int,ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>*,ACE_SYNCH_RW_MUTEX>; +template class ACE_Auto_Basic_Array_Ptr<TAO_IIOP_Client_Connection_Handler*>; -#pragma instantiate ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr> -#pragma instantiate ACE_Auto_Basic_Array_Ptr<TAO_IIOP_Client_Connection_Handler*> -#pragma instantiate auto_ptr<TAO_IIOP_Connect_Creation_Strategy> -#pragma instantiate ACE_Auto_Basic_Ptr<TAO_IIOP_Connect_Creation_Strategy> +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) #pragma instantiate ACE_Node<ACE_INET_Addr> #pragma instantiate ACE_Unbounded_Stack<ACE_INET_Addr> -#pragma instantiate ACE_Unbounded_Stack_Iterator<ACE_INET_Addr> - -#if !defined (TAO_USES_ROBUST_CONNECTION_MGMT) -#pragma instantiate CACHED_CONNECT_STRATEGY -#pragma instantiate TAO_ADDR -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ - -#pragma instantiate ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> #pragma instantiate ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> -#pragma instantiate ACE_NOOP_Creation_Strategy<TAO_HANDLER> -#pragma instantiate ACE_Concurrency_Strategy<TAO_HANDLER> -#pragma instantiate ACE_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR> -#pragma instantiate ACE_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR> -#pragma instantiate ACE_Creation_Strategy<TAO_HANDLER> -#pragma instantiate ACE_Hash_Map_Entry<TAO_ADDR, TAO_HANDLER *> -#pragma instantiate ACE_Hash<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> > #pragma instantiate ACE_Equal_To<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> > -#pragma instantiate ACE_Map_Entry<ACE_HANDLE, TAO_SVC_TUPLE *> -#pragma instantiate ACE_Map_Manager<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Map_Iterator_Base<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Map_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Map_Reverse_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_NOOP_Concurrency_Strategy<TAO_HANDLER> -#pragma instantiate ACE_Recycling_Strategy<TAO_HANDLER> -#pragma instantiate ACE_Strategy_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR> -#pragma instantiate TAO_SVC_TUPLE - -#pragma instantiate ACE_Hash_Map_Manager<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> - -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) -#pragma instantiate ACE_Pair<TAO_HANDLER *, TAO_ATTRIBUTES> -#pragma instantiate ACE_Reference_Pair<TAO_ADDR, TAO_HANDLER *> -#pragma instantiate ACE_Hash_Map_Entry<TAO_ADDR, TAO_CACHED_HANDLER> - -#pragma instantiate ACE_Hash_Map_Manager<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex> - -// = Caching_Strategy -#pragma instantiate ACE_Hash_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES> - -#pragma instantiate ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> - -#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES) -#if (TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 0) - -#pragma instantiate ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> -#pragma instantiate ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> -#pragma instantiate ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> -#pragma instantiate ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY> - -#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LRU_CACHING_STRATEGY> -#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LFU_CACHING_STRATEGY> -#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_FIFO_CACHING_STRATEGY> -#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_NULL_CACHING_STRATEGY> - -#pragma instantiate ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES> -#pragma instantiate ACE_Cache_Map_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES> -#pragma instantiate ACE_Cache_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES> -#endif /* TAO_HAS_MINIMUM_CONNECTION_CACHING_STRATEGY == 0 */ -#else - -#pragma instantiate ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES> - -#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES*/ - -#pragma instantiate ACE_Cached_Connect_Strategy_Ex<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES, TAO_Cached_Connector_Lock> -#pragma instantiate ACE_Cached_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_Cached_Connector_Lock> - -#pragma instantiate ACE_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP> -#pragma instantiate ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP> -#pragma instantiate ACE_Refcounted_Recyclable_Handler_Caching_Utility<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_ATTRIBUTES> -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ +#pragma instantiate ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr> +#pragma instantiate ACE_Hash<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> > + +#pragma instantiate ACE_NOOP_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler> +#pragma instantiate ACE_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler> +#pragma instantiate ACE_Strategy_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR> +#pragma instantiate ACE_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR> + +#pragma instantiate ACE_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_Connector> +#pragma instantiate ACE_Creation_Strategy<TAO_IIOP_Client_Connection_Handler> +#pragma instantiate ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler> +#pragma instantiate ACE_Map_Manager<int, ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler> *, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Map_Iterator_Base<int, ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler> *, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Map_Entry<int,ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>*> +#pragma instantiate ACE_Map_Iterator<int,ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>*,ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Map_Reverse_Iterator<int,ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>*,ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Auto_Basic_Array_Ptr<TAO_IIOP_Client_Connection_Handler*> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + TAO_IIOP_Connect_Creation_Strategy:: TAO_IIOP_Connect_Creation_Strategy (ACE_Thread_Manager* t, TAO_ORB_Core *orb_core, void *arg, CORBA::Boolean flag) - : ACE_Creation_Strategy<TAO_IIOP_Client_Connection_Handler> (t), - orb_core_ (orb_core), - arg_ (arg), - lite_flag_ (flag) + : ACE_Creation_Strategy<TAO_IIOP_Client_Connection_Handler> (t), + orb_core_ (orb_core), + arg_ (arg), + lite_flag_ (flag) { + } int @@ -341,36 +96,17 @@ TAO_IIOP_Connect_Creation_Strategy::make_svc_handler // **************************************************************** -#if !defined (TAO_USES_ROBUST_CONNECTION_MGMT) -typedef ACE_Cached_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, - ACE_SOCK_CONNECTOR, - TAO_Cached_Connector_Lock> - TAO_CACHED_CONNECT_STRATEGY; -#endif /* ! TAO_USES_ROBUST_CONNECTION_MGMT */ - - TAO_IIOP_Connector::TAO_IIOP_Connector (CORBA::Boolean flag) : TAO_Connector (TAO_TAG_IIOP_PROFILE), - - orb_core_ (0), base_connector_ (), lite_flag_ (flag) -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) - , cached_connect_strategy_ (0), - caching_strategy_ (0) -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ { } int TAO_IIOP_Connector::open (TAO_ORB_Core *orb_core) { - this->orb_core_ = orb_core; - -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) - if (this->make_caching_strategy () == -1) - return -1; -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ + this->orb_core (orb_core); if (this->init_tcp_properties () != 0) return -1; @@ -379,92 +115,27 @@ TAO_IIOP_Connector::open (TAO_ORB_Core *orb_core) ACE_NEW_RETURN (connect_creation_strategy, TAO_IIOP_Connect_Creation_Strategy - (this->orb_core_->thr_mgr (), - this->orb_core_, + (this->orb_core ()->thr_mgr (), + this->orb_core (), &(this->tcp_properties_), this->lite_flag_), -1); - auto_ptr<TAO_IIOP_Connect_Creation_Strategy> - new_connect_creation_strategy (connect_creation_strategy); - - TAO_Cached_Connector_Lock *connector_lock = 0; - ACE_NEW_RETURN (connector_lock, - TAO_Cached_Connector_Lock (this->orb_core_), - -1); - - auto_ptr<TAO_Cached_Connector_Lock> new_connector_lock (connector_lock); - -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) - ACE_NEW_RETURN (this->cached_connect_strategy_, - TAO_CACHED_CONNECT_STRATEGY (*this->caching_strategy_, - new_connect_creation_strategy.get (), - 0, - 0, - new_connector_lock.get (), - 1), - -1); -#else /* TAO_USES_ROBUST_CONNECTION_MGMT */ - TAO_CACHED_CONNECT_STRATEGY *cached_connect_strategy = 0; - ACE_NEW_RETURN (cached_connect_strategy, - TAO_CACHED_CONNECT_STRATEGY - (new_connect_creation_strategy.get (), - 0, - 0, - new_connector_lock.get (), - 1), - -1); -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ - - // Finally everything is fine. Make sure to take ownership away - // from the auto pointer. - connect_creation_strategy = - new_connect_creation_strategy.release (); - connector_lock = - new_connector_lock.release (); - -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) - - return this->base_connector_.open (this->orb_core_->reactor (), - &this->null_creation_strategy_, - this->cached_connect_strategy_, - &this->null_activation_strategy_); - -#else /* TAO_USES_ROBUST_CONNECTION_MGMT */ - - return this->base_connector_.open (this->orb_core_->reactor (), - &this->null_creation_strategy_, - cached_connect_strategy, + return this->base_connector_.open (this->orb_core ()->reactor (), + connect_creation_strategy, + &this->connect_strategy_, &this->null_activation_strategy_); - -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ - } int TAO_IIOP_Connector::close (void) { - this->base_connector_.close (); - - // Zap the creation strategy that we created earlier -#if defined (TAO_USES_ROBUST_CONNECTION_MGMT) - delete this->cached_connect_strategy_->creation_strategy (); - delete this->cached_connect_strategy_; - delete this->caching_strategy_; -#else /* TAO_USES_ROBUST_CONNECTION_MGMT */ - TAO_CACHED_CONNECT_STRATEGY *cached_connect_strategy = - ACE_dynamic_cast (TAO_CACHED_CONNECT_STRATEGY *, - this->base_connector_.connect_strategy ()); - - delete cached_connect_strategy->creation_strategy (); - delete cached_connect_strategy; -#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */ - - return 0; + delete this->base_connector_.creation_strategy (); + return this->base_connector_.close (); } int -TAO_IIOP_Connector::connect (TAO_Endpoint *endpoint, +TAO_IIOP_Connector::connect (TAO_Base_Connection_Property *prop, TAO_Transport *&transport, ACE_Time_Value *max_wait_time, CORBA::Environment &) @@ -474,12 +145,14 @@ TAO_IIOP_Connector::connect (TAO_Endpoint *endpoint, ACE_TEXT ("TAO (%P|%t) Connector::connect - ") ACE_TEXT ("looking for IIOP connection.\n"))); + TAO_Endpoint *endpoint = prop->endpoint (); + if (endpoint->tag () != TAO_TAG_IIOP_PROFILE) return -1; TAO_IIOP_Endpoint *iiop_endpoint = ACE_dynamic_cast (TAO_IIOP_Endpoint *, - endpoint); + endpoint ); if (iiop_endpoint == 0) return -1; @@ -503,49 +176,87 @@ TAO_IIOP_Connector::connect (TAO_Endpoint *endpoint, return -1; } - TAO_IIOP_Client_Connection_Handler *svc_handler = 0; int result = 0; + TAO_IIOP_Client_Connection_Handler *svc_handler = 0; + TAO_Connection_Handler *conn_handler = 0; - if (max_wait_time != 0) + // Check the Cache first for connections + if (this->orb_core ()->connection_cache ().find_handler (prop, + conn_handler) == 0) { - ACE_Synch_Options synch_options (ACE_Synch_Options::USE_TIMEOUT, - *max_wait_time); - - // The connect call will set the hint () stored in the Endpoint - // object; but we obtain the transport in the <svc_handler> - // variable. Other threads may modify the hint, but we are not - // affected. - result = this->base_connector_.connect (iiop_endpoint->hint (), - svc_handler, - remote_address, - synch_options); + if (TAO_debug_level > 5) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%P|%t) IIOP_Connector::connect ") + ACE_TEXT ("got an existing connection \n"))); + // We have found a connection and a handler + svc_handler = + ACE_dynamic_cast (TAO_IIOP_Client_Connection_Handler *, + conn_handler); } else { - // The connect call will set the hint () stored in the Endpoint - // object; but we obtain the transport in the <svc_handler> - // variable. Other threads may modify the hint, but we are not - // affected. - result = this->base_connector_.connect (iiop_endpoint->hint (), - svc_handler, - remote_address); - } + if (TAO_debug_level > 4) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%P|%t) IIOP_Connector::connect ") + ACE_TEXT ("making a new connection \n"))); - if (result == -1) - { - // Give users a clue to the problem. - if (TAO_orbdebug) + // @@ This needs to change in the next round when we implement a + // policy that will not allow new connections when a connection + // is busy. + if (max_wait_time != 0) { - ACE_DEBUG ((LM_ERROR, - ACE_TEXT ("(%P|%t) %s:%u, connection to ") - ACE_TEXT ("%s:%d failed (%p)\n"), - __FILE__, - __LINE__, - iiop_endpoint->host (), - iiop_endpoint->port (), - "errno")); + ACE_Synch_Options synch_options (ACE_Synch_Options::USE_TIMEOUT, + *max_wait_time); + + // We obtain the transport in the <svc_handler> variable. As + // we know now that the connection is not available in Cache + // we can make a new connection + result = this->base_connector_.connect (svc_handler, + remote_address, + synch_options); + } + else + { + // We obtain the transport in the <svc_handler> variable. As + // we know now that the connection is not available in Cache + // we can make a new connection + result = this->base_connector_.connect (svc_handler, + remote_address); + } + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%P|%t) IIOP_Connector::connect ") + ACE_TEXT ("The result is <%d> \n"), result)); + + if (result == -1) + { + // Give users a clue to the problem. + if (TAO_debug_level) + { + ACE_DEBUG ((LM_ERROR, + ACE_TEXT ("(%P|%t) %s:%u, connection to ") + ACE_TEXT ("%s:%d failed (%p)\n"), + __FILE__, + __LINE__, + iiop_endpoint->host (), + iiop_endpoint->port (), + "errno")); + } + return -1; + } + + // Add the handler to Cache + int retval = + this->orb_core ()->connection_cache ().cache_handler (prop, + svc_handler); + + if (retval != 0 && TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%P|%t) IIOP_Connector::connect ") + ACE_TEXT ("could not add the new connection to Cache \n"))); } - return -1; } transport = svc_handler->transport (); @@ -675,6 +386,7 @@ TAO_IIOP_Connector::preconnect (const char *preconnects) if (!failures[slot]) { handlers[slot]->idle (); + // Add it to cache.. successes++; if (TAO_debug_level > 0) @@ -708,7 +420,7 @@ TAO_IIOP_Connector::create_profile (TAO_InputCDR& cdr) { TAO_Profile *pfile; ACE_NEW_RETURN (pfile, - TAO_IIOP_Profile (this->orb_core_), + TAO_IIOP_Profile (this->orb_core ()), 0); int r = pfile->decode (cdr); @@ -733,7 +445,7 @@ TAO_IIOP_Connector::make_profile (const char *endpoint, ACE_NEW_THROW_EX (profile, TAO_IIOP_Profile (endpoint, - this->orb_core_, + this->orb_core (), ACE_TRY_ENV), CORBA::NO_MEMORY ()); @@ -789,12 +501,12 @@ TAO_IIOP_Connector::init_tcp_properties (void) // overrides for protocol configuration because connection // lookup and caching are not done based on protocol // properties. - + ACE_DECLARE_NEW_CORBA_ENV; // Check ORB-level override for tcp properties. TAO_ClientProtocolPolicy *client_protocols = - this->orb_core_->policy_manager ()->client_protocol (); + this->orb_core ()->policy_manager ()->client_protocol (); CORBA::Object_var auto_release = client_protocols; RTCORBA::TCPProtocolProperties_var tcp_properties = RTCORBA::TCPProtocolProperties::_nil (); @@ -802,7 +514,7 @@ TAO_IIOP_Connector::init_tcp_properties (void) if (client_protocols != 0) { RTCORBA::ProtocolList & protocols = client_protocols->protocols_rep (); - + for (CORBA::ULong j = 0; j < protocols.length (); ++j) if (protocols[j].protocol_type == TAO_TAG_IIOP_PROFILE) { @@ -820,7 +532,7 @@ TAO_IIOP_Connector::init_tcp_properties (void) // No tcp properties in ORB-level override. Use ORB defaults. // Orb defaults should never be null - they were initialized by // the ORB_Core. - client_protocols = this->orb_core_->default_client_protocol (); + client_protocols = this->orb_core ()->default_client_protocol (); auto_release = client_protocols; RTCORBA::ProtocolList & protocols = client_protocols->protocols_rep (); for (CORBA::ULong j = 0; j < protocols.length (); ++j) @@ -848,11 +560,11 @@ TAO_IIOP_Connector::init_tcp_properties (void) // Without RTCORBA, protocol configuration properties come from ORB // options. this->tcp_properties_.send_buffer_size = - this->orb_core_->orb_params ()->sock_sndbuf_size (); + this->orb_core ()->orb_params ()->sock_sndbuf_size (); this->tcp_properties_.recv_buffer_size = - this->orb_core_->orb_params ()->sock_rcvbuf_size (); + this->orb_core ()->orb_params ()->sock_rcvbuf_size (); this->tcp_properties_.no_delay = - this->orb_core_->orb_params ()->nodelay (); + this->orb_core ()->orb_params ()->nodelay (); #endif /* TAO_HAS_RT_CORBA == 1 */ |