net-ssh 5.2.0 → 7.0.1

data/lib/net/ssh/connection/event_loop.rb

@@ -1,8 +1,7 @@
 require 'net/ssh/loggable'
-require 'net/ssh/ruby_compat'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Connection
       # EventLoop can be shared across multiple sessions
       #
@@ -12,81 +11,84 @@ module Net
       # and we don't pass session.
       class EventLoop
         include Loggable
-    
-        def initialize(logger=nil)
+
+        def initialize(logger = nil)
           self.logger = logger
           @sessions = []
         end
-    
+
         def register(session)
           @sessions << session
         end
-    
+
         # process until timeout
         # if a block is given a session will be removed from loop
         # if block returns false for that session
         def process(wait = nil, &block)
           return false unless ev_preprocess(&block)
-    
+
           ev_select_and_postprocess(wait)
         end
-    
+
         # process the event loop but only for the sepcified session
         def process_only(session, wait = nil)
           orig_sessions = @sessions
           begin
             @sessions = [session]
             return false unless ev_preprocess
+
             ev_select_and_postprocess(wait)
           ensure
             @sessions = orig_sessions
           end
         end
-    
+
         # Call preprocess on each session. If block given and that
         # block retuns false then we exit the processing
         def ev_preprocess(&block)
           return false if block_given? && !yield(self)
+
           @sessions.each(&:ev_preprocess)
           return false if block_given? && !yield(self)
+
           return true
         end
-    
+
         def ev_select_and_postprocess(wait)
           owners = {}
           r = []
           w = []
           minwait = nil
           @sessions.each do |session|
-            sr,sw,actwait = session.ev_do_calculate_rw_wait(wait)
+            sr, sw, actwait = session.ev_do_calculate_rw_wait(wait)
             minwait = actwait if actwait && (minwait.nil? || actwait < minwait)
             r.push(*sr)
             w.push(*sw)
             sr.each { |ri| owners[ri] = session }
             sw.each { |wi| owners[wi] = session }
           end
-    
+
           readers, writers, = IO.select(r, w, nil, minwait)
-    
+
           fired_sessions = {}
-    
+
           if readers
             readers.each do |reader|
               session = owners[reader]
-              (fired_sessions[session] ||= { r: [],w: [] })[:r] << reader
+              (fired_sessions[session] ||= { r: [], w: [] })[:r] << reader
             end
           end
           if writers
             writers.each do |writer|
               session = owners[writer]
-              (fired_sessions[session] ||= { r: [],w: [] })[:w] << writer
+              (fired_sessions[session] ||= { r: [], w: [] })[:w] << writer
             end
           end
-    
-          fired_sessions.each do |s,rw|
-            s.ev_do_handle_events(rw[:r],rw[:w])
+
+          fired_sessions.each do |s, rw|
+            s.ev_do_handle_events(rw[:r], rw[:w])
           end
-    
+
           @sessions.each { |s| s.ev_do_postprocess(fired_sessions.key?(s)) }
           true
         end
@@ -98,18 +100,21 @@ module Net
         # we call block with session as argument
         def ev_preprocess(&block)
           return false if block_given? && !yield(@sessions.first)
+
           @sessions.each(&:ev_preprocess)
           return false if block_given? && !yield(@sessions.first)
+
           return true
         end
-    
+
         def ev_select_and_postprocess(wait)
           raise "Only one session expected" unless @sessions.count == 1
+
           session = @sessions.first
-          sr,sw,actwait = session.ev_do_calculate_rw_wait(wait)
+          sr, sw, actwait = session.ev_do_calculate_rw_wait(wait)
           readers, writers, = IO.select(sr, sw, nil, actwait)
-    
-          session.ev_do_handle_events(readers,writers)
+
+          session.ev_do_handle_events(readers, writers)
           session.ev_do_postprocess(!((readers.nil? || readers.empty?) && (writers.nil? || writers.empty?)))
         end
       end

data/lib/net/ssh/connection/keepalive.rb

@@ -1,45 +1,46 @@
 require 'net/ssh/loggable'
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Connection
-
       class Keepalive
         include Loggable
-      
+
         def initialize(session)
           @last_keepalive_sent_at = nil
           @unresponded_keepalive_count = 0
           @session = session
           self.logger = session.logger
         end
-      
+
         def options
           @session.options
         end
-      
+
         def enabled?
           options[:keepalive]
         end
-      
+
         def interval
           options[:keepalive_interval] || Session::DEFAULT_IO_SELECT_TIMEOUT
         end
-      
+
         def should_send?
           return false unless enabled?
           return true unless @last_keepalive_sent_at
+
           Time.now - @last_keepalive_sent_at >= interval
         end
-      
+
         def keepalive_maxcount
           (options[:keepalive_maxcount] || 3).to_i
         end
-      
+
         def send_as_needed(was_events)
           return if was_events
           return unless should_send?
+
           info { "sending keepalive #{@unresponded_keepalive_count}" }
-      
+
           @unresponded_keepalive_count += 1
           @session.send_global_request("keepalive@openssh.com") { |success, response|
             debug { "keepalive response successful. Missed #{@unresponded_keepalive_count - 1} keepalives" }
@@ -53,7 +54,6 @@ module Net
           end
         end
       end
-
     end
   end
 end