diff options
Diffstat (limited to 'TAO/tao/Transport_Connector.h')
| -rw-r--r-- | TAO/tao/Transport_Connector.h | 243 |
1 files changed, 243 insertions, 0 deletions
diff --git a/TAO/tao/Transport_Connector.h b/TAO/tao/Transport_Connector.h new file mode 100644 index 00000000000..22a99ac0e47 --- /dev/null +++ b/TAO/tao/Transport_Connector.h @@ -0,0 +1,243 @@ +// This may look like C, but it's really -*- C++ -*- + +//============================================================================= +/** + * @file Transport_Connector.h + * + * $Id$ + * + * Define the interface for the Connector component in TAO's + * pluggable protocol framework. + * + * @author Fred Kuhns <fredk@cs.wustl.edu> + */ +//============================================================================= + +#ifndef TAO_CONNECTOR_H +#define TAO_CONNECTOR_H + +#include /**/ "ace/pre.h" +#include "ace/CORBA_macros.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include /**/ "tao/TAO_Export.h" +#include "tao/Basic_Types.h" + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL +class ACE_Time_Value; +ACE_END_VERSIONED_NAMESPACE_DECL + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +class TAO_Transport_Descriptor_Interface; +class TAO_InputCDR; +class TAO_Endpoint; +class TAO_Profile; +class TAO_MProfile; +class TAO_ORB_Core; +class TAO_Connect_Strategy; +class TAO_Transport; +class TAO_Connection_Handler; +class TAO_LF_Multi_Event; + +namespace TAO +{ + class Profile_Transport_Resolver; +} + +namespace CORBA +{ + class Environment; +} + +/* + * Hook to add includes and forward declaration + * to the Connector class. + */ +//@@ TAO_CONNECTOR_SPL_INCLUDE_FORWARD_DECL_ADD_HOOK + +/** + * @class TAO_Connector + * + * @brief Generic Connector interface definitions. + * + * Base class for connector bridge object. + * + * @todo Need to rename the class as TAO_Transport_Connector. + */ +class TAO_Export TAO_Connector +{ +public: + + /// Default constructor. + TAO_Connector (CORBA::ULong tag); + + /// The destructor. + virtual ~TAO_Connector (void); + + /** + * 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. + */ + CORBA::ULong tag (void) const; + + /// Parse a string containing a URL style IOR and return an + /// MProfile. Verify that ior is in the correct format. + int make_mprofile ( + const char *ior, + TAO_MProfile &mprofile + ACE_ENV_ARG_DECL); + + /// 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(). + virtual TAO_Profile * corbaloc_scan (const char *ior, + size_t &len + ACE_ENV_ARG_DECL); + + /// Initialize object and register with reactor. + virtual int open ( + TAO_ORB_Core *orb_core) = 0; + + /// Shutdown Connector bridge and concrete Connector. + virtual int close (void) = 0; + + /** + * 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. + */ + virtual TAO_Transport* connect ( + TAO::Profile_Transport_Resolver *r, + TAO_Transport_Descriptor_Interface *desc, + ACE_Time_Value *timeout + ACE_ENV_ARG_DECL); + + /// A variation on connect that will try simultanious connections + /// on all endpoints listed in the desc. + virtual TAO_Transport* parallel_connect ( + TAO::Profile_Transport_Resolver *r, + TAO_Transport_Descriptor_Interface *desc, + ACE_Time_Value *timeout + ACE_ENV_ARG_DECL); + + /// Create a profile for this protocol and initialize it based on the + /// encapsulation in @a cdr + virtual TAO_Profile *create_profile ( + TAO_InputCDR& cdr) = 0; + + /// Check that the prefix of the provided endpoint is valid for use + /// with a given pluggable protocol. + virtual int check_prefix ( + const char *endpoint) = 0; + + /// Return the object key delimiter to use or expect. + virtual char object_key_delimiter (void) const = 0; + + //@@ TAO_CONNECTOR_SPL_PUBLIC_METHODS_ADD_HOOK + +protected: + /// 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. + virtual int supports_parallel_connects (void) const; + + /// Create a profile with a given endpoint. + virtual TAO_Profile *make_profile (ACE_ENV_SINGLE_ARG_DECL) = 0; + + /// Set and validate endpoint. We need to do this to initialize our + /// remote *_Addr's which have not been done during IOR decode. + virtual int set_validate_endpoint (TAO_Endpoint *endpoint) = 0; + + /// Make a connection + virtual TAO_Transport* make_connection ( + TAO::Profile_Transport_Resolver *r, + TAO_Transport_Descriptor_Interface &desc, + ACE_Time_Value *timeout) = 0; + + /// Make a connection using - not a pure virtual since not all + /// protocols support this. + virtual TAO_Transport* make_parallel_connection ( + TAO::Profile_Transport_Resolver *r, + TAO_Transport_Descriptor_Interface &desc, + ACE_Time_Value *timeout); + + /// Cancel the passed cvs handler from the connector + virtual int cancel_svc_handler ( + TAO_Connection_Handler *svc_handler) = 0; + + /// Check whether the connection is not closed + /** + * @retval 0 The connection happens to be not closed, but is now open + * because an other thread managed to open the handler + * @retval -1 The connection is closed + */ + virtual int check_connection_closure ( + TAO_Connection_Handler *connection_handler); + + /** + * Wait for connection completion. We have a transport that is not + * connected yet, wait until it is connected. + * @retval true When we could use @a transport + * @return false When we can't use the @a transport + */ + virtual bool wait_for_connection_completion( + TAO::Profile_Transport_Resolver *r, + TAO_Transport *&transport, + ACE_Time_Value *timeout); + + /// 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. + 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); + + /// Set the ORB Core pointer + void orb_core (TAO_ORB_Core *orb_core); + + /// Create a connect strategy + int create_connect_strategy (void); + + /// Return the TAO_ORB_Core pointer + TAO_ORB_Core *orb_core (void); + +protected: + + /// The (a)synch connect strategy + TAO_Connect_Strategy *active_connect_strategy_; + +private: + + /// IOP protocol tag. + CORBA::ULong const tag_; + + /// Pointer to our ORB core + TAO_ORB_Core *orb_core_; + + //@@ TAO_CONNECTOR_SPL_PRIVATE_DATA_ADD_HOOK +}; + +//@@ TAO_CONNECTOR_SPL_EXTERN_ADD_HOOK + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined (__ACE_INLINE__) +# include "tao/Transport_Connector.inl" +#endif /* __ACE_INLINE__ */ + +#include /**/ "ace/post.h" +#endif /*TAO_CONNECTOR_H*/ |