Use max_select_wait_time to limit IO#select sleep

lib/net/ssh/multi/server.rb

@@ -229,5 +229,9 @@ def postprocess(readers, writers) #:nodoc:
         listeners = session.listeners.keys
         session.postprocess(listeners & readers, listeners & writers)
       end
+
+      def max_select_wait_time
+        session.max_select_wait_time if session
+      end
   end
 end; end; end

lib/net/ssh/multi/session.rb

@@ -442,12 +442,11 @@ def process(wait=nil, &block)
     end
 
     def io_select_wait(wait)
-      [wait, keepalive_interval].compact.min
+      [wait, max_select_wait_time].compact.min
     end
 
-    def keepalive_interval
-      servers = server_list.select { |s| s.options[:keepalive] }
-      servers.map { |s| s.options[:keepalive_interval] }.compact.min
+    def max_select_wait_time
+      server_list.map(&:max_select_wait_time).compact.min
     end
 
     # Runs the preprocess stage on all servers. Returns false if the block

test/server_test.rb

@@ -211,6 +211,19 @@ def test_postprocess_should_call_session_postprocess_with_ios_belonging_to_sessi
     assert_equal :result, srv.postprocess([1,11,3], [18,14,7,12])
   end
 
+  def test_max_select_wait_time_should_call_session_max_select_wait_time_when_session_is_open
+    srv = server('host')
+    session = expect_connection_to(srv)
+    session.expects(:max_select_wait_time).returns(:result)
+    srv.session(true)
+    assert_equal :result, srv.max_select_wait_time
+  end
+
+  def test_max_select_wait_time_should_return_nil_when_session_is_not_open
+    srv = server('host')
+    assert_nil srv.max_select_wait_time
+  end
+
   private
 
     class MockIO

test/session_test.rb

@@ -200,22 +200,28 @@ def test_process_should_call_select_on_combined_readers_and_writers_from_all_ser
   end
 
   def test_process_should_pass_minimum_keepalive_interval_as_io_select_timeout
-    @session.use('h1', :keepalive => true)
-    @session.use('h2', :keepalive_interval => 1)
-    @session.use('h3', :keepalive => true, :keepalive_interval => 2)
-    @session.use('h4', :keepalive => true, :keepalive_interval => 3)
+    s1 = @session.use('h1', :keepalive => true)
+    s1.expects(:max_select_wait_time).returns(300)
+    s2 = @session.use('h2', :keepalive_interval => 1)
+    s2.expects(:max_select_wait_time).returns(nil)
+    s3 = @session.use('h3', :keepalive => true, :keepalive_interval => 2)
+    s3.expects(:max_select_wait_time).returns(2)
+    s4 = @session.use('h4', :keepalive => true, :keepalive_interval => 3)
+    s4.expects(:max_select_wait_time).returns(3)
     IO.expects(:select).with([], [], nil, 2)
     @session.process
   end
 
   def test_process_should_pass_wait_as_io_select_timeout_if_provided_and_minimum
-    @session.use('h1', :keepalive => true, :keepalive_interval => 1)
+    s1 = @session.use('h1', :keepalive => true, :keepalive_interval => 2)
+    s1.expects(:max_select_wait_time).returns(2)
     IO.expects(:select).with([], [], nil, 1)
-    @session.process(2)
+    @session.process(1)
   end
 
   def test_process_should_pass_nil_as_io_select_timeout_by_default
-    @session.use('h1')
+    s1 = @session.use('h1')
+    s1.expects(:max_select_wait_time).returns(nil)
     IO.expects(:select).with([], [], nil, nil)
     @session.process
   end