net-ssh 2.9.2 → 4.0.0

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

@@ -126,7 +126,7 @@ module Net; module SSH; module Connection
       @pending_requests = []
       @on_open_failed = @on_data = @on_extended_data = @on_process = @on_close = @on_eof = nil
       @on_request = {}
-      @closing = @eof = @sent_eof = false
+      @closing = @eof = @sent_eof = @local_closed = @remote_closed = false
     end
 
     # A shortcut for accessing properties of the channel (see #properties).
@@ -189,12 +189,12 @@ module Net; module SSH; module Connection
     end
 
     # A hash of the valid PTY options (see #request_pty).
-    VALID_PTY_OPTIONS = { :term        => "xterm",
-                          :chars_wide  => 80,
-                          :chars_high  => 24,
-                          :pixels_wide => 640,
-                          :pixels_high => 480,
-                          :modes       => {} }
+    VALID_PTY_OPTIONS = { term: "xterm",
+                          chars_wide: 80,
+                          chars_high: 24,
+                          pixels_wide: 640,
+                          pixels_high: 480,
+                          modes: {} }
 
     # Requests that a pseudo-tty (or "pty") be made available for this channel.
     # This is useful when you want to invoke and interact with some kind of
@@ -269,24 +269,33 @@ module Net; module SSH; module Connection
       connection.loop { active? }
     end
 
-    # Returns true if the channel is currently closing, but not actually
-    # closed. A channel is closing when, for instance, #close has been
-    # invoked, but the server has not yet responded with a CHANNEL_CLOSE
-    # packet of its own.
+    # True if close() has been called; NOTE: if the channel has data waiting to
+    # be sent then the channel will close after all the data is sent. See
+    # closed?() to determine if we have actually sent CHANNEL_CLOSE to server.
+    # This may be true for awhile before closed? returns true if we are still
+    # sending buffered output to server.
     def closing?
       @closing
     end
 
-    # Requests that the channel be closed. If the channel is already closing,
-    # this does nothing, nor does it do anything if the channel has not yet
-    # been confirmed open (see #do_open_confirmation). Otherwise, it sends a
-    # CHANNEL_CLOSE message and marks the channel as closing.
+    # True if we have sent CHANNEL_CLOSE to the remote server.
+    def local_closed?
+      @local_closed
+    end
+
+    def remote_closed?
+      @remote_closed
+    end
+
+    def remote_closed!
+      @remote_closed = true
+    end
+
+    # Requests that the channel be closed. It only marks the channel to be closed
+    # the CHANNEL_CLOSE message will be sent from event loop
     def close
       return if @closing
-      if remote_id
-        @closing = true
-        connection.send_message(Buffer.from(:byte, CHANNEL_CLOSE, :long, remote_id))
-      end
+      @closing = true
     end
 
     # Returns true if the local end of the channel has declared that no more
@@ -311,10 +320,16 @@ module Net; module SSH; module Connection
       @on_process.call(self) if @on_process
       enqueue_pending_output
 
-      if @eof and not @sent_eof and output.empty? and remote_id
+      if @eof and not @sent_eof and output.empty? and remote_id and not @local_closed
         connection.send_message(Buffer.from(:byte, CHANNEL_EOF, :long, remote_id))
         @sent_eof = true
       end
+
+      if @closing and not @local_closed and output.empty? and remote_id
+        connection.send_message(Buffer.from(:byte, CHANNEL_CLOSE, :long, remote_id))
+        @local_closed = true
+        connection.cleanup_channel(self)
+      end
     end
 
     # Registers a callback to be invoked when data packets are received by the
@@ -467,6 +482,7 @@ module Net; module SSH; module Connection
     # convenient helper methods (see #exec and #subsystem).
     def send_channel_request(request_name, *data, &callback)
       info { "sending channel request #{request_name.inspect}" }
+      fail "Channel open not yet confirmed, please call send_channel_request(or exec) from block of open_channel" unless remote_id
       msg = Buffer.from(:byte, CHANNEL_REQUEST,
         :long, remote_id, :string, request_name,
         :bool, !callback.nil?, *data)
@@ -613,6 +629,12 @@ module Net; module SSH; module Connection
 
     private
 
+      # Runs the SSH event loop until the remote confirmed channel open
+      # experimental api
+      def wait_until_open_confirmed
+        connection.loop { !remote_id }
+      end
+
       # Updates the local window size by the given amount. If the window
       # size drops to less than half of the local maximum (an arbitrary
       # threshold), a CHANNEL_WINDOW_ADJUST message will be sent to the

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

@@ -0,0 +1,114 @@
+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
+
+    # 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)
+        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, = Net::SSH::Compat.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
+
+  # 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
+
+    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.ev_do_handle_events(readers,writers)
+      session.ev_do_postprocess(!((readers.nil? || readers.empty?) && (writers.nil? || writers.empty?)))
+    end
+  end
+end; end; end

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

@@ -33,8 +33,8 @@ class Keepalive
     (options[:keepalive_maxcount] || 3).to_i
   end
 
-  def send_as_needed(readers, writers)
-    return unless readers.nil? && writers.nil?
+  def send_as_needed(was_events)
+    return if was_events
     return unless should_send?
     info { "sending keepalive #{@unresponded_keepalive_count}" }
 

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

@@ -4,6 +4,7 @@ require 'net/ssh/connection/channel'
 require 'net/ssh/connection/constants'
 require 'net/ssh/service/forward'
 require 'net/ssh/connection/keepalive'
+require 'net/ssh/connection/event_loop'
 
 module Net; module SSH; module Connection
 
@@ -77,10 +78,13 @@ module Net; module SSH; module Connection
       @on_global_request = {}
       @properties = (options[:properties] || {}).dup
 
-      @max_pkt_size = (options.has_key?(:max_pkt_size) ? options[:max_pkt_size] : 0x8000)
-      @max_win_size = (options.has_key?(:max_win_size) ? options[:max_win_size] : 0x20000)
+      @max_pkt_size = (options.key?(:max_pkt_size) ? options[:max_pkt_size] : 0x8000)
+      @max_win_size = (options.key?(:max_win_size) ? options[:max_win_size] : 0x20000)
 
       @keepalive = Keepalive.new(self)
+
+      @event_loop = options[:event_loop] || SingleSessionEventLoop.new
+      @event_loop.register(self)
     end
 
     # Retrieves a custom property from this instance. This can be used to
@@ -116,7 +120,11 @@ module Net; module SSH; module Connection
     def close
       info { "closing remaining channels (#{channels.length} open)" }
       channels.each { |id, channel| channel.close }
-      loop(0.1) { channels.any? }
+      begin
+        loop(0.1) { channels.any? }
+      rescue Net::SSH::Disconnect
+        raise unless channels.empty?
+      end
       transport.close
     end
 
@@ -186,6 +194,8 @@ module Net; module SSH; module Connection
     # This will also cause all active channels to be processed once each (see
     # Net::SSH::Connection::Channel#on_process).
     #
+    # TODO revise example
+    #
     #   # process multiple Net::SSH connections in parallel
     #   connections = [
     #     Net::SSH.start("host1", ...),
@@ -203,13 +213,10 @@ module Net; module SSH; module Connection
     #     break if connections.empty?
     #   end
     def process(wait=nil, &block)
-      return false unless preprocess(&block)
-
-      r = listeners.keys
-      w = r.select { |w2| w2.respond_to?(:pending_write?) && w2.pending_write? }
-      readers, writers, = Net::SSH::Compat.io_select(r, w, nil, io_select_wait(wait))
-
-      postprocess(readers, writers)
+      @event_loop.process(wait, &block)
+    rescue
+      force_channel_cleanup_on_close if closed?
+      raise
     end
 
     # This is called internally as part of #process. It dispatches any
@@ -217,19 +224,38 @@ module Net; module SSH; module Connection
     # for any active channels. If a block is given, it is invoked at the
     # start of the method and again at the end, and if the block ever returns
     # false, this method returns false. Otherwise, it returns true.
-    def preprocess
+    def preprocess(&block)
       return false if block_given? && !yield(self)
-      dispatch_incoming_packets
-      channels.each { |id, channel| channel.process unless channel.closing? }
+      ev_preprocess(&block)
       return false if block_given? && !yield(self)
       return true
     end
 
-    # This is called internally as part of #process. It loops over the given
-    # arrays of reader IO's and writer IO's, processing them as needed, and
+    # Called by event loop to process available data before going to
+    # event multiplexing
+    def ev_preprocess(&block)
+      dispatch_incoming_packets(raise_disconnect_errors: false)
+      each_channel { |id, channel| channel.process unless channel.local_closed? }
+    end
+
+    # Returns the file descriptors the event loop should wait for read/write events,
+    # we also return the max wait
+    def ev_do_calculate_rw_wait(wait)
+      r = listeners.keys
+      w = r.select { |w2| w2.respond_to?(:pending_write?) && w2.pending_write? }
+      [r,w,io_select_wait(wait)]
+    end
+
+    # This is called internally as part of #process.
+    def postprocess(readers, writers)
+      ev_do_handle_events(readers, writers)
+    end
+
+    # It loops over the given arrays of reader IO's and writer IO's,
+    # processing them as needed, and
     # then calls Net::SSH::Transport::Session#rekey_as_needed to allow the
     # transport layer to rekey. Then returns true.
-    def postprocess(readers, writers)
+    def ev_do_handle_events(readers, writers)
       Array(readers).each do |reader|
         if listeners[reader]
           listeners[reader].call(reader)
@@ -244,11 +270,14 @@ module Net; module SSH; module Connection
       Array(writers).each do |writer|
         writer.send_pending
       end
+    end
 
-      @keepalive.send_as_needed(readers, writers)
+    # calls Net::SSH::Transport::Session#rekey_as_needed to allow the
+    # transport layer to rekey
+    def ev_do_postprocess(was_events)
+      @keepalive.send_as_needed(was_events)
       transport.rekey_as_needed
-
-      return true
+      true
     end
 
     # Send a global request of the given type. The +extra+ parameters must
@@ -306,6 +335,15 @@ module Net; module SSH; module Connection
       channels[local_id] = channel
     end
 
+    class StringWithExitstatus < String
+      def initialize(str, exitstatus)
+        super(str)
+        @exitstatus = exitstatus
+      end
+
+      attr_reader :exitstatus
+    end
+
     # A convenience method for executing a command and interacting with it. If
     # no block is given, all output is printed via $stdout and $stderr. Otherwise,
     # the block is called for each data and extended data packet, with three
@@ -326,11 +364,21 @@ module Net; module SSH; module Connection
     #       puts data
     #     end
     #   end
-    def exec(command, &block)
+    def exec(command, status: nil, &block)
       open_channel do |channel|
         channel.exec(command) do |ch, success|
           raise "could not execute command: #{command.inspect}" unless success
-          
+
+          if status
+            channel.on_request("exit-status") do |ch2,data|
+              status[:exit_code] = data.read_long
+            end
+
+            channel.on_request("exit-signal") do |ch2, data|
+              status[:exit_signal] = data.read_long
+            end
+          end
+
           channel.on_data do |ch2, data|
             if block
               block.call(ch2, :stdout, data)
@@ -351,20 +399,26 @@ module Net; module SSH; module Connection
     end
 
     # Same as #exec, except this will block until the command finishes. Also,
-    # if a block is not given, this will return all output (stdout and stderr)
+    # if no block is given, this will return all output (stdout and stderr)
     # as a single string.
     #
     #   matches = ssh.exec!("grep something /some/files")
-    def exec!(command, &block)
-      block ||= Proc.new do |ch, type, data|
+    #
+    # the returned string has an exitstatus method to query it's exit satus
+    def exec!(command, status: nil, &block)
+      block_or_concat = block || Proc.new do |ch, type, data|
         ch[:result] ||= ""
         ch[:result] << data
       end
 
-      channel = exec(command, &block)
+      status ||= {}
+      channel = exec(command, status: status, &block_or_concat)
       channel.wait
 
-      return channel[:result]
+      channel[:result] ||= "" unless block
+      channel[:result] &&= channel[:result].force_encoding("UTF-8") unless block
+
+      StringWithExitstatus.new(channel[:result], status[:exit_code]) if channel[:result]
     end
 
     # Enqueues a message to be sent to the server as soon as the socket is
@@ -453,11 +507,31 @@ module Net; module SSH; module Connection
       old
     end
 
+    def cleanup_channel(channel)
+      if channel.local_closed? and channel.remote_closed?
+        info { "#{host} delete channel #{channel.local_id} which closed locally and remotely" }
+        channels.delete(channel.local_id)
+      end
+    end
+
+    # If the #preprocess and #postprocess callbacks for this session need to run
+    # periodically, this method returns the maximum number of seconds which may
+    # pass between callbacks.
+    def max_select_wait_time
+      @keepalive.interval if @keepalive.enabled?
+    end
+
+
     private
 
+      # iterate channels with the posibility of callbacks opening new channels during the iteration
+      def each_channel(&block)
+        channels.dup.each(&block)
+      end
+
       # Read all pending packets from the connection and dispatch them as
       # appropriate. Returns as soon as there are no more pending packets.
-      def dispatch_incoming_packets
+      def dispatch_incoming_packets(raise_disconnect_errors: true)
         while packet = transport.poll_message
           unless MAP.key?(packet.type)
             raise Net::SSH::Exception, "unexpected response #{packet.type} (#{packet.inspect})"
@@ -465,6 +539,9 @@ module Net; module SSH; module Connection
 
           send(MAP[packet.type], packet)
         end
+      rescue
+        force_channel_cleanup_on_close if closed?
+        raise if raise_disconnect_errors || !$!.is_a?(Net::SSH::Disconnect)
       end
 
       # Returns the next available channel id to be assigned, and increments
@@ -473,6 +550,20 @@ module Net; module SSH; module Connection
         @channel_id_counter += 1
       end
 
+      def force_channel_cleanup_on_close
+        channels.each do |id, channel|
+          channel_closed(channel)
+        end
+      end
+
+      def channel_closed(channel)
+        channel.remote_closed!
+        channel.close
+
+        cleanup_channel(channel)
+        channel.do_close
+      end
+
       # Invoked when a global request is received. The registered global
       # request callback will be invoked, if one exists, and the necessary
       # reply returned.
@@ -581,10 +672,7 @@ module Net; module SSH; module Connection
         info { "channel_close: #{packet[:local_id]}" }
 
         channel = channels[packet[:local_id]]
-        channel.close
-
-        channels.delete(packet[:local_id])
-        channel.do_close
+        channel_closed(channel)
       end
 
       def channel_success(packet)
@@ -598,9 +686,7 @@ module Net; module SSH; module Connection
       end
 
       def io_select_wait(wait)
-        return wait if wait
-        return wait unless @keepalive.enabled?
-        @keepalive.interval
+        [wait, max_select_wait_time].compact.min
       end
 
       MAP = Constants.constants.inject({}) do |memo, name|

data/lib/net/ssh/errors.rb

@@ -5,14 +5,14 @@ module Net; module SSH
 
   # This exception is raised when authentication fails (whether it be
   # public key authentication, password authentication, or whatever).
-  class AuthenticationFailed < Exception; end
+  class AuthenticationFailed < Net::SSH::Exception; end
 
   # This exception is raised when a connection attempt times out.
-  class ConnectionTimeout < Exception; end
+  class ConnectionTimeout < Net::SSH::Exception; end
 
   # This exception is raised when the remote host has disconnected
   # unexpectedly.
-  class Disconnect < Exception; end
+  class Disconnect < Net::SSH::Exception; end
 
   # This exception is raised when the remote host has disconnected/
   # timeouted unexpectedly.
@@ -23,14 +23,14 @@ module Net; module SSH
   # want to fail in such a way that the server knows it failed, you can
   # raise this exception in the handler and Net::SSH will translate that into
   # a "channel failure" message.
-  class ChannelRequestFailed < Exception; end
+  class ChannelRequestFailed < Net::SSH::Exception; end
 
   # This is exception is primarily used internally, but if you have a channel
   # open handler (see Net::SSH::Connection::Session#on_open_channel) and you
   # want to fail in such a way that the server knows it failed, you can
   # raise this exception in the handler and Net::SSH will translate that into
   # a "channel open failed" message.
-  class ChannelOpenFailed < Exception
+  class ChannelOpenFailed < Net::SSH::Exception
     attr_reader :code, :reason
 
     def initialize(code, reason)
@@ -42,7 +42,7 @@ module Net; module SSH
   # Base class for host key exceptions. When rescuing this exception, you can
   # inspect the key fingerprint and, if you want to proceed anyway, simply call
   # the remember_host! method on the exception, and then retry.
-  class HostKeyError < Exception
+  class HostKeyError < Net::SSH::Exception
     # the callback to use when #remember_host! is called
     attr_writer :callback #:nodoc: