Merge pull request #2525 from jwillemsen/jwi-transportidle

[ace6tao2] Backport #2523, add `-ORBTransportIdleTimeout` to purge idle transports

Author: jwillemsen

ACE/ace/Event_Handler_Handle_Timeout_Upcall.cpp

@@ -29,7 +29,7 @@ timeout (ACE_Timer_Queue &timer_queue,
         int recurring_timer,
         const ACE_Time_Value &cur_time)
 {
-  int requires_reference_counting = 0;
+  bool requires_reference_counting = false;
 
   if (!recurring_timer)
     {
@@ -47,8 +47,7 @@ timeout (ACE_Timer_Queue &timer_queue,
         timer_queue.cancel (event_handler, 0); // 0 means "call handle_close()".
     }
 
-  if (!recurring_timer &&
-      requires_reference_counting)
+  if (!recurring_timer && requires_reference_counting)
     {
       event_handler->remove_reference ();
     }

ACE/ace/WFMO_Reactor.cpp

@@ -870,7 +870,7 @@ ACE_WFMO_Reactor_Handler_Repository::make_changes_in_suspension_infos (void)
           // the upcall.
           if (event_handler != 0)
             {
-              int requires_reference_counting =
+              bool const requires_reference_counting =
                 event_handler->reference_counting_policy ().value () ==
                 ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
 
@@ -2062,7 +2062,7 @@ ACE_WFMO_Reactor::simple_dispatch_handler (DWORD slot,
   ACE_Event_Handler *event_handler =
     this->handler_rep_.current_info ()[slot].event_handler_;
 
-  int requires_reference_counting =
+  bool const requires_reference_counting =
     event_handler->reference_counting_policy ().value () ==
     ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
 

TAO/NEWS

@@ -1,6 +1,12 @@
 USER VISIBLE CHANGES BETWEEN TAO-2.5.23 and TAO-2.5.24
 ======================================================
 
+. All issues from bugzilla.dre.vanderbilt.edu migrated to
+  https://github.com/DOCGroup/bugzilla
+
+. Add -ORBTransportIdleTimeout to purge idle transports after
+  a configurable timeout, default is 0 (no purging of idle transports)
+
 USER VISIBLE CHANGES BETWEEN TAO-2.5.22 and TAO-2.5.23
 ======================================================
 

TAO/bin/tao_orb_tests.lst

@@ -428,6 +428,7 @@ TAO/tests/TransportCurrent/Framework/run_test.pl -static: !DISABLE_TRANSPORT_CUR
 TAO/tests/TransportCurrent/IIOP/run_test.pl -dynamic: !DISABLE_TRANSPORT_CURRENT !STATIC !CORBA_E_COMPACT !CORBA_E_MICRO !DISABLE_INTERCEPTORS !MINIMUM
 TAO/tests/TransportCurrent/IIOP/run_test.pl -static: !DISABLE_TRANSPORT_CURRENT STATIC !CORBA_E_COMPACT !CORBA_E_MICRO !DISABLE_INTERCEPTORS !MINIMUM
 TAO/tests/Transport_Cache_Manager/run_test.pl
+TAO/tests/Transport_Idle_Timeout/run_test.pl
 TAO/tests/UNKNOWN_Exception/run_test.pl:
 TAO/tests/Native_Exceptions/run_test.pl:
 TAO/tests/Servant_To_Reference_Test/run_test.pl: !MINIMUM !CORBA_E_COMPACT !CORBA_E_MICRO !ST

TAO/docs/Options.html

@@ -1389,6 +1389,12 @@ <h4><a name="TDRF">1.1. Resource_Factory</a></h4>
         to your config.h file.
         </td>
       </tr>
+      <tr>
+        <td><code>-ORBTransportIdleTimeout</code> <em>number</em></td>
+        <td>Number of seconds after which idle connections are closed and purged from
+        the transport cache. By default idle connections are kept until they are
+        explicitly closed or purged because the transport cache is almost full.</td>
+      </tr>
     </tbody>
   </table>
   </p>

TAO/tao/Cache_Entries_T.inl

@@ -112,7 +112,6 @@ namespace TAO
       is_delete_ (false),
       index_ (0)
   {
-
   }
 
   template <typename TRANSPORT_DESCRIPTOR_TYPE> ACE_INLINE

TAO/tao/Resource_Factory.h

@@ -255,6 +255,10 @@ class TAO_Export TAO_Resource_Factory : public ACE_Service_Object
   /// replies during shutdown.
   virtual bool drop_replies_during_shutdown () const = 0;
 
+  /// Amount of seconds after which an idle transport will be closed
+  /// 0 means no closing of idle connections (default)
+  virtual int transport_idle_timeout () const = 0;
+
 protected:
   /**
    * Loads the default protocols. This method is used so that the

TAO/tao/Transport.cpp

@@ -134,7 +134,9 @@ TAO_Transport::TAO_Transport (CORBA::ULong tag,
   , incoming_message_queue_ (orb_core)
   , current_deadline_ (ACE_Time_Value::zero)
   , flush_timer_id_ (-1)
+  , idle_timer_id_ (-1)
   , transport_timer_ (this)
+  , transport_idle_timer_ (this)
   , handler_lock_ (orb_core->resource_factory ()->create_cached_connection_lock ())
   , id_ ((size_t) this)
   , purging_order_ (0)
@@ -202,6 +204,8 @@ TAO_Transport::~TAO_Transport (void)
                   ));
     }
 
+  this->cancel_idle_timer ();
+
   delete this->messaging_object_;
 
   delete this->ws_;
@@ -359,6 +363,16 @@ TAO_Transport::register_if_necessary (void)
 void
 TAO_Transport::close_connection (void)
 {
+  if (TAO_debug_level > 4)
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("TAO (%P|%t) - Transport[%d]::close_connection\n"),
+                  this->id ()));
+    }
+
+  // Cancel any pending timer
+  this->cancel_idle_timer ();
+
   this->connection_handler_i ()->close_connection ();
 }
 
@@ -410,8 +424,7 @@ TAO_Transport::register_handler (void)
   this->ws_->is_registered (true);
 
   // Register the handler with the reactor
-  return r->register_handler (this->event_handler_i (),
-                              ACE_Event_Handler::READ_MASK);
+  return r->register_handler (this->event_handler_i (), ACE_Event_Handler::READ_MASK);
 }
 
 int
@@ -582,7 +595,12 @@ TAO_Transport::make_idle (void)
                   this->id ()));
     }
 
-  return this->transport_cache_manager ().make_idle (this->cache_map_entry_);
+  int const result = this->transport_cache_manager ().make_idle (this->cache_map_entry_);
+  if (result == 0)
+    {
+       this->schedule_idle_timer ();
+    }
+  return result;
 }
 
 int
@@ -992,6 +1010,46 @@ TAO_Transport::handle_timeout (const ACE_Time_Value & /* current_time */,
   return 0;
 }
 
+int
+TAO_Transport::handle_idle_timeout (const ACE_Time_Value & /* current_time */, const void */*act*/)
+{
+  if (TAO_debug_level > 6)
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+         ACE_TEXT ("TAO (%P|%t) - Transport[%d]::handle_idle_timeout, ")
+         ACE_TEXT ("idle timer expired, closing transport\n"),
+         this->id ()));
+    }
+
+  // Timer has expired, so setting the idle timer id back to -1
+  this->idle_timer_id_ = -1;
+
+  if (this->transport_cache_manager ().purge_entry_when_purgable (this->cache_map_entry_) == -1)
+    {
+      if (TAO_debug_level > 6)
+        TAOLIB_DEBUG ((LM_DEBUG,
+            ACE_TEXT ("TAO (%P|%t) - Transport[%d]::handle_idle_timeout, ")
+            ACE_TEXT ("idle_timeout, transport is not purgable, don't close it, reschedule it\n"),
+            this->id ()));
+
+      this->schedule_idle_timer ();
+    }
+  else
+    {
+      if (TAO_debug_level > 6)
+        TAOLIB_DEBUG ((LM_DEBUG,
+            ACE_TEXT ("TAO (%P|%t) - Transport[%d]::handle_idle_timeout, ")
+            ACE_TEXT ("idle_timeout, transport purged due to idle timeout\n"),
+            this->id ()));
+
+      // Close the underlying socket.
+      // close_connection() is safe to call from the reactor thread.
+      (void) this->close_connection ();
+    }
+
+  return 0;
+}
+
 TAO_Transport::Drain_Result
 TAO_Transport::drain_queue (TAO::Transport::Drain_Constraints const & dc)
 {
@@ -2767,8 +2825,7 @@ TAO_Transport::pre_close (void)
   // of the is_connected_ flag, so that during cache lookups the cache
   // manager doesn't need to be burdened by the lock in is_connected().
   this->is_connected_ = false;
-  this->transport_cache_manager ().mark_connected (this->cache_map_entry_,
-                                                   false);
+  this->transport_cache_manager ().mark_connected (this->cache_map_entry_, false);
   this->purge_entry ();
   {
     ACE_MT (ACE_GUARD (ACE_Lock, guard, *this->handler_lock_));
@@ -2842,13 +2899,13 @@ TAO_Transport::post_open (size_t id)
                             ACE_TEXT (", cache_map_entry_ is [%@]\n"), this->id_, this->cache_map_entry_));
     }
 
-  this->transport_cache_manager ().mark_connected (this->cache_map_entry_,
-                                                   true);
+  this->transport_cache_manager ().mark_connected (this->cache_map_entry_, true);
 
   // update transport cache to make this entry available
-  this->transport_cache_manager ().set_entry_state (
-    this->cache_map_entry_,
-    TAO::ENTRY_IDLE_AND_PURGABLE);
+  this->transport_cache_manager ().set_entry_state (this->cache_map_entry_, TAO::ENTRY_IDLE_AND_PURGABLE);
+
+  // this transport is just opened, so schedule it for the idle timer
+  this->schedule_idle_timer ();
 
   return true;
 }
@@ -2919,4 +2976,56 @@ TAO_Transport::connection_closed_on_read (void) const
 
 //@@ TAO_TRANSPORT_SPL_METHODS_ADD_HOOK
 
+void
+TAO_Transport::schedule_idle_timer ()
+{
+  int const timeout_sec = this->orb_core_->resource_factory ()->transport_idle_timeout ();
+  if (timeout_sec > 0)
+    {
+      if (this->idle_timer_id_ != -1)
+        {
+          // The transport was marked as idle, but we have a timer running, cancel that old timer
+          // first
+          this->cancel_idle_timer ();
+        }
+      ACE_Reactor *reactor = this->orb_core_->reactor ();
+      if (reactor)
+        {
+          ACE_Time_Value const tv (static_cast<time_t> (timeout_sec));
+          this->idle_timer_id_= reactor->schedule_timer (&this->transport_idle_timer_, 0, tv);
+
+          if (TAO_debug_level > 6)
+            {
+              TAOLIB_DEBUG ((LM_DEBUG,
+                      ACE_TEXT ("TAO (%P|%t) - Transport[%d]::schedule_idle_timer, ")
+                      ACE_TEXT ("schedule idle timer with id [%d] ")
+                      ACE_TEXT ("in the reactor.\n"),
+                      this->id (), this->idle_timer_id_));
+            }
+        }
+    }
+}
+
+void
+TAO_Transport::cancel_idle_timer ()
+{
+  if (this->idle_timer_id_ != -1)
+    {
+      ACE_Reactor *reactor = this->orb_core ()->reactor ();
+      if (reactor)
+        {
+          if (TAO_debug_level > 6)
+            {
+              TAOLIB_DEBUG ((LM_DEBUG,
+                      ACE_TEXT ("TAO (%P|%t) - Transport[%d]::cancel_idle_timer, ")
+                      ACE_TEXT ("cancel idle timer with id [%d] ")
+                      ACE_TEXT ("from the reactor.\n"),
+                      this->id (), this->idle_timer_id_));
+            }
+          reactor->cancel_timer (this->idle_timer_id_);
+          this->idle_timer_id_ = -1;
+        }
+    }
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL

TAO/tao/Transport.h

@@ -1,6 +1,3 @@
-// -*- C++ -*-
-
-//=============================================================================
 /**
  *  @file Transport.h
  *
@@ -9,7 +6,6 @@
  *
  *  @author  Fred Kuhns <fredk@cs.wustl.edu>
  */
-//=============================================================================
 
 #ifndef TAO_TRANSPORT_H
 #define TAO_TRANSPORT_H
@@ -23,6 +19,7 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
 #include "tao/Transport_Timer.h"
+#include "tao/Transport_Idle_Timer.h"
 #include "tao/Incoming_Message_Queue.h"
 #include "tao/Incoming_Message_Stack.h"
 #include "tao/Message_Semantics.h"
@@ -867,6 +864,9 @@ class TAO_Export TAO_Transport
    */
   int handle_timeout (const ACE_Time_Value &current_time, const void* act);
 
+  /// Timeout called when the idle timer expired for this transport
+  int handle_idle_timeout (const ACE_Time_Value &current_time, const void* act);
+
   /// Accessor to recv_buffer_size_
   size_t recv_buffer_size (void) const;
 
@@ -910,6 +910,9 @@ class TAO_Export TAO_Transport
   /// Transport statistics
   TAO::Transport::Stats* stats (void) const;
 
+  /// Helper method to cancel the timer when the transport is not idle anymore
+  void cancel_idle_timer ();
+
 private:
   /// Helper method that returns the Transport Cache Manager.
   TAO::Transport_Cache_Manager &transport_cache_manager (void);
@@ -1072,10 +1075,8 @@ class TAO_Export TAO_Transport
    */
   bool using_blocking_io_for_asynch_messages() const;
 
-  /*
-   * Specialization hook to add concrete private methods from
-   * TAO's protocol implementation onto the base Transport class
-   */
+  /// Helper method to schedule a timer when the transport is made idle
+  void schedule_idle_timer ();
 
   //@@ TAO_TRANSPORT_SPL_PRIVATE_METHODS_ADD_HOOK
 
@@ -1138,8 +1139,14 @@ class TAO_Export TAO_Transport
   /// The timer ID
   long flush_timer_id_;
 
+  /// The idle timer ID
+  long idle_timer_id_;
+
   /// The adapter used to receive timeout callbacks from the Reactor
-  TAO_Transport_Timer transport_timer_;
+  TAO::Transport_Timer transport_timer_;
+
+  /// The adapter used to receive idle timeout callbacks from the Reactor
+  TAO::Transport_Idle_Timer transport_idle_timer_;
 
   /// Lock that insures that activities that *might* use handler-related
   /// resources (such as a connection handler) get serialized.