#include <Connection_Handler.h>
Public Member Functions | |
TAO_Connection_Handler (void) | |
Constructor. | |
TAO_Connection_Handler (TAO_ORB_Core *orb_core) | |
Constructor. | |
virtual | ~TAO_Connection_Handler (void) |
Destructor. | |
TAO_Transport * | transport (void) |
Return the underlying transport object. | |
void | transport (TAO_Transport *transport) |
Set the underlying transport object. | |
bool | is_closed (void) const |
Is the handler closed or timed out? | |
bool | is_open (void) const |
Is the handler open? | |
bool | is_timeout (void) const |
Closed due to timeout? | |
bool | is_connecting (void) const |
Is the handler in the process of being connected? | |
virtual int | close_connection (void)=0 |
Close the underlying connection. | |
virtual int | handle_input (ACE_HANDLE fd)=0 |
int | svc_i (void) |
virtual int | open_handler (void *)=0 |
A open () hook. | |
virtual int | close_handler (u_long flags=0) |
void | connection_pending (void) |
void | cancel_pending_connection (void) |
virtual int | set_dscp_codepoint (CORBA::Boolean set_network_priority) |
virtual int | set_dscp_codepoint (CORBA::Long dscp_codepoint) |
virtual int | release_os_resources (void) |
Release the OS resources related to this handler. | |
virtual int | handle_write_ready (const ACE_Time_Value *timeout) |
Protected Member Functions | |
TAO_ORB_Core * | orb_core (void) |
Return our TAO_ORB_Core pointer. | |
int | shared_open (void) |
int | set_socket_option (ACE_SOCK &sock, int snd_size, int rcv_size) |
Set options on the socket. | |
Helper methods for Event_Handler-based derived classes. | |
Many (actually all so far) implementations of TAO_Connection_Handler are a mixin of TAO_Connection_Handler and some form of ACE_Event_Handler. The following methods simplify such implementations by capturing the common code in a single place. | |
int | handle_output_eh (ACE_HANDLE h, ACE_Event_Handler *eh) |
Implement the handle_output() callback. | |
int | handle_input_eh (ACE_HANDLE h, ACE_Event_Handler *eh) |
Implement the handle_input() callback. | |
int | handle_input_internal (ACE_HANDLE h, ACE_Event_Handler *eh) |
Implement the handle_output() callback. | |
int | close_connection_eh (ACE_Event_Handler *eh) |
virtual void | pre_io_hook (int &return_value) |
virtual void | pos_io_hook (int &return_value) |
Private Member Functions | |
void | operator= (const TAO_Connection_Handler &) |
TAO_Connection_Handler (const TAO_Connection_Handler &) | |
Private Attributes | |
TAO_ORB_Core *const | orb_core_ |
Pointer to the TAO_ORB_Core. | |
TAO_Transport * | transport_ |
Transport object reference. | |
ACE_Lock * | lock_ |
bool | connection_pending_ |
Stores the connection pending state. | |
bool | is_closed_ |
This class is an abstraction for the connection handlers. The connections handler in every protocol can derive from this class as well as the ACE_Svc_Handler specialised for the right protocol. This way, most of the common code for the different protocols would be in this implementation.
TAO_Connection_Handler::TAO_Connection_Handler | ( | void | ) |
Constructor.
TAO_Connection_Handler::TAO_Connection_Handler | ( | TAO_ORB_Core * | orb_core | ) |
Constructor.
TAO_Connection_Handler::~TAO_Connection_Handler | ( | void | ) | [virtual] |
Destructor.
TAO_Connection_Handler::TAO_Connection_Handler | ( | const TAO_Connection_Handler & | ) | [private] |
void TAO_Connection_Handler::cancel_pending_connection | ( | void | ) | [inline] |
A pending connection may be canceled due to an error detected while the initiating thread is still in the Connector.
virtual int TAO_Connection_Handler::close_connection | ( | void | ) | [pure virtual] |
Close the underlying connection.
Used by the ORB to actively close connections that are idle, stale or somehow are determined to be broken before the Reactor does.
Implemented in TAO_IIOP_Connection_Handler.
int TAO_Connection_Handler::close_connection_eh | ( | ACE_Event_Handler * | eh | ) | [protected] |
Implement close_connection() for Connection_Handlers that are also Event_Handlers.
int TAO_Connection_Handler::close_handler | ( | u_long | flags = 0 |
) | [virtual] |
A close() hook, called by the Transport Connector when they want to close this handler
void TAO_Connection_Handler::connection_pending | ( | void | ) | [inline] |
When waiting for an asynchronous connection to complete an additional reference must be maintained, related to bugzilla #2417. However once the connection is successfully established, this reference must be removed. Using connection_pending allows the connection handler to know that it is opening as a result of a delayed asynch connection rather than an immediate synch connection, which has no additional reference needs.
virtual int TAO_Connection_Handler::handle_input | ( | ACE_HANDLE | fd | ) | [pure virtual] |
The event handler calls, here so that other objects who hold a reference to this object can call the event handler methods.
Implemented in TAO_IIOP_Connection_Handler.
int TAO_Connection_Handler::handle_input_eh | ( | ACE_HANDLE | h, | |
ACE_Event_Handler * | eh | |||
) | [protected] |
Implement the handle_input() callback.
int TAO_Connection_Handler::handle_input_internal | ( | ACE_HANDLE | h, | |
ACE_Event_Handler * | eh | |||
) | [protected] |
Implement the handle_output() callback.
int TAO_Connection_Handler::handle_output_eh | ( | ACE_HANDLE | h, | |
ACE_Event_Handler * | eh | |||
) | [protected] |
Implement the handle_output() callback.
int TAO_Connection_Handler::handle_write_ready | ( | const ACE_Time_Value * | timeout | ) | [inline, virtual] |
Derived classes should implement this for proper support with the Blocking Flushing Strategy.
Reimplemented in TAO_IIOP_Connection_Handler.
bool TAO_Connection_Handler::is_closed | ( | void | ) | const [inline] |
Is the handler closed or timed out?
bool TAO_Connection_Handler::is_connecting | ( | void | ) | const [inline] |
Is the handler in the process of being connected?
bool TAO_Connection_Handler::is_open | ( | void | ) | const [inline] |
Is the handler open?
bool TAO_Connection_Handler::is_timeout | ( | void | ) | const [inline] |
Closed due to timeout?
virtual int TAO_Connection_Handler::open_handler | ( | void * | ) | [pure virtual] |
A open () hook.
See Thread_Per_Connection_Handler for a use case
Implemented in TAO_IIOP_Connection_Handler.
void TAO_Connection_Handler::operator= | ( | const TAO_Connection_Handler & | ) | [private] |
TAO_ORB_Core * TAO_Connection_Handler::orb_core | ( | void | ) | [inline, protected] |
Return our TAO_ORB_Core pointer.
void TAO_Connection_Handler::pos_io_hook | ( | int & | return_value | ) | [protected, virtual] |
Post-invocation hook for I/O operations (handle_input() & handle_output()) See the SSLIOP protocol for an interesting use-case
void TAO_Connection_Handler::pre_io_hook | ( | int & | return_value | ) | [protected, virtual] |
Pre-invocation hook for I/O operations (handle_input() & handle_output()) See the SSLIOP protocol for an interesting use-case
int TAO_Connection_Handler::release_os_resources | ( | void | ) | [virtual] |
int TAO_Connection_Handler::set_dscp_codepoint | ( | CORBA::Long | dscp_codepoint | ) | [virtual] |
Reimplemented in TAO_IIOP_Connection_Handler.
int TAO_Connection_Handler::set_dscp_codepoint | ( | CORBA::Boolean | set_network_priority | ) | [virtual] |
Set the Diff-Serv codepoint on outgoing packets. Only has effect for remote protocols (e.g., IIOP); no effect for local protocols (UIOP). Default implementation is for local protocols. Remote protocols must overwrite implementation.
Reimplemented in TAO_IIOP_Connection_Handler.
int TAO_Connection_Handler::set_socket_option | ( | ACE_SOCK & | sock, | |
int | snd_size, | |||
int | rcv_size | |||
) | [protected] |
Set options on the socket.
int TAO_Connection_Handler::shared_open | ( | void | ) | [protected] |
A common function called at the start of any protocol-specific open. Returns -1 on a failure (although no failure mode is currently defined).
int TAO_Connection_Handler::svc_i | ( | void | ) |
This method is invoked from the svc () method of the Svc_Handler Object.
void TAO_Connection_Handler::transport | ( | TAO_Transport * | transport | ) |
Set the underlying transport object.
TAO_Transport * TAO_Connection_Handler::transport | ( | void | ) | [inline] |
Return the underlying transport object.
bool TAO_Connection_Handler::connection_pending_ [private] |
Stores the connection pending state.
bool TAO_Connection_Handler::is_closed_ [private] |
Once closed make sure the transport is not added back to the cache. This is distinct from the leader-follower state so it cannot be reset.
ACE_Lock* TAO_Connection_Handler::lock_ [private] |
Internal state lock, needs to be separate from the reference count / pending upcalls lock because they interleave.
TAO_ORB_Core* const TAO_Connection_Handler::orb_core_ [private] |
Pointer to the TAO_ORB_Core.
TAO_Transport* TAO_Connection_Handler::transport_ [private] |
Transport object reference.