em-ssh 0.0.1

data/README.md

@@ -0,0 +1,102 @@
+#EM-SSH
+Em-ssh is a net-ssh adapter for EventMachine. For the most part you can take any net-ssh code you have and run it in the EventMachine reactor.
+
+Em-ssh is not associated with the Jamis Buck's [net-ssh](http://net-ssh.github.com/) library. Please report any bugs with em-ssh to [https://github.com/simulacre/em-ssh/issues](https://github.com/simulacre/em-ssh/issues)
+##Installation
+	gem install em-ssh
+
+##Synopsis
+	EM.run do
+	  EM::Ssh.start(host, user, :password => password) do |ssh|
+	    # capture all stderr and stdout output from a remote process
+	    ssh.exec!('uname -a').tap {|r| puts "\nuname: #{r}"}
+    
+	    # capture only stdout matching a particular pattern
+	    stdout = ""
+	    ssh.exec!("ls -l /home") do |channel, stream, data|
+	      stdout << data if stream == :stdout
+	    end
+	    puts "\n#{stdout}"
+    
+	    # run multiple processes in parallel to completion
+	    ssh.exec('ping -c 1 www.google.com')
+	    ssh.exec('ping -c 1 www.yahoo.com')
+	    ssh.exec('ping -c 1 www.rakuten.co.jp')
+    
+	    #open a new channel and configure a minimal set of callbacks, then wait for the channel to finishes (closees).
+	    channel = ssh.open_channel do |ch|
+	      ch.exec "/usr/local/bin/ruby /path/to/file.rb" do |ch, success|
+	        raise "could not execute command" unless success
+    
+	        # "on_data" is called when the process writes something to stdout
+	        ch.on_data do |c, data|
+	          $stdout.print data
+	        end
+        
+	        # "on_extended_data" is called when the process writes something to stderr
+	        ch.on_extended_data do |c, type, data|
+	          $stderr.print data
+	        end
+        
+	        ch.on_close { puts "done!" }
+	      end
+	    end
+    
+	    channel.wait
+
+	    ssh.close
+	    EM.stop
+	  end
+	end
+
+See [http://net-ssh.github.com/ssh/v2/api/index.html](http://net-ssh.github.com/ssh/v2/api/index.html)
+
+##Shell
+ 
+Em-ssh provides an exepct-like shell abstraction layer on top of net-ssh in EM::Ssh::Shell
+
+### Example
+	EM.run {
+		EM::Ssh::Shell.new(host, 'caleb', 'password') do	|shell|
+			shell.wait_for(']$')
+			shell.send_and_wait('sudo su -', 'password for caleb: ')
+			shell.send_and_wait('password', ']$')
+			output = shell.send_and_wait('/etc/init.d/openvpn restart', ']$')
+			# ...
+			shell.send_and_wait('exit', ']$')
+			shell.send_data('exit')
+		end
+	}
+
+
+
+## Other Examples
+See bin/em-ssh for an example of a basic replacement for system ssh.
+
+See bin/em-ssh-shell for a more complex example usage of Shell.
+
+
+##Copyright
+Copyright (c) 2011 Caleb Crane
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Portions of this software are Copyright (c) 2008 Jamis Buck

data/bin/em-ssh

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+# This is really nothing more than a utility to test the em-ssh adapter.
+# It's not meant to be used for anything else.
+# It probably requires ruby 1.9.2-p180 as p190 tends to segfault when using Fibers.
+require 'bundler/setup'
+require 'termios'
+require 'highline'
+require 'em-ssh'
+
+include EM::Ssh::Log
+
+
+def bufferio( enable, io = $stdin )
+  raise "Termios library not found" unless defined?(::Termios)
+  attr = Termios::getattr( io )
+  enable ? (attr.c_lflag |= Termios::ICANON | Termios::ECHO) : (attr.c_lflag &= ~(Termios::ICANON|Termios::ECHO))
+  Termios::setattr( io, Termios::TCSANOW, attr )
+end # def bufferio( enable, io = $stdin )
+
+def abort(msg)
+  puts msg
+  Process.exit
+end # abort(msg)
+
+options = {}
+opts    = OptionParser.new
+opts.banner += " [user:[password]@]host[:port]"
+options[:port] = 22
+opts.on('-u', '--user String', String) { |u| options[:user] = u }
+opts.on('-p', '--password [String]', String) do |p| 
+  options[:password] = p.nil? ? HighLine.new.ask("password: "){|q| q.echo = "*" } : p
+end
+opts.on('-v', '--verbose') do 
+  EM::Ssh.logger.level = EM::Ssh.logger.level - 1 unless EM::Ssh.logger.level == 0 
+  options[:verbose] = EM::Ssh.logger.level
+end
+opts.parse!
+
+host = ARGV.shift
+if host.nil?
+  host,options[:password] = options[:password], HighLine.new.ask("#{options[:password]}'s password: "){|q| q.echo = "*" }
+end # host.nil?
+abort("a host is required") if host.nil?
+
+options[:user], host = *host.split('@') if host.include?('@')
+options[:user], options[:password] = *options[:user].split(':') if options[:user].include?(':')
+host, options[:port] = *host.split(':') if host.include?(':')
+connected = false
+
+
+module CInput
+  def shell=(shell)
+    @shell = shell
+  end # shell=(shell)
+  def initialize
+    bufferio(false, $stdin)
+  end # initialize
+  def unbind
+    bufferio(true, $stdin)
+  end # unbind
+  def notify_readable
+    @shell.send_data($stdin.read(1))
+  end
+end
+
+
+
+EM.run do
+  EM::Ssh.start(host, options[:user], options) do |connection|
+    debug "**** connected: #{connection}"
+    connection.open_channel do |channel|
+      debug "**** channel: #{channel}"
+      channel.request_pty(options[:pty] || {}) do |pty,suc|
+        debug "***** pty: #{pty}; suc: #{suc}"
+        pty.send_channel_request("shell") do |shell,success|
+          raise ConnectionError, "Failed to create shell." unless success
+          debug "***** shell: #{shell}"
+          connected = true
+
+          shell.on_data { |c,d| $stdout.print d } 
+          shell.on_extended_data { |c,data| $STDERR.print data }
+          shell.on_eof do
+            shell.close
+            EM.stop
+          end # 
+
+          trap("SIGINT") { shell.send_data("\C-c") }
+          trap("SIGEXIT") do
+            shell.close
+            trap("SIGINT", "SIG_DFL")
+          end # 
+
+          conn        = EM.watch($stdin, CInput)
+          conn.shell  = shell
+          conn.notify_readable = true
+
+        end # |shell,success|
+      end # |pty,suc|
+    end # |channel|
+  end #  |connection|  
+end # EM.start
+

data/bin/em-ssh-shell

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# This is really nothing more than a utility to test the em-ssh adapter.
+# It's not meant to be used for anything else.
+# It probably requires ruby 1.9.2-p180 as p190 tends to segfault when using Fibers.
+require 'bundler/setup'
+require 'termios'
+require 'highline'
+require 'em-ssh'
+require 'em-ssh/shell'
+
+include EM::Ssh::Log
+
+def abort(msg)
+  puts msg
+  Process.exit
+end # abort(msg)
+
+options = {}
+opts    = OptionParser.new
+opts.banner += " [user:[password]@]host[:port] wait_string command [command command ...]"
+options[:port] = 22
+opts.on('-u', '--user String', String) { |u| options[:user] = u }
+opts.on('-p', '--password [String]', String) do |p| 
+  options[:password] = p.nil? ? HighLine.new.ask("password: "){|q| q.echo = "*" } : p
+end
+opts.on('-v', '--verbose') do 
+  EM::Ssh.logger.level = EM::Ssh.logger.level - 1 unless EM::Ssh.logger.level == 0 
+  options[:verbose] = EM::Ssh.logger.level
+end
+opts.parse!
+
+host = ARGV.shift
+if host.nil?
+  host,options[:password] = options[:password], HighLine.new.ask("#{options[:password]}'s password: "){|q| q.echo = "*" }
+end # host.nil?
+abort("a host is required") if host.nil?
+
+options[:user], host = *host.split('@') if host.include?('@')
+options[:user], options[:password] = *options[:user].split(':') if options[:user].include?(':')
+host, options[:port] = *host.split(':') if host.include?(':')
+
+
+waitstr = ARGV.shift
+commands = ARGV
+abort("wait_string is required") if waitstr.nil?
+abort("command is required") if commands.empty?
+
+
+EM.run do
+  Fiber.new {
+    shell = EM::Ssh::Shell.new(host, options[:user], options[:password])
+     commands.each do |command|
+       mys = shell.split
+       mys.on(:closed) { info("#{mys} has closed") }
+     
+       EM.next_tick do
+         Fiber.new {
+           debug("#{mys} waited for: '#{mys.wait_for(waitstr)}'")
+           mys.line_terminator = "\n"
+           debug("#{mys} send: #{command.inspect}")
+           puts "#{mys} result: '#{mys.send_and_wait(command, waitstr)}'"
+           mys.close        
+         }.resume
+       end # 
+     end #  |command|
+     
+     shell.on(:childless) do
+       info("#{shell}'s children all closed")
+       shell.close
+       EM.stop
+     end # :childless
+  }.resume  
+end # EM.run

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

@@ -0,0 +1,38 @@
+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
+
+          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_SUCCESS
+            transport.hint :authenticated
+            return packet
+
+          else
+            raise SshError, "unexpected message #{packet.type} (#{packet})"
+          end
+      end # next_message
+    end # class::AuthenticationSession
+  end # module::Ssh
+end # module::EventMachine

data/lib/em-ssh/callbacks.rb

@@ -0,0 +1,99 @@
+module EventMachine
+  class Ssh
+    # A simple mixin enabling your objects to allow other objects to register callbacks and fire events.
+    # @example
+    #     class Connection
+    #       include Callbacks
+    #       # ...
+    #     end
+    #
+    #     connection = Connection.new(...)
+    #     cb = connection.on(:data) do |data|
+    #       @version << data
+    #       if @version[-1] == "\n"
+    #         @version.chomp!
+    #         raise SshError.new("incompatible SSH version `#{@version}'") unless @version.match(/^SSH-(1\.99|2\.0)-/)
+    #         connection.send_data("#{PROTO_VERSION}\r\n")
+    #         cb.cancel
+    #         connection.fire(:version_negotiated)
+    #       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
+      # @param [Objects] arguments to pass to all callbacks registered for the given event
+      # @param [Array] the results of each callback that was executed
+      def fire(event, *args)
+        #log.debug("#{self}.fire(#{event.inspect}, #{args})")
+        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})")      
+        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|
+          cb.cancel
+          blk.call(*args)
+        end # |*args|
+      end # on_next(event, &blk)
+      
+      
+      class Callback
+        # The object that keeps this callback
+        attr_reader :obj
+        # [Sybmol] the name of the event
+        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. 
+        # 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

@@ -0,0 +1,277 @@
+require 'em-ssh/callbacks'
+module EventMachine
+  class Ssh
+    # EventMachine::Ssh::Connection is a EventMachine::Connection that emulates the Net::SSH transport layer. It ties
+    # 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
+        
+        ##
+        # Transport related
+        
+        # @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
+            on_next(:algo_init) do
+              f.resume
+            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")
+          @closed = true
+        end
+
+        def receive_data(data)
+          debug("read #{data.length} bytes")
+          @data.append(data)
+          fire(:data, data)
+        end
+
+
+
+        def initialize(options = {})
+          debug("#{self.class}.new(#{options})")
+          @host           = options[:host]
+          @port           = options[:port]
+          @password       = options[:password]
+          @queue          = []
+          @options        = options
+
+          begin
+            on(:connected, &options[:callback]) if options[:callback]
+            @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
+                    close_connection
+                    raise Net::SSH::AuthenticationFailed, user
+                  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
+
+
+
+
+      private
+
+        # Register the primary :data callback
+        # @return [Callback] the callback that was registered
+        def register_data_handler
+          on(:data) do |data|
+            # @todo instead of while use a EM.next_tick
+            while (packet = @socket.poll_next_packet) 
+              case packet.type
+              when DISCONNECT
+                raise Net::SSH::Disconnect, "disconnected: #{packet[:description]} (#{packet[:reason_code]})"
+              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
+                   algorithms.accept_kexinit(packet)
+                   fire(:algo_init) if algorithms.initialized?
+                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

@@ -0,0 +1,30 @@
+module EventMachine
+  class Ssh
+    module Log
+      # @return [Logger] the default logger
+      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
+    end # module::Log
+  end # class::Ssh
+end # module::EventMachine

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

@@ -0,0 +1,154 @@
+module EventMachine
+  class Ssh
+    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
+      # data when using the "delayed" compression algorithm.
+      attr_reader :hints
+
+      # The server state object, which encapsulates the algorithms used to interpret
+      # packets coming from the server.
+      attr_reader :server
+
+      # 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
+        @output     = Net::SSH::Buffer.new
+        @hints      = {}
+        @server     = Net::SSH::Transport::State.new(self, :server)
+        @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
+      # to be appended. It helps to keep the size of buffers down when they
+      # would otherwise tend to grow without bound.
+      #
+      # Returns the buffer object itself.
+      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
+      # algorithms specified in the server state object, and returned as a
+      # new Packet object.
+      # Copyright (c) 2008 Jamis Buck
+      def poll_next_packet
+        if @packet.nil?
+          minimum = server.block_size < 4 ? 4 : server.block_size
+          return nil if available < minimum
+          data = read_available(minimum)
+          # decipher it
+          @packet = Net::SSH::Buffer.new(server.update_cipher(data))
+          @packet_length = @packet.read_long
+        end
+        need = @packet_length + 4 - server.block_size
+        raise SshError, "padding error, need #{need} block #{server.block_size}" if need % server.block_size != 0
+
+        return nil if available < need + server.hmac.mac_length
+
+        if need > 0
+          # read the remainder of the packet and decrypt it.
+          data = read_available(need)
+          @packet.append(server.update_cipher(data))
+        end
+
+        # get the hmac from the tail of the packet (if one exists), and
+        # then validate it.
+        real_hmac = read_available(server.hmac.mac_length) || ""
+
+        @packet.append(server.final_cipher)
+        padding_length = @packet.read_byte
+
+        payload = @packet.read(@packet_length - padding_length - 1)
+        padding = @packet.read(padding_length) if padding_length > 0
+
+        my_computed_hmac = server.hmac.digest([server.sequence_number, @packet.content].pack("NA*"))
+        raise Net::SSH::Exception, "corrupted mac detected" if real_hmac != my_computed_hmac
+
+        # try to decompress the payload, in case compression is active
+        payload = server.decompress(payload)
+
+        log.debug("received packet nr #{server.sequence_number} type #{payload.getbyte(0)} len #{@packet_length}")
+
+        server.increment(@packet_length)
+        @packet = nil
+
+        return Net::SSH::Packet.new(payload)
+      end # poll_next_packet
+      
+      # Copyright (c) 2008 Jamis Buck
+      def send_packet(payload)
+        # try to compress the packet
+        payload = client.compress(payload)
+
+        # the length of the packet, minus the padding
+        actual_length = 4 + payload.length + 1
+
+        # compute the padding length
+        padding_length = client.block_size - (actual_length % client.block_size)
+        padding_length += client.block_size if padding_length < 4
+
+        # compute the packet length (sans the length field itself)
+        packet_length = payload.length + padding_length + 1
+        if packet_length < 16
+          padding_length += client.block_size
+          packet_length = payload.length + padding_length + 1
+        end
+
+        padding = Array.new(padding_length) { rand(256) }.pack("C*")
+
+        unencrypted_data = [packet_length, padding_length, payload, padding].pack("NCA*A*")
+        mac = client.hmac.digest([client.sequence_number, unencrypted_data].pack("NA*"))
+
+        encrypted_data = client.update_cipher(unencrypted_data) << client.final_cipher
+        message = encrypted_data + mac
+
+        log.debug("queueing packet nr #{client.sequence_number} type #{payload.getbyte(0)} len #{packet_length}")
+        @connection.send_data(message)
+        log.debug("sent #{message.length} bytes")
+        client.increment(packet_length)
+
+        self
+      end # send_packet(payload)
+      
+      # Performs any pending cleanup necessary on the IO and its associated
+      # state objects. (See State#cleanup).
+      def cleanup
+        client.cleanup
+        server.cleanup
+      end
+
+      # If the IO object requires a rekey operation (as indicated by either its
+      # client or server state objects, see State#needs_rekey?), this will
+      # yield. Otherwise, this does nothing.
+      # Copyright (c) 2008 Jamis Buck
+      def if_needs_rekey?
+        if client.needs_rekey? || server.needs_rekey?
+          yield
+          client.reset! if client.needs_rekey?
+          server.reset! if server.needs_rekey?
+        end
+      end
+      
+    end # class::PacketStream
+  end # class::Ssh
+end # module::EventMachine

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

@@ -0,0 +1,37 @@
+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
+      
+      def negotiate!(connection)
+        @version = ''
+        cb = connection.on(:data) do |data|
+          log.debug("#{self.class}.on(:data, #{data.inspect})")
+          @version << data
+          @header = @version.clone
+          if @version[-1] == "\n"
+            @version.chomp!
+            log.debug("server version: #{@version}")
+            raise SshError.new("incompatible SSH version `#{@version}'") unless @version.match(/^SSH-(1\.99|2\.0)-/)
+            log.debug("local version: #{Net::SSH::Transport::ServerVersion::PROTO_VERSION}")
+            connection.send_data("#{Net::SSH::Transport::ServerVersion::PROTO_VERSION}\r\n")
+            cb.cancel
+            connection.fire(:version_negotiated)
+          end # @header[-1] == "\n"
+        end #  |data|
+      end
+
+    end # class::ServerVersion
+  end # module::Ssh
+end # module::EventMachine

data/lib/em-ssh/session.rb

@@ -0,0 +1,51 @@
+
+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 
+          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
+      end
+
+      def send_message(msg)
+        transport.send_message(msg)
+      end
+
+
+    private
+
+
+      def register_callbacks
+        transport.on(:packet) do |packet|
+          raise SshError, "unexpected response #{packet.type} (#{packet.inspect})" unless MAP.key?(packet.type)
+          send(MAP[packet.type], packet)
+        end #  |packet|
+
+        chann_proc = proc do
+          channels.each { |id, channel| channel.process unless channel.closing? }
+          EM.next_tick(&chann_proc)
+        end
+        EM.next_tick(&chann_proc)
+      end # register_callbacks
+
+    end # class::Session
+  end # class::Ssh
+end # module::EventMachine

data/lib/em-ssh/shell.rb

@@ -0,0 +1,225 @@
+require 'em-ssh'
+
+module EventMachine
+  class Ssh
+    # EM::Ssh::Shell encapsulates interaction with a user shell on an SSH server.
+    # @example Retrieve the output of ifconfig -a on a server
+    #   EM.run{
+    #     shell = EM::Ssh::Shell.new(host, user, password)
+    #     shell.wait_for('@icaleb ~]$')
+    #     interfaces = send_and_wait('/sbin/ifconfig -a', '@icaleb ~]$')
+    #
+    # Shells can be easily and quickly duplicated (#split) without the need to establish another connection.
+    # Shells provide :closed, :childless, and :split callbacks.
+    #
+    # @example Start another shell using the same connection
+    #   shell.on(:childless) do
+    #     info("#{shell}'s children all closed")
+    #     shell.disconnect
+    #     EM.stop
+    #   end
+    #
+    #   admin_shell = shell.split
+    #   admin_shell.on(:closed) { warn("admin shell has closed") }
+    #   admin_shell.send_and_wait('sudo su -', ']$')
+    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
+      attr_reader :shell
+      # @return [Net::SSH::Connection]
+      attr_reader :connection
+      # @return [Boolean] Default (false) halt on timeout value - when true any timeouts will be halt the shell by raising an exception
+      attr_reader :halt_on_timeout
+      # @return [Hash] the options passed to initialize
+      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
+      attr_reader :user
+      # @return [String] the password to authenticate with - can be nil
+      attr_reader :pass
+      # @return [Array] all shells that have been split off from this one.
+      attr_reader :children
+      # @return [Shell] the parent of this shell
+      attr_reader :parent
+      # @return [String] a string (\r\n) to append to every command
+      def line_terminator
+        @line_terminator ||= "\r\n"
+      end
+      # [String]
+      attr_writer :line_terminator
+      
+      # Connect to an ssh server then start a user shell.
+      # @param [String] address
+      # @param [String] user
+      # @param [String, nil] pass by default publickey and password auth will be attempted
+      # @param [Hash] opts
+      # @option opts [Hash] :net_ssh options to pass to Net::SSH; see Net::SSH.start
+      # @option opts [Boolean] :halt_on_timeout (false)
+      # @option opts [Fixnum] :timeout (TIMEOUT) default timeout for all #wait_for and #send_wait calls.
+      def initialize(address, user, pass, opts = {}, &blk)
+        @halt_on_timeout = opts[:halt_on_timeout] || false
+        @timeout         = opts[:timeout].is_a?(Fixnum) ? opts[:timeout] : TIMEOUT
+        @host            = address
+        @user            = user
+        @pass            = pass
+        @options         = opts
+        @connect_opts    = {:password => pass, :port => 22, :auth_methods => ['publickey', 'password']}.merge(opts[:net_ssh] || {})
+        @connection      = opts[:connection]
+        @parent          = opts[:parent]
+        @children        = []
+        
+        block_given? ? open(&blk) : open
+      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.
+      # @see Callbacks
+      def close
+        shell.close.tap{ debug("closing") } if shell.active?
+        @closed = true
+        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 = {})
+        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 = {})
+      
+      # 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
+      # @option opts [Boolean] (false) :halt_on_timeout 
+      # @return [String] the contents of the buffer
+      def wait_for(strregex, opts = { })
+        raise ClosedChannel if closed?
+        debug("wait_for(#{strregex}, #{opts})")
+        opts      = { :timeout => @timeout, :halt_on_timeout => @halt_on_timeout }.merge(opts)
+        buffer    = ''
+        found     = nil
+        f         = Fiber.current
+        
+        timer   = nil
+        timeout = proc do
+          shell.on_data {|c,d| }
+          # @todo fire an em errback
+          if opts[:halt_on_timeout]
+            raise TimeoutError("timeout while waiting for #{strregex.inspect}; received: #{buffer.inspect}")
+          else
+            warn("timeout while waiting for #{strregex.inspect}; received: #{buffer.inspect}")
+          end # opts[:halt_on_timeout]
+        end # timeout
+        
+        shell.on_data do |ch,data|
+          buffer = "#{buffer}#{data}"
+          if strregex.is_a?(Regexp) ? buffer.match(strregex)  :  buffer.include?(strregex)
+            timer.respond_to?(:cancel) && timer.cancel
+            result = buffer.clone
+            shell.on_data {|c,d| }
+            f.resume(result)
+          end
+        end #  |ch,data|
+        
+        timer = EM::Timer.new(opts[:timeout], &timeout)
+        return Fiber.yield
+      end # wait_for(strregex, opts = { })
+      
+      # Open a shell on the server.
+      # You generally don't need to call this.
+      # @return [self]
+      def open
+        f = Fiber.current
+        connect unless connected?
+        
+        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
+              debug "***** shell open: #{shell}"
+              @shell = shell
+              f.resume(self)
+            end # |shell,success|
+          end # |pty,suc|
+        end # |channel|
+        
+        return Fiber.yield
+      end # start
+      
+      # Create a new shell using the same ssh connection.
+      # 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 
+        children.push(child)
+        child.on(:closed) do
+          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
+      
+      # 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
+        f = Fiber.current
+        ::EM::Ssh.start(host, user, connect_opts) do |connection|
+          @connection = connection
+          f.resume
+        end # |connection|
+        return Fiber.yield
+      end # connect
+      
+      
+      # 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.inspect}#{line_terminator}")
+        shell.send_data("#{d}#{line_terminator}")
+      end
+      
+      
+    end # class::Shell
+  end # class::Ssh
+end # module::EventMachine

data/lib/em-ssh/version.rb

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

data/lib/em-ssh.rb

@@ -0,0 +1,74 @@
+require 'eventmachine'
+
+require 'fiber'
+require 'timeout'
+
+require 'net/ssh'
+require 'em-ssh/log'
+
+module EventMachine
+  # @example
+  #   EM::Ssh.start(host, user, :password => password) do |ssh|
+  #    ssh.exec("hostname") do |ch,stream,data|
+  #      puts "data: #{data}"
+  #    end
+  #  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
+    class SshError < Net::SSH::Exception; include Error; end
+    class TimeoutError < Timeout::Error; include Error; end
+    class ClosedChannel < SshError; end
+    
+    class << self
+      attr_writer :logger
+      # Creates a logger when necessary
+      # @return [Logger]
+      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
+      # @param [Hash] opts all options accepted by Net::SSH.start
+      # @yield [Session]  an EventMachine compatible Net::SSH::Session
+      # @see http://net-ssh.github.com/ssh/v2/api/index.html
+      # @return [Session]
+      # @example 
+      #   EM::Ssh.start(host, user, options) do |connection|
+      #    log.debug "**** connected: #{connection}"
+      #    connection.open_channel do |channel|
+      #      log.debug "**** channel: #{channel}"
+      #      channel.request_pty(options[:pty] || {}) do |pty,suc|
+      def connect(host, user, opts = {}, &blk)
+        logger.debug("#{self}.connect(#{host}, #{user}, #{opts})")
+        options = { :host => host, :user => user, :port => DEFAULT_PORT, :callback => blk }.merge(opts)
+        EM.connect(options[:host], options[:port], Connection, options)
+      end
+      alias :start :connect
+    end # << self
+    
+    # Pull in the constants from Net::SSH::[Transport, Connection and Authentication]
+    # and define them locally.
+    [:Transport, :Connection, :Authentication]
+    .map{ |sym| Net::SSH.const_get(sym).const_get(:Constants) }
+    .each do |mod|
+      mod.constants.each do |name|
+        const_set(name, mod.const_get(name))
+      end #  |name|
+    end #  |module|
+    
+  end # class::Ssh
+end # module::EventMachine
+
+
+require 'em-ssh/callbacks'
+require 'em-ssh/connection'
+require 'em-ssh/server-version'
+require 'em-ssh/packet-stream'
+require 'em-ssh/authentication-session'
+require 'em-ssh/session'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: em-ssh
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Caleb Crane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70157793111680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70157793111680
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: &70157793111020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70157793111020
+- !ruby/object:Gem::Dependency
+  name: ruby-termios
+  requirement: &70157793110100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70157793110100
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: &70157793109680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70157793109680
+description: ''
+email:
+- em-ssh@simulacre.org
+executables:
+- em-ssh
+- em-ssh-shell
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/em-ssh/authentication-session.rb
+- lib/em-ssh/callbacks.rb
+- lib/em-ssh/connection.rb
+- lib/em-ssh/log.rb
+- lib/em-ssh/packet-stream.rb
+- lib/em-ssh/server-version.rb
+- lib/em-ssh/session.rb
+- lib/em-ssh/shell.rb
+- lib/em-ssh/version.rb
+- lib/em-ssh.rb
+- bin/em-ssh
+- bin/em-ssh-shell
+- README.md
+homepage: http://github.com/simulacre/em-ssh
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: An EventMachine compatible net-ssh
+test_files: []
+has_rdoc: