net-ssh 4.2.0 → 7.0.1

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

@@ -1,33 +1,33 @@
-module Net; module SSH; module Connection
+module Net
+  module SSH
+    module Connection
+      # Definitions of constants that are specific to the connection layer of the
+      # SSH protocol.
+      module Constants
+        #--
+        # Connection protocol generic messages
+        #++
 
-  # Definitions of constants that are specific to the connection layer of the
-  # SSH protocol.
-  module Constants
+        GLOBAL_REQUEST            = 80
+        REQUEST_SUCCESS           = 81
+        REQUEST_FAILURE           = 82
 
-    #--
-    # Connection protocol generic messages
-    #++
-
-    GLOBAL_REQUEST            = 80
-    REQUEST_SUCCESS           = 81
-    REQUEST_FAILURE           = 82
-
-    #--
-    # Channel related messages
-    #++
-
-    CHANNEL_OPEN              = 90
-    CHANNEL_OPEN_CONFIRMATION = 91
-    CHANNEL_OPEN_FAILURE      = 92
-    CHANNEL_WINDOW_ADJUST     = 93
-    CHANNEL_DATA              = 94
-    CHANNEL_EXTENDED_DATA     = 95
-    CHANNEL_EOF               = 96
-    CHANNEL_CLOSE             = 97
-    CHANNEL_REQUEST           = 98
-    CHANNEL_SUCCESS           = 99
-    CHANNEL_FAILURE           = 100
+        #--
+        # Channel related messages
+        #++
 
+        CHANNEL_OPEN              = 90
+        CHANNEL_OPEN_CONFIRMATION = 91
+        CHANNEL_OPEN_FAILURE      = 92
+        CHANNEL_WINDOW_ADJUST     = 93
+        CHANNEL_DATA              = 94
+        CHANNEL_EXTENDED_DATA     = 95
+        CHANNEL_EOF               = 96
+        CHANNEL_CLOSE             = 97
+        CHANNEL_REQUEST           = 98
+        CHANNEL_SUCCESS           = 99
+        CHANNEL_FAILURE           = 100
+      end
+    end
   end
-
-end; end end
+end

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

@@ -1,114 +1,123 @@
 require 'net/ssh/loggable'
-require 'net/ssh/ruby_compat'
-
-module Net; module SSH; module Connection
-  # EventLoop can be shared across multiple sessions
-  #
-  # one issue is with blocks passed to loop, etc.
-  # they should get current session as parameter, but in
-  # case you're using multiple sessions in an event loop it doesnt makes sense
-  # and we don't pass session.
-  class EventLoop
-    include Loggable
-
-    def initialize(logger=nil)
-      self.logger = logger
-      @sessions = []
-    end
 
-    def register(session)
-      @sessions << session
-    end
+module Net
+  module SSH
+    module Connection
+      # EventLoop can be shared across multiple sessions
+      #
+      # one issue is with blocks passed to loop, etc.
+      # they should get current session as parameter, but in
+      # case you're using multiple sessions in an event loop it doesnt makes sense
+      # and we don't pass session.
+      class EventLoop
+        include Loggable
+
+        def initialize(logger = nil)
+          self.logger = logger
+          @sessions = []
+        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)
+        def register(session)
+          @sessions << session
+        end
 
-      ev_select_and_postprocess(wait)
-    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)
 
-    # 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
+          ev_select_and_postprocess(wait)
+        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)
-        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
+        # 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
 
-      readers, writers, = Net::SSH::Compat.io_select(r, w, nil, minwait)
+        # 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)
 
-      fired_sessions = {}
+          @sessions.each(&:ev_preprocess)
+          return false if block_given? && !yield(self)
 
-      if readers
-        readers.each do |reader|
-          session = owners[reader]
-          (fired_sessions[session] ||= {r: [],w: []})[:r] << reader
+          return true
         end
-      end
-      if writers
-        writers.each do |writer|
-          session = owners[writer]
-          (fired_sessions[session] ||= {r: [],w: []})[:w] << writer
+
+        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)
+            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
+            end
+          end
+          if writers
+            writers.each do |writer|
+              session = owners[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])
+          end
+
+          @sessions.each { |s| s.ev_do_postprocess(fired_sessions.key?(s)) }
+          true
         end
       end
 
-      fired_sessions.each do |s,rw|
-        s.ev_do_handle_events(rw[:r],rw[:w])
-      end
+      # optimized version for a single session
+      class SingleSessionEventLoop < EventLoop
+        # Compatibility for original single session event loops:
+        # we call block with session as argument
+        def ev_preprocess(&block)
+          return false if block_given? && !yield(@sessions.first)
 
-      @sessions.each { |s| s.ev_do_postprocess(fired_sessions.key?(s)) }
-      true
-    end
-  end
+          @sessions.each(&:ev_preprocess)
+          return false if block_given? && !yield(@sessions.first)
 
-  # optimized version for a single session
-  class SingleSessionEventLoop < EventLoop
-    # Compatibility for original single session event loops:
-    # 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
+          return true
+        end
+
+        def ev_select_and_postprocess(wait)
+          raise "Only one session expected" unless @sessions.count == 1
 
-    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)
-      readers, writers, = Net::SSH::Compat.io_select(sr, sw, nil, actwait)
+          session = @sessions.first
+          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_postprocess(!((readers.nil? || readers.empty?) && (writers.nil? || writers.empty?)))
+          session.ev_do_handle_events(readers, writers)
+          session.ev_do_postprocess(!((readers.nil? || readers.empty?) && (writers.nil? || writers.empty?)))
+        end
+      end
     end
   end
-end; end; end
+end

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

@@ -1,55 +1,59 @@
 require 'net/ssh/loggable'
-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" }
-      @unresponded_keepalive_count = 0
-    }
-    @last_keepalive_sent_at = Time.now
-    if keepalive_maxcount > 0 && @unresponded_keepalive_count > keepalive_maxcount
-      error { "Timeout, server #{@session.host} not responding. Missed #{@unresponded_keepalive_count-1} timeouts." }
-      @unresponded_keepalive_count = 0
-      raise Net::SSH::Timeout, "Timeout, server #{@session.host} not responding."
+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" }
+            @unresponded_keepalive_count = 0
+          }
+          @last_keepalive_sent_at = Time.now
+          if keepalive_maxcount > 0 && @unresponded_keepalive_count > keepalive_maxcount
+            error { "Timeout, server #{@session.host} not responding. Missed #{@unresponded_keepalive_count - 1} timeouts." }
+            @unresponded_keepalive_count = 0
+            raise Net::SSH::Timeout, "Timeout, server #{@session.host} not responding."
+          end
+        end
+      end
     end
   end
 end
-
-end; end; end