net-ssh 6.2.0.rc2 → 6.3.0.beta1

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

@@ -1,11 +1,9 @@
 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
         #++
@@ -29,9 +27,7 @@ module Net
         CHANNEL_REQUEST           = 98
         CHANNEL_SUCCESS           = 99
         CHANNEL_FAILURE           = 100
-
       end
-
     end
   end
 end

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

@@ -1,7 +1,7 @@
 require 'net/ssh/loggable'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Connection
       # EventLoop can be shared across multiple sessions
       #
@@ -11,46 +11,49 @@ module Net
       # 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 = []
@@ -64,11 +67,11 @@ module Net
             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]
@@ -81,11 +84,11 @@ module Net
               (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
@@ -97,17 +100,20 @@ 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)
           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?)))
         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

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

@@ -5,10 +5,9 @@ require 'net/ssh/service/forward'
 require 'net/ssh/connection/keepalive'
 require 'net/ssh/connection/event_loop'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Connection
-
       # A session class representing the connection service running on top of
       # the SSH transport layer. It manages the creation of channels (see
       # #open_channel), and the dispatching of messages to the various channels.
@@ -28,50 +27,50 @@ module Net
       class Session
         include Loggable
         include Constants
-    
+
         # Default IO.select timeout threshold
         DEFAULT_IO_SELECT_TIMEOUT = 300
-    
+
         # The underlying transport layer abstraction (see Net::SSH::Transport::Session).
         attr_reader :transport
-    
+
         # The map of options that were used to initialize this instance.
         attr_reader :options
-    
+
         # The collection of custom properties for this instance. (See #[] and #[]=).
         attr_reader :properties
-    
+
         # The map of channels, each key being the local-id for the channel.
         attr_reader :channels #:nodoc:
-    
+
         # The map of listeners that the event loop knows about. See #listen_to.
         attr_reader :listeners #:nodoc:
-    
+
         # The map of specialized handlers for opening specific channel types. See
         # #on_open_channel.
         attr_reader :channel_open_handlers #:nodoc:
-    
+
         # The list of callbacks for pending requests. See #send_global_request.
         attr_reader :pending_requests #:nodoc:
-    
+
         class NilChannel
           def initialize(session)
             @session = session
           end
-    
+
           def method_missing(sym, *args)
             @session.lwarn { "ignoring request #{sym.inspect} for non-existent (closed?) channel; probably ssh server bug" }
           end
         end
-    
+
         # Create a new connection service instance atop the given transport
         # layer. Initializes the listeners to be only the underlying socket object.
         def initialize(transport, options={})
           self.logger = transport.logger
-    
+
           @transport = transport
           @options = options
-    
+
           @channel_id_counter = -1
           @channels = Hash.new(NilChannel.new(self))
           @listeners = { transport.socket => nil }
@@ -79,34 +78,34 @@ module Net
           @channel_open_handlers = {}
           @on_global_request = {}
           @properties = (options[:properties] || {}).dup
-    
+
           @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
         # store additional state in applications that must manage multiple
         # SSH connections.
         def [](key)
           @properties[key]
         end
-    
+
         # Sets a custom property for this instance.
         def []=(key, value)
           @properties[key] = value
         end
-    
+
         # Returns the name of the host that was given to the transport layer to
         # connect to.
         def host
           transport.host
         end
-    
+
         # Returns true if the underlying transport has been closed. Note that
         # this can be a little misleading, since if the remote server has
         # closed the connection, the local end will still think it is open
@@ -115,7 +114,7 @@ module Net
         def closed?
           transport.closed?
         end
-    
+
         # Closes the session gracefully, blocking until all channels have
         # successfully closed, and then closes the underlying transport layer
         # connection.
@@ -129,7 +128,7 @@ module Net
           end
           transport.close
         end
-    
+
         # Performs a "hard" shutdown of the connection. In general, this should
         # never be done, but it might be necessary (in a rescue clause, for instance,
         # when the connection needs to close but you don't know the status of the
@@ -137,10 +136,10 @@ module Net
         def shutdown!
           transport.shutdown!
         end
-    
+
         # preserve a reference to Kernel#loop
         alias :loop_forever :loop
-    
+
         # Returns +true+ if there are any channels currently active on this
         # session. By default, this will not include "invisible" channels
         # (such as those created by forwarding ports and such), but if you pass
@@ -157,7 +156,7 @@ module Net
             channels.any? { |id, ch| !ch[:invisible] }
           end
         end
-    
+
         # The main event loop. Calls #process until #process returns false. If a
         # block is given, it is passed to #process, otherwise a default proc is
         # used that just returns true if there are any channels active (see #busy?).
@@ -188,7 +187,7 @@ module Net
             end
           end
         end
-    
+
         # The core of the event loop. It processes a single iteration of the event
         # loop. If a block is given, it should return false when the processing
         # should abort, which causes #process to return false. Otherwise,
@@ -229,7 +228,7 @@ module Net
           force_channel_cleanup_on_close if closed?
           raise
         end
-    
+
         # This is called internally as part of #process. It dispatches any
         # available incoming packets, and then runs Net::SSH::Connection::Channel#process
         # for any active channels. If a block is given, it is invoked at the
@@ -237,18 +236,20 @@ module Net
         # false, this method returns false. Otherwise, it returns true.
         def preprocess(&block)
           return false if block_given? && !yield(self)
+
           ev_preprocess(&block)
           return false if block_given? && !yield(self)
+
           return true
         end
-    
+
         # 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)
@@ -256,12 +257,12 @@ module Net
           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
@@ -277,12 +278,12 @@ module Net
               end
             end
           end
-    
+
           Array(writers).each do |writer|
             writer.send_pending
           end
         end
-    
+
         # calls Net::SSH::Transport::Session#rekey_as_needed to allow the
         # transport layer to rekey
         def ev_do_postprocess(was_events)
@@ -290,7 +291,7 @@ module Net
           transport.rekey_as_needed
           true
         end
-    
+
         # Send a global request of the given type. The +extra+ parameters must
         # be even in number, and conform to the same format as described for
         # Net::SSH::Buffer.from. If a callback is not specified, the request will
@@ -314,7 +315,7 @@ module Net
           pending_requests << callback if callback
           self
         end
-    
+
         # Requests that a new channel be opened. By default, the channel will be
         # of type "session", but if you know what you're doing you can select any
         # of the channel types supported by the SSH protocol. The +extra+ parameters
@@ -336,25 +337,25 @@ module Net
         #   channel.wait
         def open_channel(type="session", *extra, &on_confirm)
           local_id = get_next_channel_id
-    
+
           channel = Channel.new(self, type, local_id, @max_pkt_size, @max_win_size, &on_confirm)
           msg = Buffer.from(:byte, CHANNEL_OPEN, :string, type, :long, local_id,
             :long, channel.local_maximum_window_size,
             :long, channel.local_maximum_packet_size, *extra)
           send_message(msg)
-    
+
           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
@@ -379,17 +380,17 @@ module Net
           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)
@@ -397,7 +398,7 @@ module Net
                   $stdout.print(data)
                 end
               end
-    
+
               channel.on_extended_data do |ch2, type, data|
                 if block
                   block.call(ch2, :stderr, data)
@@ -408,7 +409,7 @@ module Net
             end
           end
         end
-    
+
         # Same as #exec, except this will block until the command finishes. Also,
         # if no block is given, this will return all output (stdout and stderr)
         # as a single string.
@@ -418,20 +419,20 @@ module Net
         # 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] ||= String.new
             ch[:result] << data
           end
-    
+
           status ||= {}
           channel = exec(command, status: status, &block_or_concat)
           channel.wait
-    
-          channel[:result] ||= "" unless block
+
+          channel[:result] ||= String.new 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
         # available for writing. Most programs will never need to call this, but
         # if you are implementing an extension to the SSH protocol, or if you
@@ -442,7 +443,7 @@ module Net
         def send_message(message)
           transport.enqueue_message(message)
         end
-    
+
         # Adds an IO object for the event loop to listen to. If a callback
         # is given, it will be invoked when the io is ready to be read, otherwise,
         # the io will merely have its #fill method invoked.
@@ -480,19 +481,19 @@ module Net
         def listen_to(io, &callback)
           listeners[io] = callback
         end
-    
+
         # Removes the given io object from the listeners collection, so that the
         # event loop will no longer monitor it.
         def stop_listening_to(io)
           listeners.delete(io)
         end
-    
+
         # Returns a reference to the Net::SSH::Service::Forward service, which can
         # be used for forwarding ports over SSH.
         def forward
           @forward ||= Service::Forward.new(self)
         end
-    
+
         # Registers a handler to be invoked when the server wants to open a
         # channel on the client. The callback receives the connection object,
         # the new channel object, and the packet itself as arguments, and should
@@ -506,7 +507,7 @@ module Net
         def on_open_channel(type, &block)
           channel_open_handlers[type] = block
         end
-    
+
         # Registers a handler to be invoked when the server sends a global request
         # of the given type. The callback receives the request data as the first
         # parameter, and true/false as the second (indicating whether a response
@@ -517,61 +518,61 @@ module Net
           old, @on_global_request[type] = @on_global_request[type], block
           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(raise_disconnect_errors: true)
           while packet = transport.poll_message
             raise Net::SSH::Exception, "unexpected response #{packet.type} (#{packet.inspect})" unless MAP.key?(packet.type)
-    
+
             send(MAP[packet.type], packet)
           end
         rescue StandardError
           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
         # the counter.
         def get_next_channel_id
           @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.
@@ -583,41 +584,41 @@ module Net
           if result != :sent && result != true && result != false
             raise "expected global request handler for `#{packet[:request_type]}' to return true, false, or :sent, but got #{result.inspect}"
           end
-    
+
           if packet[:want_reply] && result != :sent
             msg = Buffer.from(:byte, result ? REQUEST_SUCCESS : REQUEST_FAILURE)
             send_message(msg)
           end
         end
-    
+
         # Invokes the next pending request callback with +true+.
         def request_success(packet)
           info { "global request success" }
           callback = pending_requests.shift
           callback.call(true, packet) if callback
         end
-    
+
         # Invokes the next pending request callback with +false+.
         def request_failure(packet)
           info { "global request failure" }
           callback = pending_requests.shift
           callback.call(false, packet) if callback
         end
-    
+
         # Called when the server wants to open a channel. If no registered
         # channel handler exists for the given channel type, CHANNEL_OPEN_FAILURE
         # is returned, otherwise the callback is invoked and everything proceeds
         # accordingly.
         def channel_open(packet)
           info { "channel open #{packet[:channel_type]}" }
-    
+
           local_id = get_next_channel_id
-    
+
           channel = Channel.new(self, packet[:channel_type], local_id, @max_pkt_size, @max_win_size)
           channel.do_open_confirmation(packet[:remote_id], packet[:window_size], packet[:packet_size])
-    
+
           callback = channel_open_handlers[packet[:channel_type]]
-    
+
           if callback
             begin
               callback[self, channel, packet]
@@ -632,80 +633,80 @@ module Net
           else
             failure = [3, "unknown channel type #{channel.type}"]
           end
-    
+
           if failure
             error { failure.inspect }
             msg = Buffer.from(:byte, CHANNEL_OPEN_FAILURE, :long, channel.remote_id, :long, failure[0], :string, failure[1], :string, "")
           end
-    
+
           send_message(msg)
         end
-    
+
         def channel_open_confirmation(packet)
           info { "channel_open_confirmation: #{packet[:local_id]} #{packet[:remote_id]} #{packet[:window_size]} #{packet[:packet_size]}" }
           channel = channels[packet[:local_id]]
           channel.do_open_confirmation(packet[:remote_id], packet[:window_size], packet[:packet_size])
         end
-    
+
         def channel_open_failure(packet)
           error { "channel_open_failed: #{packet[:local_id]} #{packet[:reason_code]} #{packet[:description]}" }
           channel = channels.delete(packet[:local_id])
           channel.do_open_failed(packet[:reason_code], packet[:description])
         end
-    
+
         def channel_window_adjust(packet)
           info { "channel_window_adjust: #{packet[:local_id]} +#{packet[:extra_bytes]}" }
           channels[packet[:local_id]].do_window_adjust(packet[:extra_bytes])
         end
-    
+
         def channel_request(packet)
           info { "channel_request: #{packet[:local_id]} #{packet[:request]} #{packet[:want_reply]}" }
           channels[packet[:local_id]].do_request(packet[:request], packet[:want_reply], packet[:request_data])
         end
-    
+
         def channel_data(packet)
           info { "channel_data: #{packet[:local_id]} #{packet[:data].length}b" }
           channels[packet[:local_id]].do_data(packet[:data])
         end
-    
+
         def channel_extended_data(packet)
           info { "channel_extended_data: #{packet[:local_id]} #{packet[:data_type]} #{packet[:data].length}b" }
           channels[packet[:local_id]].do_extended_data(packet[:data_type], packet[:data])
         end
-    
+
         def channel_eof(packet)
           info { "channel_eof: #{packet[:local_id]}" }
           channels[packet[:local_id]].do_eof
         end
-    
+
         def channel_close(packet)
           info { "channel_close: #{packet[:local_id]}" }
-    
+
           channel = channels[packet[:local_id]]
           channel_closed(channel)
         end
-    
+
         def channel_success(packet)
           info { "channel_success: #{packet[:local_id]}" }
           channels[packet[:local_id]].do_success
         end
-    
+
         def channel_failure(packet)
           info { "channel_failure: #{packet[:local_id]}" }
           channels[packet[:local_id]].do_failure
         end
-    
+
         def io_select_wait(wait)
           [wait, max_select_wait_time].compact.min
         end
-    
+
         MAP = Constants.constants.each_with_object({}) do |name, memo|
           value = const_get(name)
           next unless Integer === value
+
           memo[value] = name.downcase.to_sym
         end
       end
-
     end
   end
 end