From c2b63a1dedf25171b83136b7d33a6ab4acd56cec Mon Sep 17 00:00:00 2001 From: Chris Cleeland Date: Fri, 23 Mar 2001 18:03:42 +0000 Subject: Commit so that Carlos and others can take a look at the code. --- TAO/tao/GIOP_Message_Base.cpp | 23 ++-- TAO/tao/GIOP_Message_Lite.cpp | 10 +- TAO/tao/GIOP_Utils.cpp | 4 +- TAO/tao/IIOP_Connector.cpp | 6 + TAO/tao/IIOP_Transport.cpp | 52 ++++----- TAO/tao/IIOP_Transport.h | 56 +++++----- TAO/tao/Strategies/SHMIOP_Connector.cpp | 2 + TAO/tao/Strategies/SHMIOP_Transport.cpp | 48 ++++---- TAO/tao/Strategies/SHMIOP_Transport.h | 38 +++++-- TAO/tao/Strategies/UIOP_Connector.cpp | 2 + TAO/tao/Strategies/UIOP_Transport.cpp | 52 +++++---- TAO/tao/Strategies/UIOP_Transport.h | 38 +++++-- TAO/tao/Sync_Strategies.cpp | 8 +- TAO/tao/Transport.cpp | 161 ++++++++++++++++++++++++--- TAO/tao/Transport.h | 191 +++++++++++++++++++++++++++++--- TAO/tao/Transport_Cache_Manager.cpp | 44 ++++++-- 16 files changed, 557 insertions(+), 178 deletions(-) diff --git a/TAO/tao/GIOP_Message_Base.cpp b/TAO/tao/GIOP_Message_Base.cpp index 6db8d12025c..534defedb1f 100644 --- a/TAO/tao/GIOP_Message_Base.cpp +++ b/TAO/tao/GIOP_Message_Base.cpp @@ -880,8 +880,6 @@ TAO_GIOP_Message_Base::send_error (TAO_Transport *transport) (const u_char *) error_message, TAO_GIOP_MESSAGE_HEADER_LEN ); - ACE_HANDLE which = transport->handle (); - ACE_Data_Block data_block (TAO_GIOP_MESSAGE_HEADER_LEN, ACE_Message_Block::MB_DATA, error_message, @@ -897,8 +895,8 @@ TAO_GIOP_Message_Base::send_error (TAO_Transport *transport) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%N|%l|%P|%t) error sending error to %d\n"), - which)); + ACE_TEXT ("TAO (%N|%l|%P|%t) error sending error to transport %lu\n"), + transport->id ())); } return result; @@ -997,6 +995,14 @@ TAO_GIOP_Message_Base:: (const u_char *) close_message, TAO_GIOP_MESSAGE_HEADER_LEN); +#if 0 + // @@CJC I don't think we need this check b/c the transport's send() + // will simply return -1. However, I guess we could create something + // like TAO_Tranport::is_closed() that returns whether the connection + // is already closed. The problem with that, however, is that it's + // entirely possible that is_closed() could return TRUE, and then the + // transport could get closed down btw. the time it gets called and the + // time that the send actually occurs. ACE_HANDLE which = transport->handle (); if (which == ACE_INVALID_HANDLE) { @@ -1006,6 +1012,7 @@ TAO_GIOP_Message_Base:: " connection already closed\n")); return; } +#endif ACE_Data_Block data_block (TAO_GIOP_MESSAGE_HEADER_LEN, ACE_Message_Block::MB_DATA, @@ -1017,18 +1024,18 @@ TAO_GIOP_Message_Base:: ACE_Message_Block message_block(&data_block); message_block.wr_ptr (TAO_GIOP_MESSAGE_HEADER_LEN); - if (transport->send (&message_block) == -1) + if (transport->send (&message_block) == -1 && errno != ENOENT) { if (TAO_orbdebug) ACE_ERROR ((LM_ERROR, - "(%P|%t) error closing connection %d\n", - which)); + "(%P|%t) error closing connection %lu, errno = %d\n", + transport->id (), errno)); } transport->close_connection (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) shut down transport, handle %d\n", - which)); + transport-> id ())); } diff --git a/TAO/tao/GIOP_Message_Lite.cpp b/TAO/tao/GIOP_Message_Lite.cpp index 55c1159bed2..4ef083ccf55 100644 --- a/TAO/tao/GIOP_Message_Lite.cpp +++ b/TAO/tao/GIOP_Message_Lite.cpp @@ -1290,8 +1290,8 @@ TAO_GIOP_Message_Lite::send_reply_exception ( // Close the handle. ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t|%N|%l) cannot marshal exception, handle = %d: %p\n"), - transport->handle (), + ACE_TEXT ("(%P|%t|%N|%l) cannot marshal exception on transport %lu: %p\n"), + transport->id (), ACE_TEXT ("send_reply_exception ()"))); return -1; } @@ -1355,8 +1355,6 @@ TAO_GIOP_Message_Lite::send_error (TAO_Transport *transport) (const u_char *) error_message, TAO_GIOP_LITE_HEADER_LEN); - ACE_HANDLE which = transport->handle (); - ACE_Data_Block data_block (TAO_GIOP_LITE_HEADER_LEN, ACE_Message_Block::MB_DATA, error_message, @@ -1374,8 +1372,8 @@ TAO_GIOP_Message_Lite::send_error (TAO_Transport *transport) { ACE_DEBUG (( LM_DEBUG, - ACE_TEXT ("TAO (%N|%l|%P|%t) error sending error to %d\n"), - which + ACE_TEXT ("TAO (%N|%l|%P|%t) error sending error to transport %lu, errno = %d\n"), + transport->id (), errno )); } } diff --git a/TAO/tao/GIOP_Utils.cpp b/TAO/tao/GIOP_Utils.cpp index fba958a8111..34600301bbd 100644 --- a/TAO/tao/GIOP_Utils.cpp +++ b/TAO/tao/GIOP_Utils.cpp @@ -57,10 +57,10 @@ TAO_GIOP_Utils::read_buffer (TAO_Transport *transport, if (bytes_read <= 0 && TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t|%N|%l) - %p,\n") - ACE_TEXT (" transport = %d, ") + ACE_TEXT (" transport = %lu, ") ACE_TEXT ("bytes = %d, len = %d\n"), ACE_TEXT ("read_buffer"), - transport->handle (), + transport->id (), bytes_read, len)); diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp index bf016deaee9..4f05995a7b7 100644 --- a/TAO/tao/IIOP_Connector.cpp +++ b/TAO/tao/IIOP_Connector.cpp @@ -164,6 +164,11 @@ TAO_IIOP_Connector::connect (TAO_Transport_Descriptor_Interface *desc, if (this->orb_core ()->transport_cache ().find_transport (desc, base_transport) == 0) { +#if 0 + // @@CJC + // Seems that the only reason we have the call to connection_handler is + // to print out the debug message. Yucko! We can ditch it, hopefully. + // We have found a connection and a transport svc_handler = ACE_dynamic_cast (TAO_IIOP_Connection_Handler *, @@ -173,6 +178,7 @@ TAO_IIOP_Connector::connect (TAO_Transport_Descriptor_Interface *desc, ACE_TEXT ("(%P|%t) IIOP_Connector::connect - ") ACE_TEXT ("got an existing connection on HANDLE %d\n"), svc_handler->peer ().get_handle ())); +#endif } else { diff --git a/TAO/tao/IIOP_Transport.cpp b/TAO/tao/IIOP_Transport.cpp index a86c84819b4..9605f6618ef 100644 --- a/TAO/tao/IIOP_Transport.cpp +++ b/TAO/tao/IIOP_Transport.cpp @@ -32,6 +32,10 @@ TAO_IIOP_Transport::TAO_IIOP_Transport (TAO_IIOP_Connection_Handler *handler, , connection_handler_ (handler) , messaging_object_ (0) { + // We'll set the id_ (from TAO_Transport) to the handle from our connection + if (connection_handler_ != 0) + this->id_ = ACE_static_cast (int, this->connection_handler_->get_handle ()); + if (flag) { // Use the lite version of the protocol @@ -51,43 +55,39 @@ TAO_IIOP_Transport::~TAO_IIOP_Transport (void) delete this->messaging_object_; } -TAO_IIOP_SVC_HANDLER * -TAO_IIOP_Transport::service_handler (void) -{ - return this->connection_handler_; -} - +#if 0 ACE_HANDLE TAO_IIOP_Transport::handle (void) { return this->connection_handler_->get_handle (); } +#endif ACE_Event_Handler * -TAO_IIOP_Transport::event_handler (void) +TAO_IIOP_Transport::event_handler_i (void) { return this->connection_handler_; } ssize_t -TAO_IIOP_Transport::send (const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time, - size_t *bytes_transferred) +TAO_IIOP_Transport::send_i (const ACE_Message_Block *message_block, + const ACE_Time_Value *max_wait_time, + size_t *bytes_transferred) { - return ACE::send_n (this->handle (), + return ACE::send_n (this->connection_handler_->get_handle (), message_block, max_wait_time, bytes_transferred); } ssize_t -TAO_IIOP_Transport::recv (char *buf, - size_t len, - const ACE_Time_Value *max_wait_time) +TAO_IIOP_Transport::recv_i (char *buf, + size_t len, + const ACE_Time_Value *max_wait_time) { - return this->service_handler ()->peer ().recv (buf, - len, - max_wait_time); + return this->connection_handler_->peer ().recv (buf, + len, + max_wait_time); } @@ -127,7 +127,7 @@ TAO_IIOP_Transport::read_process_message (ACE_Time_Value *max_wait_time, int -TAO_IIOP_Transport::register_handler (void) +TAO_IIOP_Transport::register_handler_i (void) { // @@ It seems like this method should go away, the right reactor is // picked at object creation time. @@ -191,8 +191,8 @@ TAO_IIOP_Transport::send_message (TAO_OutputCDR &stream, { if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) closing conn %d after fault %p\n"), - this->handle (), + ACE_TEXT ("TAO: (%P|%t|%N|%l) closing transport %d after fault %p\n"), + this->id (), ACE_TEXT ("send_message ()\n"))); return -1; @@ -204,8 +204,8 @@ TAO_IIOP_Transport::send_message (TAO_OutputCDR &stream, if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing conn %d\n"), - this->handle())); + ACE_TEXT ("EOF, closing transport %d\n"), + this->id ())); return -1; } @@ -389,8 +389,8 @@ TAO_IIOP_Transport::process_message (void) // every reply on this connection. if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) : IIOP_Client_Transport::") - ACE_TEXT ("handle_client_input - ") + ACE_TEXT ("TAO (%P|%t) : IIOP_Transport::") + ACE_TEXT ("process_message - ") ACE_TEXT ("dispatch reply failed\n"))); this->messaging_object_->reset (); @@ -562,13 +562,15 @@ TAO_IIOP_Transport::get_listen_point ( } void -TAO_IIOP_Transport::transition_handler_state (void) +TAO_IIOP_Transport::transition_handler_state_i (void) { connection_handler_ = 0; } +#if 0 TAO_Connection_Handler* TAO_IIOP_Transport::connection_handler (void) const { return connection_handler_; } +#endif diff --git a/TAO/tao/IIOP_Transport.h b/TAO/tao/IIOP_Transport.h index b8990bf2462..419c6481fa0 100644 --- a/TAO/tao/IIOP_Transport.h +++ b/TAO/tao/IIOP_Transport.h @@ -61,25 +61,11 @@ public: /// Default destructor. ~TAO_IIOP_Transport (void); - /// Return the connection service handler - TAO_IIOP_SVC_HANDLER *service_handler (void); - +#if 0 /// The TAO_Transport methods, please check the documentation in /// "tao/Pluggable.h" for more details. virtual ACE_HANDLE handle (void); - - virtual ACE_Event_Handler *event_handler (void); - - /// Write the complete Message_Block chain to the connection. - virtual ssize_t send (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); - - - /// Read len bytes from into buf. - virtual ssize_t recv (char *buf, - size_t len, - const ACE_Time_Value *s = 0); +#endif /// Read and process the message from the connection. The processing /// of the message is done by delegating the work to the underlying @@ -87,8 +73,6 @@ public: virtual int read_process_message (ACE_Time_Value *max_time_value = 0, int block =0); - virtual int register_handler (void); - /// @@TODO: These methods IMHO should have more meaningful /// names. The names seem to indicate nothing. virtual int send_request (TAO_Stub *stub, @@ -116,10 +100,9 @@ public: ACE_THROW_SPEC ((CORBA::SystemException)); - virtual CORBA::Boolean - send_request_header (TAO_Operation_Details &opdetails, - TAO_Target_Specification &spec, - TAO_OutputCDR &msg); + virtual CORBA::Boolean send_request_header (TAO_Operation_Details &opdetails, + TAO_Target_Specification &spec, + TAO_OutputCDR &msg); /// Initialising the messaging object virtual int messaging_init (CORBA::Octet major, @@ -128,12 +111,35 @@ public: /// Open the service context list and process it. virtual int tear_listen_point_list (TAO_InputCDR &cdr); +protected: /// Method to do whatever it needs to do when the connection /// handler is being closed and destroyed. - virtual void transition_handler_state (void); + virtual void transition_handler_state_i (void); + + /// Access connection_handler_ as an ACE_Event_Handler. + /// Must be called with transport's lock held. + virtual ACE_Event_Handler *event_handler_i (void); + + /// Write the complete Message_Block chain to the connection. + /// Must be called with transport's lock held. + virtual ssize_t send_i (const ACE_Message_Block *mblk, + const ACE_Time_Value *s = 0, + size_t *bytes_transferred = 0); + - // Access the connection handler - virtual TAO_Connection_Handler* connection_handler (void) const; + /// Read len bytes from into buf. + /// Must be called with transport's lock held. + virtual ssize_t recv_i (char *buf, + size_t len, + const ACE_Time_Value *s = 0); + + virtual int register_handler_i (void); + +#if 0 + /// Access the connection handler as TAO_Connection_Handler. + /// Must be called with transport's lock held. + virtual TAO_Connection_Handler* connection_handler_i (void) const; +#endif private: diff --git a/TAO/tao/Strategies/SHMIOP_Connector.cpp b/TAO/tao/Strategies/SHMIOP_Connector.cpp index c8e4c3ad189..4972f4505fe 100644 --- a/TAO/tao/Strategies/SHMIOP_Connector.cpp +++ b/TAO/tao/Strategies/SHMIOP_Connector.cpp @@ -160,10 +160,12 @@ TAO_SHMIOP_Connector::connect (TAO_Transport_Descriptor_Interface *desc, ACE_TEXT ("(%P|%t) SHMIOP_Connector::connect ") ACE_TEXT ("got an existing connection \n"))); +#if 0 // We have found a connection and a handler svc_handler = ACE_dynamic_cast (TAO_SHMIOP_Connection_Handler *, base_transport->connection_handler ()); +#endif } else { diff --git a/TAO/tao/Strategies/SHMIOP_Transport.cpp b/TAO/tao/Strategies/SHMIOP_Transport.cpp index bb39b601bb8..3ae9fd256ff 100644 --- a/TAO/tao/Strategies/SHMIOP_Transport.cpp +++ b/TAO/tao/Strategies/SHMIOP_Transport.cpp @@ -36,6 +36,10 @@ TAO_SHMIOP_Transport::TAO_SHMIOP_Transport (TAO_SHMIOP_Connection_Handler *handl connection_handler_ (handler), messaging_object_ (0) { + // We'll set the id_ (from TAO_Transport) to the handle from our connection + if (connection_handler_ != 0) + this->id_ = ACE_static_cast (int, this->connection_handler_->get_handle ()); + if (flag) { // Use the lite version of the protocol @@ -55,6 +59,7 @@ TAO_SHMIOP_Transport::~TAO_SHMIOP_Transport (void) delete this->messaging_object_; } +#if 0 TAO_SHMIOP_SVC_HANDLER * TAO_SHMIOP_Transport::service_handler (void) { @@ -66,30 +71,31 @@ TAO_SHMIOP_Transport::handle (void) { return this->connection_handler_->get_handle (); } +#endif ACE_Event_Handler * -TAO_SHMIOP_Transport::event_handler (void) +TAO_SHMIOP_Transport::event_handler_i (void) { return this->connection_handler_; } ssize_t -TAO_SHMIOP_Transport::send (const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time, - size_t *) +TAO_SHMIOP_Transport::send_i (const ACE_Message_Block *message_block, + const ACE_Time_Value *max_wait_time, + size_t *) { - return this->service_handler ()->peer ().send (message_block, - max_wait_time); + return this->connection_handler_->peer ().send (message_block, + max_wait_time); } ssize_t -TAO_SHMIOP_Transport::recv (char *buf, - size_t len, - const ACE_Time_Value *max_wait_time) +TAO_SHMIOP_Transport::recv_i (char *buf, + size_t len, + const ACE_Time_Value *max_wait_time) { - return this->service_handler ()->peer ().recv (buf, - len, - max_wait_time); + return this->connection_handler_->peer ().recv (buf, + len, + max_wait_time); } @@ -129,7 +135,7 @@ TAO_SHMIOP_Transport::read_process_message (ACE_Time_Value *max_wait_time, int -TAO_SHMIOP_Transport::register_handler (void) +TAO_SHMIOP_Transport::register_handler_i (void) { // @@ It seems like this method should go away, the right reactor is // picked at object creation time. @@ -193,8 +199,8 @@ TAO_SHMIOP_Transport::send_message (TAO_OutputCDR &stream, { if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) closing conn %d after fault %p\n"), - this->handle (), + ACE_TEXT ("TAO: (%P|%t|%N|%l) closing transport %d after fault %p\n"), + this->id (), ACE_TEXT ("send_message ()\n"))); return -1; @@ -206,8 +212,8 @@ TAO_SHMIOP_Transport::send_message (TAO_OutputCDR &stream, if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing conn %d\n"), - this->handle())); + ACE_TEXT ("EOF, closing transport %d\n"), + this->id ())); return -1; } @@ -355,8 +361,8 @@ TAO_SHMIOP_Transport::process_message (void) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) : SHMIOP_Client_Transport::") - ACE_TEXT ("handle_client_input - ") + ACE_TEXT ("TAO (%P|%t) : SHMIOP_Transport::") + ACE_TEXT ("process_message - ") ACE_TEXT ("dispatch reply failed\n"))); this->messaging_object_->reset (); this->tms_->connection_closed (); @@ -393,15 +399,17 @@ TAO_SHMIOP_Transport::process_message (void) } void -TAO_SHMIOP_Transport::transition_handler_state (void) +TAO_SHMIOP_Transport::transition_handler_state_i (void) { connection_handler_ = 0; } +#if 0 TAO_Connection_Handler* TAO_SHMIOP_Transport::connection_handler (void) const { return connection_handler_; } +#endif #endif /* TAO_HAS_SHMIOP && TAO_HAS_SHMIOP != 0 */ diff --git a/TAO/tao/Strategies/SHMIOP_Transport.h b/TAO/tao/Strategies/SHMIOP_Transport.h index 00aa36b4c75..9e17ce40a51 100644 --- a/TAO/tao/Strategies/SHMIOP_Transport.h +++ b/TAO/tao/Strategies/SHMIOP_Transport.h @@ -55,24 +55,33 @@ public: /// Default destructor. ~TAO_SHMIOP_Transport (void); +#if 0 /// Return the connection service handler TAO_SHMIOP_SVC_HANDLER *service_handler (void); /// The TAO_Transport methods, please check the documentation in /// "tao/Pluggable.h" for more details. virtual ACE_HANDLE handle (void); +#endif - virtual ACE_Event_Handler *event_handler (void); +protected: + /** @name Overridden Template Methods + * + * These are implementations of template methods declared by TAO_Transport. + */ + //@{ + + virtual ACE_Event_Handler *event_handler_i (void); /// Write the complete Message_Block chain to the connection. - virtual ssize_t send (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); + virtual ssize_t send_i (const ACE_Message_Block *mblk, + const ACE_Time_Value *s = 0, + size_t *bytes_transferred = 0); /// Read len bytes from into buf. - virtual ssize_t recv (char *buf, - size_t len, - const ACE_Time_Value *s = 0); + virtual ssize_t recv_i (char *buf, + size_t len, + const ACE_Time_Value *s = 0); /// Read and process the message from the connection. The processing /// of the message is done by delegating the work to the underlying @@ -80,8 +89,13 @@ public: virtual int read_process_message (ACE_Time_Value *max_time_value = 0, int block =0); - virtual int register_handler (void); + virtual int register_handler_i (void); + /// Method to do whatever it needs to do when the connection + /// handler is being closed and destroyed. + virtual void transition_handler_state_i (void); + +public: /// @@TODO: These methods IMHO should have more meaningful /// names. The names seem to indicate nothing. virtual int send_request (TAO_Stub *stub, @@ -122,12 +136,12 @@ public: /// signalling. virtual int reactor_signalling (void); - /// Method to do whatever it needs to do when the connection - /// handler is being closed and destroyed. - virtual void transition_handler_state (void); - +#if 0 // Access the connection handler virtual TAO_Connection_Handler* connection_handler (void) const; +#endif + + //@} private: diff --git a/TAO/tao/Strategies/UIOP_Connector.cpp b/TAO/tao/Strategies/UIOP_Connector.cpp index b07795db20f..a7be91097bf 100644 --- a/TAO/tao/Strategies/UIOP_Connector.cpp +++ b/TAO/tao/Strategies/UIOP_Connector.cpp @@ -167,10 +167,12 @@ TAO_UIOP_Connector::connect (TAO_Transport_Descriptor_Interface *desc, ACE_TEXT ("(%P|%t) UIOP_Connector::connect ") ACE_TEXT ("got an existing connection \n"))); +#if 0 // We have found a connection and a handler svc_handler = ACE_dynamic_cast (TAO_UIOP_Connection_Handler *, base_transport->connection_handler ()); +#endif } else { diff --git a/TAO/tao/Strategies/UIOP_Transport.cpp b/TAO/tao/Strategies/UIOP_Transport.cpp index 29f67574369..fb5aa9f8c13 100644 --- a/TAO/tao/Strategies/UIOP_Transport.cpp +++ b/TAO/tao/Strategies/UIOP_Transport.cpp @@ -32,10 +32,14 @@ TAO_UIOP_Transport::TAO_UIOP_Transport (TAO_UIOP_Connection_Handler *handler, TAO_ORB_Core *orb_core, CORBA::Boolean flag) : TAO_Transport (TAO_TAG_UIOP_PROFILE, - orb_core), - connection_handler_ (handler), - messaging_object_ (0) + orb_core) + , connection_handler_ (handler) + , messaging_object_ (0) { + // We'll set the id_ (from TAO_Transport) to the handle from our connection + if (connection_handler_ != 0) + this->id_ = ACE_static_cast (int, this->connection_handler_->get_handle ()); + if (flag) { // Use the lite version of the protocol @@ -55,6 +59,7 @@ TAO_UIOP_Transport::~TAO_UIOP_Transport (void) delete this->messaging_object_; } +#if 0 TAO_UIOP_SVC_HANDLER * TAO_UIOP_Transport::service_handler (void) { @@ -66,32 +71,33 @@ TAO_UIOP_Transport::handle (void) { return this->connection_handler_->get_handle (); } +#endif ACE_Event_Handler * -TAO_UIOP_Transport::event_handler (void) +TAO_UIOP_Transport::event_handler_i (void) { return this->connection_handler_; } ssize_t -TAO_UIOP_Transport::send (const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time, - size_t *bytes_transferred) +TAO_UIOP_Transport::send_i (const ACE_Message_Block *message_block, + const ACE_Time_Value *max_wait_time, + size_t *bytes_transferred) { - return ACE::send_n (this->handle (), + return ACE::send_n (this->connection_handler_->get_handle (), message_block, max_wait_time, bytes_transferred); } ssize_t -TAO_UIOP_Transport::recv (char *buf, - size_t len, - const ACE_Time_Value *max_wait_time) +TAO_UIOP_Transport::recv_i (char *buf, + size_t len, + const ACE_Time_Value *max_wait_time) { - return this->service_handler ()->peer ().recv (buf, - len, - max_wait_time); + return this->connection_handler_->peer ().recv (buf, + len, + max_wait_time); } int @@ -130,7 +136,7 @@ TAO_UIOP_Transport::read_process_message (ACE_Time_Value *max_wait_time, int -TAO_UIOP_Transport::register_handler (void) +TAO_UIOP_Transport::register_handler_i (void) { // @@ It seems like this method should go away, the right reactor is // picked at object creation time. @@ -194,8 +200,8 @@ TAO_UIOP_Transport::send_message (TAO_OutputCDR &stream, { if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) closing conn %d after fault %p\n"), - this->handle (), + ACE_TEXT ("TAO: (%P|%t|%N|%l) closing transport %d after fault %p\n"), + this->id (), ACE_TEXT ("send_message ()\n"))); return -1; @@ -207,8 +213,8 @@ TAO_UIOP_Transport::send_message (TAO_OutputCDR &stream, if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing conn %d\n"), - this->handle())); + ACE_TEXT ("EOF, closing transport %d\n"), + this->id ())); return -1; } @@ -350,8 +356,8 @@ TAO_UIOP_Transport::process_message (void) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) : UIOP_Client_Transport::") - ACE_TEXT ("handle_client_input - ") + ACE_TEXT ("TAO (%P|%t) : UIOP_Transport::") + ACE_TEXT ("process_message - ") ACE_TEXT ("dispatch reply failed\n"))); this->messaging_object_->reset (); this->tms_->connection_closed (); @@ -387,15 +393,17 @@ TAO_UIOP_Transport::process_message (void) } void -TAO_UIOP_Transport::transition_handler_state (void) +TAO_UIOP_Transport::transition_handler_state_i (void) { connection_handler_ = 0; } +#if 0 TAO_Connection_Handler* TAO_UIOP_Transport::connection_handler (void) const { return connection_handler_; } +#endif #endif /* TAO_HAS_UIOP */ diff --git a/TAO/tao/Strategies/UIOP_Transport.h b/TAO/tao/Strategies/UIOP_Transport.h index b9b9b172fc1..ca850a497b1 100644 --- a/TAO/tao/Strategies/UIOP_Transport.h +++ b/TAO/tao/Strategies/UIOP_Transport.h @@ -60,24 +60,33 @@ public: /// Default destructor. ~TAO_UIOP_Transport (void); +#if 0 /// Return the connection service handler TAO_UIOP_SVC_HANDLER *service_handler (void); /// The TAO_Transport methods, please check the documentation in /// "tao/Pluggable.h" for more details. virtual ACE_HANDLE handle (void); +#endif - virtual ACE_Event_Handler *event_handler (void); +protected: + /** @name Overridden Template Methods + * + * These are implementations of template methods declared by TAO_Transport. + */ + //@{ + + virtual ACE_Event_Handler *event_handler_i (void); /// Write the complete Message_Block chain to the connection. - virtual ssize_t send (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); + virtual ssize_t send_i (const ACE_Message_Block *mblk, + const ACE_Time_Value *s = 0, + size_t *bytes_transferred = 0); /// Read len bytes from into buf. - virtual ssize_t recv (char *buf, - size_t len, - const ACE_Time_Value *s = 0); + virtual ssize_t recv_i (char *buf, + size_t len, + const ACE_Time_Value *s = 0); /// Read and process the message from the connection. The processing /// of the message is done by delegating the work to the underlying @@ -85,8 +94,13 @@ public: virtual int read_process_message (ACE_Time_Value *max_time_value = 0, int block =0); - virtual int register_handler (void); + virtual int register_handler_i (void); + /// Method to do whatever it needs to do when the connection + /// handler is being closed and destroyed. + virtual void transition_handler_state_i (void); + +public: /// @@TODO: These methods IMHO should have more meaningful /// names. The names seem to indicate nothing. virtual int send_request (TAO_Stub *stub, @@ -123,12 +137,12 @@ public: virtual int messaging_init (CORBA::Octet major, CORBA::Octet minor); - /// Method to do whatever it needs to do when the connection - /// handler is being closed and destroyed. - virtual void transition_handler_state (void); - +#if 0 // Access the connection handler virtual TAO_Connection_Handler* connection_handler (void) const; +#endif + + //@} private: diff --git a/TAO/tao/Sync_Strategies.cpp b/TAO/tao/Sync_Strategies.cpp index c679fc3405c..d09bcd1a5a5 100644 --- a/TAO/tao/Sync_Strategies.cpp +++ b/TAO/tao/Sync_Strategies.cpp @@ -212,13 +212,7 @@ TAO_Eager_Buffering_Sync_Strategy::timer_check (TAO_Transport &transport, ACE_Time_Value timeout = this->time_conversion (buffering_constraint.timeout); - // Get our reactor. - ACE_Reactor *reactor = transport.orb_core ()->reactor (); - - long timer_id = reactor->schedule_timer (transport.event_handler (), - 0, - timeout, - timeout); + long timer_id = transport.register_for_timer_event (0, timeout, timeout); transport.buffering_timer_id (timer_id); transport.buffering_timeout_value (timeout); diff --git a/TAO/tao/Transport.cpp b/TAO/tao/Transport.cpp index daaeee617ec..f1863fe3f8f 100644 --- a/TAO/tao/Transport.cpp +++ b/TAO/tao/Transport.cpp @@ -57,6 +57,7 @@ TAO_Transport::TAO_Transport (CORBA::ULong tag, , buffering_queue_ (0) , buffering_timer_id_ (0) , bidirectional_flag_ (-1) + , id_ ((int)this) { TAO_Client_Strategy_Factory *cf = this->orb_core_->client_factory (); @@ -66,6 +67,10 @@ TAO_Transport::TAO_Transport (CORBA::ULong tag, // Create TMS now. this->tms_ = cf->create_transport_mux_strategy (this); + + // Create a handler lock + this->handler_lock_ = + this->orb_core_->resource_factory ()->create_cached_connection_lock (); } TAO_Transport::~TAO_Transport (void) @@ -77,6 +82,8 @@ TAO_Transport::~TAO_Transport (void) this->tms_ = 0; delete this->buffering_queue_; + + delete this->handler_lock_; } ssize_t @@ -85,8 +92,13 @@ TAO_Transport::send_or_buffer (TAO_Stub *stub, const ACE_Message_Block *message_block, const ACE_Time_Value *max_wait_time) { + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, + guard, + *this->handler_lock_, + -1)); + if (stub == 0 || two_way) - return this->send (message_block, max_wait_time); + return this->send_i (message_block, max_wait_time); TAO_Sync_Strategy &sync_strategy = stub->sync_strategy (); @@ -96,6 +108,18 @@ TAO_Transport::send_or_buffer (TAO_Stub *stub, max_wait_time); } +void +TAO_Transport::provide_handle (ACE_Handle_Set &handle_set) +{ + ACE_MT (ACE_GUARD (ACE_Lock, + guard, + *this->handler_lock_)); + ACE_Event_Handler *eh = this->event_handler_i (); + TAO_Connection_Handler *ch = ACE_dynamic_cast (TAO_Connection_Handler *, eh); + if (ch && ch->is_registered ()) + handle_set.set_bit (eh->get_handle ()); +} + ssize_t TAO_Transport::send_buffered_messages (const ACE_Time_Value *max_wait_time) { @@ -104,6 +128,16 @@ TAO_Transport::send_buffered_messages (const ACE_Time_Value *max_wait_time) this->buffering_queue_->is_empty ()) return 1; + // Now, we can take the lock and try to do something. + // + // @@CJC We might be able to reduce the length of time we hold + // the lock depending on whether or not we need to hold the + // hold the lock while we're doing queueing activities. + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, + guard, + *this->handler_lock_, + -1)); + // Get the first message from the queue. ACE_Message_Block *queued_message = 0; ssize_t result = this->buffering_queue_->peek_dequeue_head (queued_message); @@ -111,11 +145,13 @@ TAO_Transport::send_buffered_messages (const ACE_Time_Value *max_wait_time) // @@ What to do here on failures? ACE_ASSERT (result != -1); + // @@CJC take lock?? // Actual network send. size_t bytes_transferred = 0; - result = this->send (queued_message, - max_wait_time, - &bytes_transferred); + result = this->send_i (queued_message, + max_wait_time, + &bytes_transferred); + // @@CJC release lock?? // Cannot send completely: timed out. if (result == -1 && @@ -263,20 +299,30 @@ TAO_Transport::reactor_signalling (void) void TAO_Transport::connection_handler_closing (void) { - this->transition_handler_state (); + { + ACE_MT (ACE_GUARD (ACE_Lock, + guard, + *this->handler_lock_)); - this->orb_core_->transport_cache ().purge_entry ( - this->cache_map_entry_); + this->transition_handler_state_i (); + + this->orb_core_->transport_cache ().purge_entry ( + this->cache_map_entry_); + } + // Can't hold the lock while we release, b/c the release could + // invoke the destructor! // This should be the last thing we do here TAO_Transport::release(this); } +#if 0 TAO_Connection_Handler* TAO_Transport::connection_handler (void) const { return 0; } +#endif TAO_Transport* TAO_Transport::_duplicate (TAO_Transport* transport) @@ -341,14 +387,103 @@ TAO_Transport::make_idle (void) void TAO_Transport::close_connection (void) { - // Call handle close on the connection handler. + ACE_MT (ACE_GUARD (ACE_Lock, + guard, + *this->handler_lock_)); + + // Call handle close on the handler. // The event handler is as common as we can get - if (this->event_handler () != 0) - { - this->event_handler ()->handle_close (ACE_INVALID_HANDLE, - ACE_Event_Handler::ALL_EVENTS_MASK); - } + ACE_Event_Handler *eh = this->event_handler_i (); + if (eh) + eh->handle_close (ACE_INVALID_HANDLE, + ACE_Event_Handler::ALL_EVENTS_MASK); // Purge the entry this->orb_core_->transport_cache ().purge_entry (this->cache_map_entry_); } + +ssize_t +TAO_Transport::send (const ACE_Message_Block *mblk, + const ACE_Time_Value *timeout, + size_t *bytes_transferred) +{ + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, + guard, + *this->handler_lock_, + -1)); + + // if there's no associated event handler, then we act like a null transport + if (this->event_handler_i () == 0) + { + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%P|%t) transport %d (tag=%d) send() ") + ACE_TEXT ("no longer associated with handler, returning -1 with errno = ENOENT\n"), + this->id (), + this->tag_)); + errno = ENOENT; + return -1; + } + + // now call the template method + return this->send_i (mblk, timeout, bytes_transferred); +} + +ssize_t +TAO_Transport::recv (char *buffer, + size_t len, + const ACE_Time_Value *timeout) +{ + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, + guard, + *this->handler_lock_, + -1)); + + // if there's no associated event handler, then we act like a null transport + if (this->event_handler_i () == 0) + { + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%P|%t) transport %d (tag=%d) recv() ") + ACE_TEXT ("no longer associated with handler, returning -1 with errno = ENOENT\n"), + this->id (), + this->tag_)); + // @@CJC Should we return -1, like an error, or should we return 0, like an EOF? + errno = ENOENT; + return -1; + } + + // now call the template method + return this->recv_i (buffer, len, timeout); +} + +long +TAO_Transport::register_for_timer_event (const void* arg, + const ACE_Time_Value &delay, + const ACE_Time_Value &interval) +{ + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, + guard, + *this->handler_lock_, + -1)); + + ACE_Event_Handler *eh = this->event_handler_i (); + if (eh == 0) + return -1; + + return this->orb_core_->reactor ()->schedule_timer (eh, arg, delay, interval); +} + +int +TAO_Transport::register_handler (void) +{ + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, + guard, + *this->handler_lock_, + -1)); + return this->register_handler_i (); +} + +int +TAO_Transport::id (void) +{ + return this->id_; +} diff --git a/TAO/tao/Transport.h b/TAO/tao/Transport.h index c318cc2d9b8..c8b9137ff9f 100644 --- a/TAO/tao/Transport.h +++ b/TAO/tao/Transport.h @@ -201,9 +201,13 @@ public: * If any data is to be sent it blocks until the queue is completely * drained. * + * This method serializes on handler_lock_, guaranteeing that only + * thread can execute it on the same instance concurrently. + * * @todo: this routine will probably go away as part of the * reorganization to support non-blocking writes. */ + // @@ lockme ssize_t send_or_buffer (TAO_Stub *stub, int two_way, const ACE_Message_Block *mblk, @@ -228,6 +232,7 @@ public: void buffering_timeout_value (const ACE_Time_Value &time); /// Send any messages that have been buffered. + // @@ lockme ssize_t send_buffered_messages (const ACE_Time_Value *max_wait_time = 0); /** @@ -242,6 +247,14 @@ public: virtual int bidirectional_flag (void) const; virtual void bidirectional_flag (int flag); + /// Fill in a handle_set with any associated handler's reactor handle. + /** + * Called by the cache when the cache is closing in order to fill + * in a handle_set in a lock-safe manner. + * @param handle_set the ACE_Handle_Set into which the transport should place any handle registered with the reactor + */ + void provide_handle (ACE_Handle_Set &handle_set); + /// @@ Bala: you must document this function!! /// @@ Bala: from the implementation in IIOP_Transport it looks more // like it process the list of listening endpoints, or it is @@ -254,6 +267,19 @@ public: */ void dequeue_all (void); + /// Register the handler with the reactor. + /** + * This method is used by the Wait_On_Reactor strategy. The + * transport must register its event handler with the ORB's Reactor. + * + * @todo: I think this method is pretty much useless, the + * connections are *always* registered with the Reactor, except in + * thread-per-connection mode. In that case putting the connection + * in the Reactor would produce unpredictable results anyway. + */ + // @@ lockme + int register_handler (void); + /** * @name Control connection lifecycle * @@ -270,8 +296,77 @@ public: /// now. virtual int idle_after_reply (void); + /// Call the corresponding connection handler's + /// method. + virtual void close_connection (void); + //@} + /// Write the complete Message_Block chain to the connection. + /** + * This method serializes on handler_lock_, guaranteeing that only + * thread can execute it on the same instance concurrently. + * + * Often the implementation simply forwards the arguments to the + * underlying ACE_Svc_Handler class. Using the code factored out + * into ACE. + * + * Be careful with protocols that perform non-trivial + * transformations of the data, such as SSLIOP or protocols that + * compress the stream. + * + * @param mblk contains the data that must be sent. For each + * message block in the cont() chain all the data between rd_ptr() + * and wr_ptr() should be delivered to the remote peer. + * + * @param timeout is the maximum time that the application is + * willing to wait for the data to be sent, useful in platforms that + * implement timed writes. + * The timeout value is obtained from the policies set by the + * application. + * + * @param bytes_transferred should return the total number of bytes + * successfully transferred before the connection blocked. This is + * required because in some platforms and/or protocols multiple + * system calls may be required to send the chain of message + * blocks. The first few calls can work successfully, but the final + * one can fail or signal a flow control situation (via EAGAIN). + * In this case the ORB expects the function to return -1, errno to + * be appropriately set and this argument to return the number of + * bytes already on the OS I/O subsystem. + * + * This call can also fail if the transport instance is no longer + * associated with a connection (e.g., the connection handler closed + * down). In that case, it returns -1 and sets errno to + * ENOENT. + */ + ssize_t send (const ACE_Message_Block *mblk, + const ACE_Time_Value *timeout = 0, + size_t *bytes_transferred = 0); + + /// Read len bytes from into buf. + /** + * This method serializes on handler_lock_, guaranteeing that only + * thread can execute it on the same instance concurrently. + * + * @param buffer ORB allocated buffer where the data should be + * @@ The ACE_Time_Value *s is just a place holder for now. It is + * not clear this this is the best place to specify this. The actual + * timeout values will be kept in the Policies. + */ + ssize_t recv (char *buffer, + size_t len, + const ACE_Time_Value *timeout = 0); + + + /// Return a unique identifier for this transport instance. + /** + * It's established at construction, and not changed throughout the life + * of a transport. + */ + virtual int id (void); + +protected: /** @name Template methods * * The Transport class uses the Template Method Pattern to implement @@ -281,10 +376,7 @@ public: */ //@{ - /// Call the corresponding connection handler's - /// method. - virtual void close_connection (void); - +#if 0 /// Return the file descriptor used for this connection. /** * @todo Someday we should be able to support protocols that do not @@ -296,6 +388,7 @@ public: * file descriptors.) */ virtual ACE_HANDLE handle (void) = 0; +#endif /// Return the event handler used to receive notifications from the /// Reactor. @@ -312,7 +405,9 @@ public: * will reduce footprint and simplify the process of implementing a * pluggable protocol. */ - virtual ACE_Event_Handler *event_handler (void) = 0; + // @@ this is broken once we add the lock b/c it returns the thing + // we're trying to lock down! (CJC) + virtual ACE_Event_Handler *event_handler_i (void) = 0; /// Write the complete Message_Block chain to the connection. /** @@ -345,9 +440,9 @@ public: * bytes already on the OS I/O subsystem. * */ - virtual ssize_t send (const ACE_Message_Block *mblk, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0) = 0; + virtual ssize_t send_i (const ACE_Message_Block *mblk, + const ACE_Time_Value *timeout = 0, + size_t *bytes_transferred = 0) = 0; // Read len bytes from into buf. /** @@ -356,15 +451,17 @@ public: * not clear this this is the best place to specify this. The actual * timeout values will be kept in the Policies. */ - virtual ssize_t recv (char *buffer, - size_t len, - const ACE_Time_Value *timeout = 0) = 0; + virtual ssize_t recv_i (char *buffer, + size_t len, + const ACE_Time_Value *timeout = 0) = 0; +public: /// Fill into the right headers to make a request. /** * @todo Bala: in the good old days it was decided that the * pluggable protocol framework would not raise exceptions. */ + // @nolock virtual void start_request (TAO_ORB_Core *orb_core, TAO_Target_Specification &spec, TAO_OutputCDR &output, @@ -377,6 +474,7 @@ public: * @todo Bala: in the good old days it was decided that the * pluggable protocol framework would not raise exceptions. */ + // @@nolock virtual void start_locate (TAO_ORB_Core *orb_core, TAO_Target_Specification &spec, TAO_Operation_Details &opdetails, @@ -410,6 +508,7 @@ public: * @todo This is generic code, it should be factored out into the * Transport class. */ + // @nolock b/c this calls send_or_buffer virtual int send_request (TAO_Stub *stub, TAO_ORB_Core *orb_core, TAO_OutputCDR &stream, @@ -439,6 +538,7 @@ public: * * @todo Another generic method, move to TAO_Transport. */ + // @@ lockme virtual int send_message (TAO_OutputCDR &stream, TAO_Stub *stub = 0, int twoway = 1, @@ -463,9 +563,11 @@ public: * @param block Is deprecated and ignored. * */ + // @@ lockme virtual int read_process_message (ACE_Time_Value *max_wait_time = 0, int block = 0) = 0; +protected: /// Register the handler with the reactor. /** * This method is used by the Wait_On_Reactor strategy. The @@ -476,8 +578,20 @@ public: * thread-per-connection mode. In that case putting the connection * in the Reactor would produce unpredictable results anyway. */ - virtual int register_handler (void) = 0; + // @@ lockme + virtual int register_handler_i (void) = 0; + + /// Called by connection_handler_closing() to signal + /// that the protocol-specific transport should dissociate itself + /// with the protocol-specific connection handler. + /** + * Typically, this just sets the pointer to the associated connection + * handler to zero, although it could also clear out any additional + * resources associated with the handler association. + */ + virtual void transition_handler_state_i (void) = 0; +public: /// Indicates whether the reactor is used by the protocol for /// signalling. /** @@ -491,10 +605,27 @@ public: /// Method for the connection handler to signify that it /// is being closed and destroyed. virtual void connection_handler_closing (void); - virtual void transition_handler_state (void) = 0; - // Access the connection handler - virtual TAO_Connection_Handler* connection_handler (void) const; + /// Register the associated connection handler with the reactor + /// for a timer. + /** + * At this point, only TAO_Eager_Buffering_Sync_Strategy::timer_check() + * uses this, and it's unclear whether it needs to stay around. But, it's here + * because it uses the associated protocol-specific connection handler, and accesses + * to that must be serialized on the internal lock. + * + * @param arg argument passed to the handle_timeout() method of the event handler + * @param delay time interval after which the timer will expire + * @param interval time interval after which the timer will be automatically rescheduled + * @return -1 on failure, a Reactor timer_id value on success + * + * @see ACE_Reactor::schedule_timer() + * @see TAO_Eager_Buffering_Sync_Strategy::timer_check() + */ + long register_for_timer_event (const void* arg, + const ACE_Time_Value &delay, + const ACE_Time_Value &interval = ACE_Time_Value::zero); + // Maintain reference counting with these static TAO_Transport* _duplicate (TAO_Transport* transport); @@ -514,6 +645,13 @@ public: int make_idle (void); protected: +#if 0 + // Access the connection handler + // @@CJC Do we still need this?! + virtual TAO_Connection_Handler* connection_handler_i (void) const; +#endif + + // @@ see if one of these calls send_message() /// Remove the first message from the outgoing queue. void dequeue_head (void); @@ -531,6 +669,7 @@ protected: void reset_message (ACE_Message_Block *message_block, size_t bytes_delivered, int queued_message); + private: /// Prohibited ACE_UNIMPLEMENTED_FUNC (TAO_Transport (const TAO_Transport&)) @@ -584,6 +723,28 @@ protected: * if the server receives the info. */ int bidirectional_flag_; + + /// Lock that insures that activities that *might* use handler-related + /// resources (such as a connection handler) get serialized. + /** + * This is an ACE_Lock that gets initialized from + * TAO_ORB_Core::resource_factory()->create_cached_connection_lock (). + * This way, one can use a lock appropriate for the type of system, i.e., + * a null lock for single-threaded systems, and a real lock for + * multi-threaded systems. + */ + ACE_Lock *handler_lock_; + + /// A unique identifier for the transport. + /** + * This never *never* + * changes over the lifespan, so we don't have to worry + * about locking it. + * + * HINT: Protocol-specific transports that use connection handler + * might choose to set this to the handle for their connection. + */ + int id_; }; #if defined (__ACE_INLINE__) diff --git a/TAO/tao/Transport_Cache_Manager.cpp b/TAO/tao/Transport_Cache_Manager.cpp index 9e2e289082c..a8dd4aa2c16 100644 --- a/TAO/tao/Transport_Cache_Manager.cpp +++ b/TAO/tao/Transport_Cache_Manager.cpp @@ -110,6 +110,12 @@ int TAO_Transport_Cache_Manager::find_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *&transport) { + if (prop == 0) + { + transport = 0; + return -1; + } + // Compose the ExternId TAO_Cache_ExtId ext_id (prop); TAO_Cache_IntId int_id; @@ -184,7 +190,7 @@ TAO_Transport_Cache_Manager::find_i (const TAO_Cache_ExtId &key, int TAO_Transport_Cache_Manager::rebind_i (const TAO_Cache_ExtId &key, - const TAO_Cache_IntId &value) + const TAO_Cache_IntId &value) { return this->cache_map_.rebind (key, value); @@ -192,7 +198,7 @@ TAO_Transport_Cache_Manager::rebind_i (const TAO_Cache_ExtId &key, int TAO_Transport_Cache_Manager::trybind_i (const TAO_Cache_ExtId &key, - TAO_Cache_IntId &value) + TAO_Cache_IntId &value) { return this->cache_map_.trybind (key, value); } @@ -205,7 +211,7 @@ TAO_Transport_Cache_Manager::unbind_i (const TAO_Cache_ExtId &key) int TAO_Transport_Cache_Manager::unbind_i (const TAO_Cache_ExtId &key, - TAO_Cache_IntId &value) + TAO_Cache_IntId &value) { return this->cache_map_.unbind (key, value); @@ -214,7 +220,9 @@ TAO_Transport_Cache_Manager::unbind_i (const TAO_Cache_ExtId &key, int TAO_Transport_Cache_Manager::make_idle_i (HASH_MAP_ENTRY *&entry) { - + if (entry == 0) + return -1; + // First get the entry again (if at all things had changed in the // cache map in the mean time) HASH_MAP_ENTRY *new_entry = 0; @@ -240,7 +248,7 @@ TAO_Transport_Cache_Manager::make_idle_i (HASH_MAP_ENTRY *&entry) int -TAO_Transport_Cache_Manager::close_i (ACE_Handle_Set & /*handle_set*/) +TAO_Transport_Cache_Manager::close_i (ACE_Handle_Set &handle_set) { for (HASH_MAP_ITER iter = this->cache_map_.begin (); iter != this->cache_map_.end (); @@ -251,6 +259,22 @@ TAO_Transport_Cache_Manager::close_i (ACE_Handle_Set & /*handle_set*/) if ((*iter).int_id_.recycle_state () != ACE_RECYCLABLE_CLOSED) { +#if 0 + // @@ This code from Connection_Cache_Manager disappeared + // during the changeover; we need the functional equivalent back. + // The problem is that with the locking stuff that we're putting + // in to the Transport, we might want to encapsulate the whole + // exercise of adding to the handle set in a method on the transport + // rather than doing it here. That way, the locking is correct. + if ((*iter).int_id_.handler ()->is_registered ()) + { + handle_set.set_bit ((*iter).int_id_.handler ()->fetch_handle ()); + } +#else + // Get the transport to fill its associated connection's handle in + // the handle_set. + (*iter).int_id_.transport ()->provide_handle (handle_set); +#endif // Inform the transport that has a reference to the entry in the // map that we are *gone* now. So, the transport should not use // the reference to the entry that he has, to acces us *at any @@ -296,10 +320,9 @@ TAO_Transport_Cache_Manager::mark_invalid_i (HASH_MAP_ENTRY *&entry) int -TAO_Transport_Cache_Manager:: - get_last_index_bind (TAO_Cache_ExtId &key, - TAO_Cache_IntId &val, - HASH_MAP_ENTRY *&entry) +TAO_Transport_Cache_Manager::get_last_index_bind (TAO_Cache_ExtId &key, + TAO_Cache_IntId &val, + HASH_MAP_ENTRY *&entry) { CORBA::ULong ctr = entry->ext_id_.index (); @@ -324,8 +347,7 @@ TAO_Transport_Cache_Manager:: int -TAO_Transport_Cache_Manager:: - is_entry_idle (HASH_MAP_ENTRY *&entry) +TAO_Transport_Cache_Manager::is_entry_idle (HASH_MAP_ENTRY *&entry) { if (entry->int_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE || entry->int_id_.recycle_state () == ACE_RECYCLABLE_IDLE_BUT_NOT_PURGABLE) -- cgit v1.2.1