em-ssh 0.1.0 → 0.2.1

data/README.md

@@ -53,7 +53,7 @@ See [http://net-ssh.github.com/ssh/v2/api/index.html](http://net-ssh.github.com/
 
 ##Shell
  
-Em-ssh provides an exepct-like shell abstraction layer on top of net-ssh in EM::Ssh::Shell
+Em-ssh provides an expect-like shell abstraction layer on top of net-ssh in EM::Ssh::Shell
 
 ### Example
 	require 'em-ssh/shell'

data/lib/em-ssh.rb

@@ -15,7 +15,7 @@ module EventMachine
   #  end
   class Ssh
     DEFAULT_PORT = 22
-    
+
     # Generic error tag
     module Error; end
     # Any class that inherits from SshError will be an Exception and include a Ssh::Error tag
@@ -25,8 +25,8 @@ module EventMachine
     class Disconnected < SshError; end
     class ConnectionFailed < SshError; end
     class ConnectionTimeout < ConnectionFailed; end
-    
-    
+
+
     class << self
       attr_writer :logger
       # Creates a logger when necessary
@@ -34,7 +34,7 @@ module EventMachine
       def logger(level = Logger::WARN)
         @logger ||= ::Logger.new(STDERR).tap{ |l| l.level = level }
       end
-      
+
       # Connect to an ssh server
       # @param [String] host
       # @param [String] user
@@ -42,7 +42,7 @@ module EventMachine
       # @yield [Session]  an EventMachine compatible Net::SSH::Session
       # @see http://net-ssh.github.com/ssh/v2/api/index.html
       # @return [Session]
-      # @example 
+      # @example
       #   EM::Ssh.start(host, user, options) do |connection|
       #    log.debug "**** connected: #{connection}"
       #    connection.open_channel do |channel|
@@ -55,7 +55,7 @@ module EventMachine
       end
       alias :start :connect
     end # << self
-    
+
     # Pull in the constants from Net::SSH::[Transport, Connection and Authentication]
     # and define them locally.
     [:Transport, :Connection, :Authentication]
@@ -65,10 +65,12 @@ module EventMachine
         const_set(name, mod.const_get(name))
       end #  |name|
     end #  |module|
-    
+
   end # class::Ssh
 end # module::EventMachine
 
+EM::P::Ssh = EventMachine::Ssh
+
 
 require 'em-ssh/callbacks'
 require 'em-ssh/connection'

data/lib/em-ssh/authentication-session.rb

@@ -2,36 +2,36 @@ module EventMachine
   class Ssh
     class AuthenticationSession < Net::SSH::Authentication::Session
       include Log
-      
+
       def authenticate(*args)
         debug { "authenticate(#{args.join(", ")})" }
         super(*args)
       end # authenticate(*args)
-      
+
       # Returns once an acceptable auth packet is received.
       def next_message
-          packet = transport.next_message
+        packet = transport.next_message
 
-          case packet.type
-          when USERAUTH_BANNER
-            info { packet[:message] }
-            transport.fire(:auth_banner, packet[:message])
-            return next_message
-          when USERAUTH_FAILURE
-            @allowed_auth_methods = packet[:authentications].split(/,/)
-            debug { "allowed methods: #{packet[:authentications]}" }
-            return packet
+        case packet.type
+        when USERAUTH_BANNER
+          info { packet[:message] }
+          transport.fire(:auth_banner, packet[:message])
+          return next_message
+        when USERAUTH_FAILURE
+          @allowed_auth_methods = packet[:authentications].split(/,/)
+          debug { "allowed methods: #{packet[:authentications]}" }
+          return packet
 
-          when USERAUTH_METHOD_RANGE, SERVICE_ACCEPT
-            return packet
+        when USERAUTH_METHOD_RANGE, SERVICE_ACCEPT
+          return packet
 
-          when USERAUTH_SUCCESS
-            transport.hint :authenticated
-            return packet
+        when USERAUTH_SUCCESS
+          transport.hint :authenticated
+          return packet
 
-          else
-            raise SshError, "unexpected message #{packet.type} (#{packet})"
-          end
+        else
+          raise SshError, "unexpected message #{packet.type} (#{packet})"
+        end
       end # next_message
     end # class::AuthenticationSession
   end # module::Ssh

data/lib/em-ssh/callbacks.rb

@@ -19,13 +19,13 @@ module EventMachine
     #       end # @header[-1] == "\n"
     #     end #  |data|
     module Callbacks
-    
+
       # @return [Hash] The registered callbacks
       def callbacks
         @clbks ||= {}
       end # callbacks
-    
-    
+
+
       # Signal that an event has occured.
       # Each callback will receive whatever args are passed to fire, or the object that the event was fired upon.
       # @param [Symbol] event
@@ -36,22 +36,22 @@ module EventMachine
         args = self if args.empty?
         (callbacks[event] ||= []).clone.map { |cb| cb.call(*args) }
       end # fire(event)
-    
+
       # Register a callback to be fired when a matching event occurs.
       # The callback will be fired when the event occurs until it returns true.
       # @param [Symbol] event
       def on(event, &blk)
-        #log.debug("#{self}.on(#{event.inspect}, #{blk})")      
+        #log.debug("#{self}.on(#{event.inspect}, #{blk})")
         if block_given?
           raise "event (#{event.inspect}) must be a symbol when a block is given" unless event.is_a?(Symbol)
           return Callback.new(self, event, &blk).tap{|cb| (callbacks[event] ||= []).push(cb) }
         end # block_given?
-      
+
         raise "event (#{event.inspect}) must be a Callback when a block is not given" unless event.is_a?(Callback)
         (callbacks[event] ||= []).push(event)
         return event
       end # on(event, &blk)
-    
+
       # Registers a callback that will be canceled after the first time it is called.
       def on_next(event, &blk)
         cb = on(event) do |*args|
@@ -59,8 +59,8 @@ module EventMachine
           blk.call(*args)
         end # |*args|
       end # on_next(event, &blk)
-      
-      
+
+
       class Callback
         # The object that keeps this callback
         attr_reader :obj
@@ -68,32 +68,31 @@ module EventMachine
         attr_reader :event
         # The block to call when the event is fired
         attr_reader :block
-        
+
         def initialize(obj, event, &blk)
           raise ArgumentError.new("a block is required") unless block_given?
           @obj   = obj
           @event = event
           @block = blk
         end # initialize(obj, event, &blk)
-        
+
         # Call the callback with optional arguments
         def call(*args)
           block.call(*args)
         end # call(*args)
-        
-        # Registers the callback with the object. 
+
+        # Registers the callback with the object.
         # This is useful if you cancel the callback at one point and want to re-enable it later on.
         def register
           @obj.on(self)
         end # register
-        
+
         def cancel
           raise "#{@obj} does not have any callbacks for #{@event.inspect}" unless @obj.respond_to?(:callbacks) && @obj.callbacks.respond_to?(:[]) && @obj.callbacks[@event].respond_to?(:delete)
           @obj.callbacks[@event].delete(self)
           self
         end # cancel
       end # class::Callback
-      
     end # module::Callbacks
   end # class::Ssh
 end # module::EventMachine

data/lib/em-ssh/connection.rb

@@ -5,283 +5,277 @@ module EventMachine
     # itself into Net::SSH so that the EventMachine reactor loop can take the place of the Net::SSH event loop.
     # Most of the methods here are only for compatibility with Net::SSH
     class Connection < EventMachine::Connection
-        include Log
-        
-        # Allows other objects to register callbacks with events that occur on a Ssh instance
-        include Callbacks
-        
-        # maximum number of seconds to wait for a connection
-        TIMEOUT = 20
-        # @return [String] The host to connect to, as given to the constructor.
-        attr_reader :host
-        
-        # @return [Fixnum] the port number (DEFAULT_PORT) to connect to, as given in the options to the constructor.
-        attr_reader :port
-        
-        # @return [ServerVersion] The ServerVersion instance that encapsulates the negotiated protocol version.
-        attr_reader :server_version
-        
-        # The Algorithms instance used to perform key exchanges.
-        attr_reader :algorithms
-
-        # The host-key verifier object used to verify host keys, to ensure that the connection is not being spoofed.
-        attr_reader :host_key_verifier
-
-        # The hash of options that were given to the object at initialization.
-        attr_reader :options
-        
-        # @return [PacketStream] emulates a socket and ssh packetstream
-        attr_reader :socket
-        
-        # @return [Boolean] true if the connection has been closed
-        def closed?
-          @closed == true
-        end
-        
-        # Close the connection
-        def close
-          # #unbind will update @closed
-          close_connection
-        end
-        
-        # Send a packet to the server
-        def send_message(message)
-          @socket.send_packet(message)
-        end
-        alias :enqueue_message :send_message
-
-        def next_message
-          return @queue.shift if @queue.any? && algorithms.allow?(@queue.first)
+      include Log
+
+      # Allows other objects to register callbacks with events that occur on a Ssh instance
+      include Callbacks
+
+      # maximum number of seconds to wait for a connection
+      TIMEOUT = 20
+      # @return [String] The host to connect to, as given to the constructor.
+      attr_reader :host
+
+      # @return [Fixnum] the port number (DEFAULT_PORT) to connect to, as given in the options to the constructor.
+      attr_reader :port
+
+      # @return [ServerVersion] The ServerVersion instance that encapsulates the negotiated protocol version.
+      attr_reader :server_version
+
+      # The Algorithms instance used to perform key exchanges.
+      attr_reader :algorithms
+
+      # The host-key verifier object used to verify host keys, to ensure that the connection is not being spoofed.
+      attr_reader :host_key_verifier
+
+      # The hash of options that were given to the object at initialization.
+      attr_reader :options
+
+      # @return [PacketStream] emulates a socket and ssh packetstream
+      attr_reader :socket
+
+      # @return [Boolean] true if the connection has been closed
+      def closed?
+        @closed == true
+      end
+
+      # Close the connection
+      def close
+        # #unbind will update @closed
+        close_connection
+      end
+
+      # Send a packet to the server
+      def send_message(message)
+        @socket.send_packet(message)
+      end
+      alias :enqueue_message :send_message
+
+      def next_message
+        return @queue.shift if @queue.any? && algorithms.allow?(@queue.first)
+        f = Fiber.current
+        cb = on(:packet) do |packet|
+          if @queue.any? && algorithms.allow?(@queue.first)
+            cb.cancel
+            f.resume(@queue.shift)
+          end
+        end # :packet
+        return Fiber.yield
+      end # next_message
+
+      # Returns a new service_request packet for the given service name, ready
+      # for sending to the server.
+      def service_request(service)
+        Net::SSH::Buffer.from(:byte, SERVICE_REQUEST, :string, service)
+      end
+
+      # Requests a rekey operation, and simulates a block until the operation completes.
+      # If a rekey is already pending, this returns immediately, having no effect.
+      def rekey!
+        if !algorithms.pending?
           f = Fiber.current
-          cb = on(:packet) do |packet|
-            if @queue.any? && algorithms.allow?(@queue.first)
-              cb.cancel
-              f.resume(@queue.shift) 
-            end
-          end # :packet
+          on_next(:algo_init) do
+            f.resume
+          end # :algo_init
+          algorithms.rekey!
           return Fiber.yield
-        end # next_message
-
-        # Returns a new service_request packet for the given service name, ready
-        # for sending to the server.
-        def service_request(service)
-          Net::SSH::Buffer.from(:byte, SERVICE_REQUEST, :string, service)
         end
+      end
+
+      # Returns immediately if a rekey is already in process. Otherwise, if a
+      # rekey is needed (as indicated by the socket, see PacketStream#if_needs_rekey?)
+      # one is performed, causing this method to block until it completes.
+      def rekey_as_needed
+        return if algorithms.pending?
+        socket.if_needs_rekey? { rekey! }
+      end
+
+
+
+      ##
+      # EventMachine callbacks
+      ###
+      def post_init
+        @socket = PacketStream.new(self)
+        @data         = @socket.input
+      end # post_init
+
+      # @return
+      def unbind
+        debug("#{self} is unbound")
+        fire(:closed)
+        @closed = true
+      end
+
+      def receive_data(data)
+        debug("read #{data.length} bytes")
+        @data.append(data)
+        fire(:data, data)
+      end
+
+      def connection_completed
+        @contimeout.cancel
+        @nocon.cancel
+      end # connection_completed
+
+      def initialize(options = {})
+        debug("#{self.class}.new(#{options})")
+        @host           = options[:host]
+        @port           = options[:port]
+        @password       = options[:password]
+        @queue          = []
+        @options        = options
+        @timeout        = options[:timeout] || TIMEOUT
+
+        begin
+          on(:connected, &options[:callback]) if options[:callback]
+          @nocon          = on(:closed) { raise ConnectionFailed, @host }
+          @contimeout     = EM::Timer.new(@timeout) { raise ConnectionTimeout, @host }
+
+          @error_callback = lambda { |code| raise SshError.new(code) }
+
+          @host_key_verifier = select_host_key_verifier(options[:paranoid])
+          @server_version    = ServerVersion.new(self)
+          on(:version_negotiated) do
+            @data.consume!(@server_version.header.length)
+            @algorithms = Net::SSH::Transport::Algorithms.new(self, options)
+
+            register_data_handler
 
-        # Requests a rekey operation, and simulates a block until the operation completes.
-        # If a rekey is already pending, this returns immediately, having no effect.
-        def rekey!
-          if !algorithms.pending?
-            f = Fiber.current
             on_next(:algo_init) do
-              f.resume
+              auth = AuthenticationSession.new(self, options)
+              user = options.fetch(:user, user)
+              Fiber.new do
+                if auth.authenticate("ssh-connection", user, options[:password])
+                  fire(:connected, Session.new(self, options))
+                else
+                  fire(:error, Net::SSH::AuthenticationFailed.new(user))
+                  close_connection
+                end # auth.authenticate("ssh-connection", user, options[:password])
+              end.resume # Fiber
             end # :algo_init
-            algorithms.rekey!
-            return Fiber.yield
-          end
-        end
-        
-        # Returns immediately if a rekey is already in process. Otherwise, if a
-        # rekey is needed (as indicated by the socket, see PacketStream#if_needs_rekey?)
-        # one is performed, causing this method to block until it completes.
-        def rekey_as_needed
-          return if algorithms.pending?
-          socket.if_needs_rekey? { rekey! }
-        end
-
-
-
-        ##
-        # EventMachine callbacks
-        ###
-        def post_init
-          @socket = PacketStream.new(self)
-          @data         = @socket.input
-        end # post_init
-
-        # @return
-        def unbind
-          debug("#{self} is unbound")
-          fire(:closed)
-          @closed = true
-        end
-
-        def receive_data(data)
-          debug("read #{data.length} bytes")
-          @data.append(data)
-          fire(:data, data)
-        end
-
-        def connection_completed
-          @contimeout.cancel
-          @nocon.cancel
-        end # connection_completed
-
-        def initialize(options = {})
-          debug("#{self.class}.new(#{options})")
-          @host           = options[:host]
-          @port           = options[:port]
-          @password       = options[:password]
-          @queue          = []
-          @options        = options
-          @timeout        = options[:timeout] || TIMEOUT
-          
-          begin
-            on(:connected, &options[:callback]) if options[:callback]
-            @nocon          = on(:closed) { raise ConnectionFailed, @host }
-            @contimeout     = EM::Timer.new(@timeout) { raise ConnectionTimeout, @host }
-            
-            @error_callback = lambda { |code| raise SshError.new(code) }
-
-            @host_key_verifier = select_host_key_verifier(options[:paranoid])
-            @server_version    = ServerVersion.new(self)
-            on(:version_negotiated) do
-              @data.consume!(@server_version.header.length)
-              @algorithms = Net::SSH::Transport::Algorithms.new(self, options)
-
-              register_data_handler
-
-              on_next(:algo_init) do
-                auth = AuthenticationSession.new(self, options)
-                user = options.fetch(:user, user)
-                Fiber.new do
-                  if auth.authenticate("ssh-connection", user, options[:password])
-                    fire(:connected, Session.new(self, options))
-                  else
-                    fire(:error, Net::SSH::AuthenticationFailed.new(user))
-                    close_connection
-                  end # auth.authenticate("ssh-connection", user, options[:password])
-                end.resume # Fiber
-              end # :algo_init
-            end # :version_negotiated
-
-          rescue Exception => e
-            log.fatal("caught an error during initialization: #{e}\n   #{e.backtrace.join("\n   ")}")
-            Process.exit
-          end # begin
-          self
-        end # initialize(options = {})
-
-
-        ##
-        # Helpers required for compatibility with Net::SSH
-        ##
-
-        # Returns the host (and possibly IP address) in a format compatible with
-        # SSH known-host files.
-        def host_as_string
-          @host_as_string ||= "#{host}".tap do |string|
-            string = "[#{string}]:#{port}" if port != DEFAULT_PORT
-            _, ip = Socket.unpack_sockaddr_in(get_peername)
-            if ip != host
-              string << "," << (port != DEFAULT_PORT ? "[#{ip}]:#{port}" : ip)
-            end # ip != host
-          end #  |string|
-        end # host_as_string
-
-        alias :logger :log
-
-
-        # Configure's the packet stream's client state with the given set of
-        # options. This is typically used to define the cipher, compression, and
-        # hmac algorithms to use when sending packets to the server.
-        def configure_client(options={})
-          @socket.client.set(options)
-        end
-
-        # Configure's the packet stream's server state with the given set of
-        # options. This is typically used to define the cipher, compression, and
-        # hmac algorithms to use when reading packets from the server.
-        def configure_server(options={})
-          @socket.server.set(options)
-        end
-
-        # Sets a new hint for the packet stream, which the packet stream may use
-        # to change its behavior. (See PacketStream#hints).
-        def hint(which, value=true)
-          @socket.hints[which] = value
-        end
-
-        # Returns a new service_request packet for the given service name, ready
-        # for sending to the server.
-        def service_request(service)
-          Net::SSH::Buffer.from(:byte, SERVICE_REQUEST, :string, service)
-        end
-
-        # Returns a hash of information about the peer (remote) side of the socket,
-        # including :ip, :port, :host, and :canonized (see #host_as_string).
-        def peer
-          @peer ||= {}.tap do |p|
-            _, ip = Socket.unpack_sockaddr_in(get_peername)
-            p[:ip] = ip
-            p[:port] = @port.to_i
-            p[:host] = @host
-            p[:canonized] = host_as_string
-          end
+          end # :version_negotiated
+
+        rescue Exception => e
+          log.fatal("caught an error during initialization: #{e}\n   #{e.backtrace.join("\n   ")}")
+          Process.exit
+        end # begin
+        self
+      end # initialize(options = {})
+
+
+      ##
+      # Helpers required for compatibility with Net::SSH
+      ##
+
+      # Returns the host (and possibly IP address) in a format compatible with
+      # SSH known-host files.
+      def host_as_string
+        @host_as_string ||= "#{host}".tap do |string|
+          string = "[#{string}]:#{port}" if port != DEFAULT_PORT
+          _, ip = Socket.unpack_sockaddr_in(get_peername)
+          if ip != host
+            string << "," << (port != DEFAULT_PORT ? "[#{ip}]:#{port}" : ip)
+          end # ip != host
+        end #  |string|
+      end # host_as_string
+
+      alias :logger :log
+
+
+      # Configure's the packet stream's client state with the given set of
+      # options. This is typically used to define the cipher, compression, and
+      # hmac algorithms to use when sending packets to the server.
+      def configure_client(options={})
+        @socket.client.set(options)
+      end
+
+      # Configure's the packet stream's server state with the given set of
+      # options. This is typically used to define the cipher, compression, and
+      # hmac algorithms to use when reading packets from the server.
+      def configure_server(options={})
+        @socket.server.set(options)
+      end
+
+      # Sets a new hint for the packet stream, which the packet stream may use
+      # to change its behavior. (See PacketStream#hints).
+      def hint(which, value=true)
+        @socket.hints[which] = value
+      end
+
+      # Returns a new service_request packet for the given service name, ready
+      # for sending to the server.
+      def service_request(service)
+        Net::SSH::Buffer.from(:byte, SERVICE_REQUEST, :string, service)
+      end
+
+      # Returns a hash of information about the peer (remote) side of the socket,
+      # including :ip, :port, :host, and :canonized (see #host_as_string).
+      def peer
+        @peer ||= {}.tap do |p|
+          _, ip = Socket.unpack_sockaddr_in(get_peername)
+          p[:ip] = ip
+          p[:port] = @port.to_i
+          p[:host] = @host
+          p[:canonized] = host_as_string
         end
-
-
-
-
-      private
-
-        # Register the primary :data callback
-        # @return [Callback] the callback that was registered
-        def register_data_handler
-          on(:data) do |data|
-            while (packet = @socket.poll_next_packet)
-              case packet.type
-              when DISCONNECT
-                close_connection
-              when IGNORE
-                debug("IGNORE packet received: #{packet[:data].inspect}")
-              when UNIMPLEMENTED
-                log.warn("UNIMPLEMENTED: #{packet[:number]}")
-              when DEBUG
-                log.send((packet[:always_display] ? :fatal : :debug), packet[:message])
-              when KEXINIT
-                Fiber.new do
-                  begin
-                    algorithms.accept_kexinit(packet)
-                    fire(:algo_init) if algorithms.initialized?
-                  rescue Exception => e
-                    fire(:error, e)
-                  end # begin
-                end.resume
-              else
-                @queue.push(packet)
-                if algorithms.allow?(packet)
-                  fire(:packet, packet)
-                  fire(:session_packet, packet) if packet.type >= GLOBAL_REQUEST
-                end # algorithms.allow?(packet)
-                socket.consume!
-              end # packet.type          
-            end # (packet = @socket.poll_next_packet) 
-          end #  |data|
-        end # register_data_handler
-
-        # Instantiates a new host-key verification class, based on the value of
-        # the parameter. When true or nil, the default Lenient verifier is
-        # returned. If it is false, the Null verifier is returned, and if it is
-        # :very, the Strict verifier is returned. If the argument happens to
-        # respond to :verify, it is returned directly. Otherwise, an exception
-        # is raised.
-        # Taken from Net::SSH::Session
-        def select_host_key_verifier(paranoid)
-          case paranoid
-          when true, nil then
-            Net::SSH::Verifiers::Lenient.new
-          when false then
-            Net::SSH::Verifiers::Null.new
-          when :very then
-            Net::SSH::Verifiers::Strict.new
-          else
-            paranoid.respond_to?(:verify) ? paranoid : (raise ArgumentError.new("argument to :paranoid is not valid: #{paranoid.inspect}"))
-          end # paranoid
-        end # select_host_key_verifier(paranoid)
-        
+      end
+
+    private
+
+      # Register the primary :data callback
+      # @return [Callback] the callback that was registered
+      def register_data_handler
+        on(:data) do |data|
+          while (packet = @socket.poll_next_packet)
+            case packet.type
+            when DISCONNECT
+              close_connection
+            when IGNORE
+              debug("IGNORE packet received: #{packet[:data].inspect}")
+            when UNIMPLEMENTED
+              log.warn("UNIMPLEMENTED: #{packet[:number]}")
+            when DEBUG
+              log.send((packet[:always_display] ? :fatal : :debug), packet[:message])
+            when KEXINIT
+              Fiber.new do
+                begin
+                  algorithms.accept_kexinit(packet)
+                  fire(:algo_init) if algorithms.initialized?
+                rescue Exception => e
+                  fire(:error, e)
+                end # begin
+              end.resume
+            else
+              @queue.push(packet)
+              if algorithms.allow?(packet)
+                fire(:packet, packet)
+                fire(:session_packet, packet) if packet.type >= GLOBAL_REQUEST
+              end # algorithms.allow?(packet)
+              socket.consume!
+            end # packet.type
+          end # (packet = @socket.poll_next_packet)
+        end #  |data|
+      end # register_data_handler
+
+      # Instantiates a new host-key verification class, based on the value of
+      # the parameter. When true or nil, the default Lenient verifier is
+      # returned. If it is false, the Null verifier is returned, and if it is
+      # :very, the Strict verifier is returned. If the argument happens to
+      # respond to :verify, it is returned directly. Otherwise, an exception
+      # is raised.
+      # Taken from Net::SSH::Session
+      def select_host_key_verifier(paranoid)
+        case paranoid
+        when true, nil then
+          Net::SSH::Verifiers::Lenient.new
+        when false then
+          Net::SSH::Verifiers::Null.new
+        when :very then
+          Net::SSH::Verifiers::Strict.new
+        else
+          paranoid.respond_to?(:verify) ? paranoid : (raise ArgumentError.new("argument to :paranoid is not valid: #{paranoid.inspect}"))
+        end # paranoid
+      end # select_host_key_verifier(paranoid)
     end # class::Connection < EventMachine::Connection
   end # module::Ssh
 end # module::EventMachine
-
-

data/lib/em-ssh/log.rb

@@ -5,23 +5,23 @@ module EventMachine
       def log
         EventMachine::Ssh.logger
       end
-      
+
       def debug(msg = nil, &blk)
         log.debug("#{self.class}".downcase.gsub("::",".") + " #{msg}", &blk)
       end
-      
+
       def info(msg = nil, &blk)
         log.info("#{self.class}".downcase.gsub("::",".") + " #{msg}", &blk)
       end
-      
+
       def fatal(msg = nil, &blk)
         log.fatal("#{self.class}".downcase.gsub("::",".") + " #{msg}", &blk)
       end
-      
+
       def warn(msg = nil, &blk)
         log.warn("#{self.class}".downcase.gsub("::",".") + " #{msg}", &blk)
       end
-      
+
       def error(msg = nil, &blk)
         log.error("#{self.class}".downcase.gsub("::",".") + " #{msg}", &blk)
       end

data/lib/em-ssh/packet-stream.rb

@@ -3,8 +3,8 @@ module EventMachine
     class PacketStream
       include Net::SSH::BufferedIo
       include Log
-      
-      
+
+
       # The map of "hints" that can be used to modify the behavior of the packet
       # stream. For instance, when authentication succeeds, an "authenticated"
       # hint is set, which is used to determine whether or not to compress the
@@ -18,12 +18,12 @@ module EventMachine
       # The client state object, which encapsulates the algorithms used to build
       # packets to send to the server.
       attr_reader :client
-      
+
       # The input stream
       attr_reader :input
       # The output stream
       attr_reader :output
-      
+
       def initialize(connection)
         @connection = connection
         @input      = Net::SSH::Buffer.new
@@ -33,7 +33,7 @@ module EventMachine
         @client     = Net::SSH::Transport::State.new(self, :client)
         @packet     = nil
       end # initialize(content="")
-      
+
       # Consumes n bytes from the buffer, where n is the current position
       # unless otherwise specified. This is useful for removing data from the
       # buffer that has previously been read, when you are expecting more data
@@ -44,7 +44,7 @@ module EventMachine
       def consume!(*args)
         input.consume!(*args)
       end # consume!(*args)
-      
+
       # Tries to read the next packet. If there is insufficient data to read
       # an entire packet, this returns immediately, otherwise the packet is
       # read, post-processed according to the cipher, hmac, and compression
@@ -94,7 +94,7 @@ module EventMachine
 
         return Net::SSH::Packet.new(payload)
       end # poll_next_packet
-      
+
       # Copyright (c) 2008 Jamis Buck
       def send_packet(payload)
         # try to compress the packet
@@ -129,7 +129,7 @@ module EventMachine
 
         self
       end # send_packet(payload)
-      
+
       # Performs any pending cleanup necessary on the IO and its associated
       # state objects. (See State#cleanup).
       def cleanup
@@ -148,7 +148,6 @@ module EventMachine
           server.reset! if server.needs_rekey?
         end
       end
-      
     end # class::PacketStream
   end # class::Ssh
 end # module::EventMachine

data/lib/em-ssh/server-version.rb

@@ -2,18 +2,18 @@ module EventMachine
   class Ssh
     class ServerVersion
       include Log
-      
+
       attr_reader :header
       attr_reader :version
-      
+
       def initialize(connection)
         debug("#{self}.new(#{connection})")
         negotiate!(connection)
       end
-      
-      
-    private
-      
+
+
+      private
+
       def negotiate!(connection)
         @version = ''
         cb = connection.on(:data) do |data|
@@ -31,7 +31,6 @@ module EventMachine
           end # @header[-1] == "\n"
         end #  |data|
       end
-
     end # class::ServerVersion
   end # module::Ssh
 end # module::EventMachine

data/lib/em-ssh/session.rb

@@ -2,23 +2,23 @@ module EventMachine
   class Ssh
     class Session < Net::SSH::Connection::Session
       include Log
-      
+
       def initialize(transport, options = {})
         super(transport, options)
         register_callbacks
       end
-      
+
       # Override the default, blocking behavior of Net::SSH.
       # Callers to loop will still wait, but not block the loop.
       def loop(wait=nil, &block)
         f = Fiber.current
-        l = proc do 
+        l = proc do
           block.call ? EM.next_tick(&l) : f.resume
         end
         EM.next_tick(&l)
         return Fiber.yield
       end
-      
+
       # Override the default, blocking behavior of Net::SSH
       def process(wait=nil, &block)
         return true
@@ -44,7 +44,6 @@ module EventMachine
           channels.each { |id, channel| channel.process unless channel.closing? }
         end
       end # register_callbacks
-
     end # class::Session
   end # class::Ssh
 end # module::EventMachine

data/lib/em-ssh/shell.rb

@@ -22,10 +22,10 @@ module EventMachine
     #   admin_shell = shell.split
     #   admin_shell.on(:closed) { warn("admin shell has closed") }
     #   admin_shell.send_and_wait('sudo su -', ']$')
-    class Shell 
+    class Shell
       include Log
       include Callbacks
-      
+
       # Global timeout for wait operations; can be overriden by :timeout option to new
       TIMEOUT = 15
       # @return [Net::SSH::Connection::Channel] The shell to which we can send_data
@@ -36,7 +36,7 @@ module EventMachine
       attr_reader :options
       # @return [Hash] the options to pass to connect automatically. They will be extracted from the opptions[:net_ssh] on initialization
       attr_reader :connect_opts
-      
+
       # @return [String] the host to login to
       attr_reader :host
       # @return [String] The user to authenticate as
@@ -53,7 +53,7 @@ module EventMachine
       end
       # [String]
       attr_writer :line_terminator
-      
+
       # Connect to an ssh server then start a user shell.
       # @param [String] address
       # @param [String] user
@@ -73,27 +73,31 @@ module EventMachine
         @parent          = opts[:parent]
         @children        = []
         @reconnect       = opts[:reconnect]
-        
-        block_given? ? Fiber.new { open(&blk) }.resume : open
+
+        if block_given?
+          Fiber.new { open(&blk).tap{|r| raise r if r.is_a?(Exception) } }.resume
+        else
+          open.tap{|r| raise r if r.is_a?(Exception) }
+        end # block_given?
       end
-      
+
       # @return [Boolean] true if the connection should be automatically re-established; default: false
       def reconnect?
         @reconnect == true
-      end # auto_connect?
-      
+      end
+
       # Close the connection to the server and all child shells.
       # Disconnected shells cannot be split.
       def disconnect
         close
         connection.close
       end
-      
+
       # @return [Boolean] true if the connection is still alive
       def connected?
         connection && !connection.closed?
       end
-      
+
       # Close this shell and all children.
       # Even when a shell is closed it is still connected to the server.
       # Fires :closed event.
@@ -104,170 +108,178 @@ module EventMachine
         children.each { |c| c.close }
         fire(:closed)
       end
-      
+
       # @return [Boolean] Has this shell been closed.
       def closed?
         @closed == true
       end
-      
+
       # Send a string to the server and wait for a response containing a specified String or Regex.
       # @param [String] send_str
       # @return [String] all data in the buffer including the wait_str if it was found
       def send_and_wait(send_str, wait_str = nil, opts = {})
-        reconnect? ? connect : raise(Disconnected) if !connected?
+        reconnect? ? open : raise(Disconnected) if !connected?
         raise ClosedChannel if closed?
         debug("send_and_wait(#{send_str.inspect}, #{wait_str.inspect}, #{opts})")
         send_data(send_str)
         return wait_for(wait_str, opts)
-      end # send_and_wait(send_str, wait_str = nil, opts = {})
-      
+      end
+
       # Wait for the shell to send data containing the given string.
       # @param [String, Regexp] strregex a string or regex to match the console output against.
       # @param [Hash] opts
       # @option opts [Fixnum] :timeout (Session::TIMEOUT) the maximum number of seconds to wait
-      # @return [String] the contents of the buffer
+      # @return [String] the contents of the buffer or a TimeoutError
+      # @raise Disconnected
+      # @raise ClosedChannel
+      # @raise TimeoutError
       def wait_for(strregex, opts = { })
-        reconnect? ? connect : raise(Disconnected) unless connected?
+        reconnect? ? open : raise(Disconnected) unless connected?
         raise ClosedChannel if closed?
         debug("wait_for(#{strregex.inspect}, #{opts})")
         opts      = { :timeout => @timeout }.merge(opts)
         buffer    = ''
         found     = nil
         f         = Fiber.current
-        
-        timer   = nil
+        trace     = caller
+        timer     = nil
+
         timeout = proc do
-          debug("timeout #{timer} fired")
           shell.on_data {|c,d| }
-          begin
-            raise TimeoutError.new("#{host}: timeout while waiting for #{strregex.inspect}; received: #{buffer.inspect}")
-          rescue Exception => e
-            error(e)
-            debug(e.backtrace)
-            fire(:error, e)
-          end # begin
-          f.resume(nil)
-          shell.on_data {|c,d| }
-        end # timeout
-        
+          f.resume(TimeoutError.new("#{host}: timeout while waiting for #{strregex.inspect}; received: #{buffer.inspect}"))
+        end
         shell.on_data do |ch,data|
           buffer = "#{buffer}#{data}"
           debug("data: #{buffer.dump}")
           if strregex.is_a?(Regexp) ? buffer.match(strregex)  :  buffer.include?(strregex)
             debug("data matched")
-            debug("canceling timer #{timer}")
             timer.respond_to?(:cancel) && timer.cancel
             shell.on_data {|c,d| }
             f.resume(buffer)
           end
-        end #  |ch,data|
-        
+        end
+
         timer = EM::Timer.new(opts[:timeout], &timeout)
         debug("set timer: #{timer} for #{opts[:timeout]}")
-        return Fiber.yield
-      end # wait_for(strregex, opts = { })
-      
+        res = Fiber.yield
+        raise(res, res.message, Array(res.backtrace) + trace) if res.is_a?(Exception)
+        yield(res) if block_given?
+        res
+      end
+
+
       # Open a shell on the server.
       # You generally don't need to call this.
-      # @return [self]
+      # @return [self, Exception]
       def open(&blk)
         debug("open(#{blk})")
         f      = Fiber.current
+        trace  = caller
 
         conerr = nil
         unless connected?
           conerr = on(:error) do |e|
             error("#{e} (#{e.class})")
+            e.set_backtrace(trace + Array(e.backtrace))
             debug(e.backtrace)
             conerr = e
             f.resume(e)
           end #  |e|
           connect
         end # connected?
-        
+
         connection || raise(ConnectionError, "failed to create shell for #{host}: #{conerr} (#{conerr.class})")
-        
+
         connection.open_channel do |channel|
           debug "**** channel open: #{channel}"
           channel.request_pty(options[:pty] || {}) do |pty,suc|
             debug "***** pty open: #{pty}; suc: #{suc}"
             pty.send_channel_request("shell") do |shell,success|
-              raise ConnectionError, "Failed to create shell." unless success
+              unless success
+                f.resume(ConnectionError.new("Failed to create shell").tap{|e| e.set_backtrace(caller) })
+              end
               conerr && conerr.cancel
               debug "***** shell open: #{shell}"
-              @shell = shell
+              @closed = false
+              @shell  = shell
               Fiber.new { yield(self) if block_given? }.resume
               f.resume(self)
             end # |shell,success|
           end # |pty,suc|
         end # |channel|
-        
+
         return Fiber.yield
-      end # start
-      
+      end
+
       # Create a new shell using the same ssh connection.
-      # A connection will be established if this shell is not connected. 
+      # A connection will be established if this shell is not connected.
       # If a block is provided the child will be closed after yielding.
       # @yield [Shell] child
       # @return [Shell] child
       def split
         connect unless connected?
         child = self.class.new(host, user, pass, {:connection => connection, :parent => self}.merge(options))
-        child.line_terminator = line_terminator 
+        child.line_terminator = line_terminator
         children.push(child)
         child.on(:closed) do
-          children.delete(child) 
+          children.delete(child)
           fire(:childless).tap{ info("fired :childless") } if children.empty?
         end
         fire(:split, child)
         block_given? ? yield(child).tap { child.close } : child
-      end # split
-      
+      end
+
       # Connect to the server.
       # Does not open the shell; use #open or #split
       # You generally won't need to call this on your own.
       def connect
         return if connected?
+        trace = caller
         f = Fiber.current
-        con = ::EM::Ssh.start(host, user, connect_opts) do |connection|
-          @connection = connection
-          f.resume
-        end # |connection|
-        con.on(:error) { |e| fire(:error, e) }
+        con = ::EM::Ssh.start(host, user, connect_opts) { |connection| f.resume(@connection = connection) }
+        con.on(:error) do |e|
+          e.set_backtrace(trace + Array(e.backtrace))
+          fire(:error, e)
+          f.resume(e)
+        end
         return Fiber.yield
-      end # connect
-      
-      
+      end
+
+
       # Send data to the ssh server shell.
       # You generally don't need to call this.
       # @see #send_and_wait
       # @param [String] d the data to send encoded as a string
       def send_data(d)
-        #debug("send_data: #{d.dump}#{line_terminator.dump}")
         shell.send_data("#{d}#{line_terminator}")
       end
-      
-      
+
+
       def debug(msg = nil, &blk)
         super("#{host} #{msg}", &blk)
       end
-      
+
       def info(msg = nil, &blk)
         super("#{host} #{msg}", &blk)
       end
-      
+
       def fatal(msg = nil, &blk)
         super("#{host} #{msg}", &blk)
       end
-      
+
       def warn(msg = nil, &blk)
         super("#{host} #{msg}", &blk)
       end
-      
+
       def error(msg = nil, &blk)
         super("#{host} #{msg}", &blk)
       end
-      
+
+
+    private
+    # TODO move private stuff down to private
+    #      e.g., #open, #connect,
+
     end # class::Shell
   end # class::Ssh
 end # module::EventMachine

data/lib/em-ssh/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   class Ssh
-    VERSION='0.1.0'
+    VERSION='0.2.1'
   end # class::Ssh
-end # module::EventMachine
+end # module::EventMachine

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-ssh
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-30 00:00:00.000000000Z
+date: 2012-02-02 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &70168320140920 !ruby/object:Gem::Requirement
+  requirement: &70209705582020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70168320140920
+  version_requirements: *70209705582020
 - !ruby/object:Gem::Dependency
   name: net-ssh
-  requirement: &70168320140460 !ruby/object:Gem::Requirement
+  requirement: &70209705581560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70168320140460
+  version_requirements: *70209705581560
 - !ruby/object:Gem::Dependency
   name: ruby-termios
-  requirement: &70168320140040 !ruby/object:Gem::Requirement
+  requirement: &70209705581140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70168320140040
+  version_requirements: *70209705581140
 - !ruby/object:Gem::Dependency
   name: highline
-  requirement: &70168320139620 !ruby/object:Gem::Requirement
+  requirement: &70209705580720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70168320139620
+  version_requirements: *70209705580720
 description: ''
 email:
 - em-ssh@simulacre.org