em-ssh 0.4.3 → 0.5.0

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+0.5.0
+ - Shell an Connection instances can have their own Loggers 
+ - [#18](https://github.com/simulacre/em-ssh/pull/18) - Target devices and options for specs can be configured through environment variables [@freakhill](https://github.com/freakhill)
+ - [#19](https://github.com/simulacre/em-ssh/pull/19) - Decouple interactive behavior from Shell allowing for other channels to be extended with #expect, etc., [@freakhill](https://github.com/freakhill)
+  
+0.4.2
+ - Connection accepts :nego_timeout (seconds to wait for protocol and algorithm negotiation to finish)
+ - If protocol, or algorithm negotiation fail #errback will be called
+ - Shell#disconnect! forcefully terminates the connection
+ - Shell#disconnect takes a timeout
+ - EM::Ssh::Session#close overrides Net::SSH::Connection::Session to check for
+ transport before trying to close channels
+ - Fixes: dangling references to EM::Timers are removed from EM::Ssh::Connection
+ - Fixes: various dangling references to EM::Ssh::Connection and EM::Ssh::Session are properly removed
+
+0.4.1
+ - Connections terminated before version negotiation wil fail with EM::Ssh::ConnectionTermianted
+
+0.3.0
+ - Provides Shell#expect which can be used to wait for a string, or send a command and then wait
+ - Connection errors are provided as Deferreds and don't halt the entire reactor
+ - Shell timeouts are for inactivity and not total duration
+ - Shell buffer is maintained until wait_for matches; results from send_cmd without a corresponding wait_for will be retained in the buffer.
+
+0.1.0
+ - Connection#initialize will fire :error Net::SSH::AuthenticationError when authentication fails rather than raising an error
+ - Shell#open will catch :error fired by Connection#initialize and raise it as a ConnectionError
+ - Shell no longer accepts :halt_on_timeout
+ - Shell#wait_for will fire :error if timeout is reached
+ - Key exchange exceptions will be caught and propagated through fire :error
+
+0.0.3
+ - Removes CPU pegging via recursive EM.next_tick
+ - Adds an auto reconnect option to shell

data/README.md

@@ -8,10 +8,12 @@ Em-ssh is not associated with the Jamis Buck's [net-ssh](http://net-ssh.github.c
 ##Synopsis
 
 ```ruby
+require "em-ssh"
 EM.run do
   EM::Ssh.start(host, user, :password => password) do |connection|
     connection.errback do |err|
       $stderr.puts "#{err} (#{err.class})"
+      EM.stop
     end
     connection.callback do |ssh|
       # capture all stderr and stdout output from a remote process
@@ -70,14 +72,13 @@ require 'em-ssh/shell'
 EM.run do
   EM::Ssh::Shell.new(host, ENV['USER'], "") do |shell|
     shell.callback do
-      shell.expect('~]$ ')
-      shell.expect('~]$ ','uname -a')
-      shell.expect('~]$ ')
-      shell.expect('~]$ ', '/sbin/ifconfig -a')
+      shell.expect(Regexp.escape('~]$ '))
+      $stderr.puts shell.expect(Regexp.escape('~]$ '),'uname -a')
+      $stderr.puts shell.expect(Regexp.escape('~]$ '), '/sbin/ifconfig -a')
       EM.stop
     end
-    shell.errback do
-      puts "error: #{err} (#{err.class})" 
+    shell.errback do |err|
+      $stderr.puts "error: #{err} (#{err.class})"
       EM.stop
     end
   end
@@ -88,34 +89,90 @@ end
 
 ```ruby
 require 'em-ssh/shell'
+
+waitstr = Regexp.escape('~]$ ')
+commands = ["uname -a", "uptime", "ifconfig"]
 EM.run do
-  EM::Ssh::Shell.new(host, ENV['USER'], '') do |shell|
+  EM::Ssh::Shell.new(host, user, "") do |shell|
     shell.errback do |err|
-      puts "error: #{err} (#{err.class})"
+      $stderr.puts "error: #{err} (#{err.class})"
       EM.stop
-    end 
+    end
 
-    shell.callback do 
+    shell.callback do
       commands.clone.each do |command|
         mys = shell.split # provides a second session over the same connection
+
         mys.on(:closed) do
           commands.delete(command)
           EM.stop if commands.empty?
         end
 
-        puts("waiting for: #{waitstr.inspect}")
-        # When given a block, Shell#expect does not 'block'
-        mys.expect(waitstr) do 
-          puts "sending #{command.inspect} and waiting for #{waitstr.inspect}"
-          mys.expect(waitstr, command) do |result|
-            puts "#{mys} result: '#{result}'"
-            mys.close
-          end 
-        end 
-      end 
-    end 
-  end 
-end 
+        mys.callback do
+          $stderr.puts("waiting for: #{waitstr.inspect}")
+          # When given a block, Shell#expect does not 'block'
+          mys.expect(waitstr) do
+            $stderr.puts "sending #{command.inspect} and waiting for #{waitstr.inspect}"
+            mys.expect(waitstr, command) do |result|
+              $stderr.puts "#{mys} result: '#{result}'"
+              mys.close
+            end
+          end
+        end
+
+        mys.errback do |err|
+          $stderr.puts "subshell error: #{err} (#{err.class})"
+          mys.close
+        end
+
+      end
+    end
+  end
+end
+```
+
+
+```ruby
+waitstr  = Regexp.escape('~]$ ')
+commands = ["uname -a", "uptime", "ifconfig"]
+
+require 'em-ssh/shell'
+EM.run do
+  EM::Ssh::Shell.new(host, user, "") do |shell|
+    shell.errback do |err|
+      $stderr.puts "error: #{err} (#{err.class})"
+      $stderr.puts err.backtrace
+      EM.stop
+    end
+
+    shell.callback do
+      commands.clone.each do |command|
+        Fiber.new {
+          # When given a block Shell#split will close the Shell after
+          # the block returns. If a block is given it must be called 
+          # within a Fiber.
+          sresult = shell.split do |mys|
+            mys.on(:closed) do
+              commands.delete(command)
+              EM.stop if commands.empty?
+            end
+            mys.errback do |err|
+              $stderr.puts "subshell error: #{err} (#{err.class})"
+              mys.close
+            end
+
+              mys.expect(waitstr)
+              result = mys.expect(waitstr, command)
+              $stderr.puts "#{mys} result: '#{result.inspect}'"
+              result
+          end
+          $stderr.puts "split result: #{sresult.inspect} +++"
+        }.resume
+
+      end
+    end
+  end
+end
 ```
 
 ## Other Examples

data/lib/em-ssh/connection/channel/interactive.rb

@@ -0,0 +1,168 @@
+require 'em-ssh/connection/channel/null-logger'
+
+module EventMachine
+  class Ssh
+    class Connection
+      class Channel
+
+        # This module adds functionality to any channel it extends.
+        # It mainly provides functionality to help interactive behaviour on said channel.
+        # * #send_data (improved) that can append 'line terminators'.
+        # * #wait_for - waits for the shell to send data containing the given string.
+        # * #send_and_wait - sends a string and waits for a response containing a specified pattern.
+        # * #expect - waits for a number of seconds until a pattern is matched by the channel output.
+        # @example
+        #   ch = get_some_ssh_channel_from_somewhere
+        #   ch.extend(Interactive)
+        #   ch.send_and_wait("ls -a", PROMPT)
+        #   # > we get the result of the `ls -a` command through the channel (hopefully)
+        module Interactive
+
+          include Callbacks
+
+          DEFAULT_TIMEOUT = 15
+
+          attr_accessor :buffer
+          private :buffer, :buffer=
+
+          # @return[String] a string (\r\n) to append to every command
+          attr_accessor :line_terminator
+
+          def self.extended(channel)
+            channel.init_interactive_module
+          end
+
+          # When this module extends an object this method is automatically called (via self#extended).
+          # In other cases (include, prepend?), you need to call this method manually before use of the channel.
+          def init_interactive_module
+            @buffer = ''
+            @line_terminator = "\n"
+            on_data do |ch, data|
+              @buffer += data
+              fire(:data, data)
+            end
+          end
+
+          # @returns[#to_s] Returns a #to_s object describing the dump of the content of the buffers used by
+          #                 the methods of the interactive module mixed in the host object.
+          def dump_buffers
+            @buffer.dump
+          end
+
+          # Wait for a number of seconds until a specified string or regexp is matched by the
+          # data returned from the ssh channel. Optionally send a given string first.
+          #
+          # If a block is not provided the current Fiber will yield until strregex matches or
+          # :timeout is reached.
+          #
+          # If a block is provided expect will return.
+          #
+          # @param [String, Regexp] strregex to match against
+          # @param [String] send_str the data to send before waiting
+          # @param [Hash] opts
+          # @option opts [Fixnum] :timeout (@timeout) number of seconds to wait when there is no activity
+          # @return [Shell, String] all data received up to an including strregex if a block is not provided.
+          #                         the Shell if a block is provided
+          # @example expect a prompt
+          #   expect(' ~]$ ')
+          # @example send a command and wait for a prompt
+          #   expect(' ~]$ ', '/sbin/ifconfig')
+          # @example expect a prompt and within 5 seconds
+          #   expect(' ~]$ ', :timeout => 5)
+          # @example send a command and wait up to 10 seconds for a prompt
+          #   expect(' ~]$ ', '/etc/sysconfig/openvpn restart', :timeout => 10)
+          def expect(strregex, send_str = nil, opts = {})
+            send_str, opts = nil, send_str if send_str.is_a?(Hash)
+            if block_given?
+              Fiber.new {
+                yield send_str ? send_and_wait(send_str, strregex, opts) : wait_for(strregex, opts)
+              }.resume
+              self
+            else
+              send_str ? send_and_wait(send_str, strregex, opts) : wait_for(strregex, opts)
+            end
+          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 = {})
+            send_data(send_str, true)
+            return wait_for(wait_str, opts)
+          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
+          # @param [Boolean] send_newline appends a newline terminator to the data (defaults: false).
+          def send_data(d, send_newline=false)
+            if send_newline
+              super("#{d}#{@line_terminator}")
+            else
+              super("#{d}")
+            end
+          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 or a TimeoutError
+          # @raise Disconnected
+          # @raise ClosedChannel
+          # @raise TimeoutError
+          def wait_for(strregex, opts = { })
+            ###
+            log = opts[:log] || NullLogger.new
+            timeout = opts[:timeout].is_a?(Fixnum) ? opts[:timeout] : DEFAULT_TIMEOUT
+            ###
+            log.debug("wait_for(#{strregex.inspect}, :timeout => #{opts[:timeout] || @timeout})")
+            opts          = { :timeout => @timeout }.merge(opts)
+            found         = nil
+            f             = Fiber.current
+            trace         = caller
+            timer         = nil
+            data_callback = nil
+            matched       = false
+            started       = Time.new
+
+            timeout = proc do
+              data_callback && data_callback.cancel
+              f.resume(TimeoutError.new("#{connection.host}: inactivity timeout (#{opts[:timeout]}) while waiting for #{strregex.inspect}; received: #{buffer.inspect}; waited total: #{Time.new - started}"))
+            end
+
+            data_callback = on(:data) do
+              timer && timer.cancel
+              if matched
+                log.warn("data_callback invoked when already matched")
+                next
+              end
+              if (matched = buffer.match(strregex))
+                log.debug("matched #{strregex.inspect} on #{buffer.inspect}")
+                data_callback.cancel
+                @buffer = matched.post_match
+                f.resume(matched.pre_match + matched.to_s)
+              else
+                timer = EM::Timer.new(opts[:timeout], &timeout)
+              end
+            end
+
+            # Check against current buffer
+            EM::next_tick { data_callback.call() if buffer.length > 0 }
+
+            timer = EM::Timer.new(opts[:timeout], &timeout)
+            Fiber.yield.tap do |res|
+              if res.is_a?(Exception)
+                res.set_backtrace(Array(res.backtrace) + trace)
+                raise res
+              end
+              yield(res) if block_given?
+            end
+          end
+
+        end # module Interactive
+      end # class Channel
+    end # class Connection
+  end # class Ssh
+end # module EventChannel

data/lib/em-ssh/connection/channel/null-logger.rb

@@ -0,0 +1,17 @@
+require 'logger'
+
+module EventMachine
+  class Ssh
+    class Connection
+      class Channel
+        class NullLogger < ::Logger
+
+          def add(*params, &block)
+            nil
+          end
+
+        end # class NullLogger
+      end # class Channel
+    end # class Connection
+  end # class Ssh
+end # module EventMachine

data/lib/em-ssh/log.rb

@@ -3,7 +3,7 @@ module EventMachine
     module Log
       # @return [Logger] the default logger
       def log
-        EventMachine::Ssh.logger
+        @logger || EventMachine::Ssh.logger
       end
 
       def debug(msg = nil, &blk)

data/lib/em-ssh/shell.rb

@@ -1,4 +1,5 @@
 require 'em-ssh'
+require 'em-ssh/connection/channel/interactive'
 
 module EventMachine
   class Ssh
@@ -50,12 +51,17 @@ module EventMachine
       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 ||= "\n"
+        shell ? shell.line_terminator : "\n"
+      end
+
+      # @param[String] lt a string (\r\n) to append to every command
+      def line_terminator=(lt)
+        @line_terminator = lt
+        shell.line_terminator = lt if shell
       end
-      # [String]
-      attr_writer :line_terminator
 
       # Connect to an ssh server then start a user shell.
       # @param [String] address
@@ -71,12 +77,12 @@ module EventMachine
         @user            = user
         @pass            = pass
         @options         = opts
-        @connect_opts    = {:password => pass, :port => 22, :auth_methods => ['publickey', 'password']}.merge(opts[:net_ssh] || {})
+        @logger          = opts[:logger] if opts[:logger]
+        @connect_opts    = {:password => pass, :port => 22, :auth_methods => ['publickey', 'password'], :logger => log}.merge(opts[:net_ssh] || {})
         @session         = opts[:session]
         @parent          = opts[:parent]
         @children        = []
         @reconnect       = opts[:reconnect]
-        @buffer          = ''
 
         # TODO make all methods other than #callback and #errback inaccessible until connected? == true
         yield self if block_given?
@@ -99,6 +105,7 @@ module EventMachine
         end
         close
         @session && @session.close
+        @shell = nil
         disconnect!
       end
 
@@ -115,6 +122,7 @@ module EventMachine
         session && !session.closed?
       end
 
+
       # Close this shell and all children.
       # Even when a shell is closed it is still connected to the server.
       # Fires :closed event.
@@ -131,117 +139,31 @@ module EventMachine
         @closed == true
       end
 
-      # Wait for a number of seconds until a specified string or regexp is matched by the
-      # data returned from the ssh connection. Optionally send a given string first.
-      #
-      # If a block is not provided the current Fiber will yield until strregex matches or
-      # :timeout # is reached.
-      #
-      # If a block is provided expect will return.
-      #
-      # @param [String, Regexp] strregex to match against
-      # @param [String] send_str the data to send before waiting
-      # @param [Hash] opts
-      # @option opts [Fixnum] :timeout (@timeout) number of seconds to wait when there is no activity
-      # @return [Shell, String] all data received up to an including strregex if a block is not provided.
-      #                         the Shell if a block is provided
-      # @example expect a prompt
-      #   expect(' ~]$ ')
-      # @example send a command and wait for a prompt
-      #   expect(' ~]$ ', '/sbin/ifconfig')
-      # @example expect a prompt and within 5 seconds
-      #   expect(' ~]$ ', :timeout => 5)
-      # @example send a command and wait up to 10 seconds for a prompt
-      #   expect(' ~]$ ', '/etc/sysconfig/openvpn restart', :timeout => 10)
-      def expect(strregex, send_str = nil, opts = {})
-        send_str, opts = nil, send_str if send_str.is_a?(Hash)
-        if block_given?
-          Fiber.new {
-            yield send_str ? send_and_wait(send_str, strregex, opts) : wait_for(strregex, opts)
-          }.resume
-          self
-        else
-          send_str ? send_and_wait(send_str, strregex, opts) : wait_for(strregex, opts)
-        end
-      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? ? 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)
+      # @return [Boolean] Is the shell open?
+      def open?
+        !closed? && @shell
       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 or a TimeoutError
-      # @raise Disconnected
-      # @raise ClosedChannel
-      # @raise TimeoutError
-      def wait_for(strregex, opts = { })
-        reconnect? ? open : raise(Disconnected) unless connected?
-        raise ClosedChannel if closed?
-        debug("wait_for(#{strregex.inspect}, #{opts})")
-        opts          = { :timeout => @timeout }.merge(opts)
-        found         = nil
-        f             = Fiber.current
-        trace         = caller
-        timer         = nil
-        data_callback = nil
-        matched       = false
-        started       = Time.new
-
-        timeout = proc do
-          data_callback && data_callback.cancel
-          f.resume(TimeoutError.new("#{host}: inactivity timeout (#{opts[:timeout]}) while waiting for #{strregex.inspect}; received: #{@buffer.inspect}; waited total: #{Time.new - started}"))
-        end
-
-        data_callback = on(:data) do
-          timer && timer.cancel
-          if matched
-            warn("data_callback invoked when already matched")
-            next
-          end
-          if (matched = @buffer.match(strregex))
-            data_callback.cancel
-            @buffer=matched.post_match
-            f.resume(matched.pre_match + matched.to_s)
-          else
-            timer = EM::Timer.new(opts[:timeout], &timeout)
-          end
-        end
-
-        # Check against current buffer
-        EM::next_tick {
-          data_callback.call() if @buffer.length>0
-        }
-
-        timer = EM::Timer.new(opts[:timeout], &timeout)
-        debug("set timer: #{timer} for #{opts[:timeout]}")
-        Fiber.yield.tap do |res|
-          if res.is_a?(Exception)
-            res.set_backtrace(Array(res.backtrace) + trace)
-            raise res
-          end
-          yield(res) if block_given?
-        end
-      end
-
-
       # Open a shell on the server.
       # You generally don't need to call this.
       # @return [self, Exception]
       def open(&blk)
-        debug("open(#{blk})")
-        f      = Fiber.current
-        trace  = caller
+        f       = Fiber.current
+        trace   = caller
+        on_open do |s|
+          Fiber.new { yield(self) if block_given? }.resume
+          f.resume(self)
+        end
+        open!
+        return Fiber.yield.tap { |r| raise r if r.is_a?(Exception) }
+      end
+
+      private
 
+      def open!
+        return if @opening
+        @opening = true
         begin
           connect
           session.open_channel do |channel|
@@ -250,32 +172,56 @@ module EventMachine
               debug "***** pty open: #{pty}; suc: #{suc}"
               pty.send_channel_request("shell") do |shell,success|
                 if !success
-                  f.resume(ConnectionError.new("Failed to create shell").tap{|e| e.set_backtrace(caller) })
+                  set_open_status(ConnectionError.new("Failed to create shell").tap{|e| e.set_backtrace(caller) })
                 else
                   debug "***** shell open: #{shell}"
                   @closed = false
                   @shell  = shell
-                  @shell.on_data do |ch,data|
-                    @buffer += data
-                    debug("data: #{@buffer.dump}")
-                    fire(:data, data)
-                  end
-                  Fiber.new { yield(self) if block_given? }.resume
-                  f.resume(self)
+                  shell.extend(EventMachine::Ssh::Connection::Channel::Interactive)
+                  shell.line_terminator = @line_terminator if @line_terminator
+                  shell.on(:data) { |data| debug("#{shell.dump_buffers}") }
+                  set_open_status(self)
                 end
+                @opening     = false
               end # |shell,success|
             end # |pty,suc|
           end # |channel|
         rescue => e
+          @opening = false
           raise ConnectionError.new("failed to create shell for #{host}: #{e} (#{e.class})")
         end
+      end
 
-        return Fiber.yield.tap { |r| raise r if r.is_a?(Exception) }
+      def on_open(&cb)
+        if open?
+          EM.next_tick { cb.call(@open_status) }
+        else
+          open_callbacks << cb
+        end
       end
 
-      # 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.
+      def open_callbacks
+        @open_callbacks ||= []
+      end
+
+      def set_open_status(status)
+        @open_status = status
+        open_callbacks.clone.each do |cb|
+          open_callbacks.delete(cb)
+          cb.call(status)
+        end
+        @open_status
+      end
+
+      public
+
+      # 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 call to split must be inside of a Fiber. The
+      # child will be closed after yielding. The block will not be yielded
+      # until the remote PTY has been opened.
+      #
       # @yield [Shell] child
       # @return [Shell] child
       def split
@@ -288,7 +234,13 @@ module EventMachine
           fire(:childless).tap{ info("fired :childless") } if children.empty?
         end
         fire(:split, child)
-        block_given? ? yield(child).tap { child.close } : child
+        if block_given?
+          # requires that the caller be in a Fiber
+          child.open rescue child.fail($!)
+          yield(child).tap { child.close }
+        else
+          child
+        end
       end
 
       # Connect to the server.
@@ -301,30 +253,84 @@ module EventMachine
         ::EM::Ssh.start(host, user, connect_opts) do |connection|
           @connection = connection
           connection.callback do |ssh|
-            f.resume(@session = ssh)
+            f.resume(@session = ssh) if f.alive?
           end
           connection.errback do |e|
             e.set_backtrace(trace + Array(e.backtrace))
-            f.resume(e)
+            f.resume(e) if f.alive?
           end
         end
         return Fiber.yield.tap { |r| raise r if r.is_a?(Exception) }
       end
 
+      # Ensure the channel is open of fail.
+      def assert_channel!
+        reconnect? ? open : raise(Disconnected) unless connected? && @shell
+        raise ClosedChannel if closed?
+      end
+      private :assert_channel!
+
+      # Wait for a number of seconds until a specified string or regexp is matched by the
+      # data returned from the ssh connection. Optionally send a given string first.
+      #
+      # If a block is not provided the current Fiber will yield until strregex matches or
+      # :timeout # is reached.
+      #
+      # If a block is provided expect will return immediately.
+      #
+      # @param [String, Regexp] strregex to match against
+      # @param [String] send_str the data to send before waiting
+      # @param [Hash] opts
+      # @option opts [Fixnum] :timeout (@timeout) number of seconds to wait when there is no activity
+      # @return [Shell, String] all data received up to an including strregex if a block is not provided.
+      #                         the Shell if a block is provided
+      # @example expect a prompt
+      #   expect(' ~]$ ')
+      # @example send a command and wait for a prompt
+      #   expect(' ~]$ ', '/sbin/ifconfig')
+      # @example expect a prompt and within 5 seconds
+      #   expect(' ~]$ ', :timeout => 5)
+      # @example send a command and wait up to 10 seconds for a prompt
+      #   expect(' ~]$ ', '/etc/sysconfig/openvpn restart', :timeout => 10)
+      def expect(strregex, send_str = nil, opts = {}, &blk)
+        assert_channel!
+        shell.expect(strregex,
+                     send_str,
+                     {:timeout => @timeout, :log => self }.merge(opts),
+                    &blk)
+      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 = {})
+        assert_channel!
+        shell.send_and_wait(send_str,
+                            wait_str,
+                            {:timeout => @timeout, :log => self }.merge(opts))
+      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, send_newline=true)
-        return unless shell
-        if send_newline
-          shell.send_data("#{d}#{line_terminator}")
-        else
-          shell.send_data("#{d}")
-        end
+        assert_channel!
+        shell.send_data(d, send_newline)
       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 or a TimeoutError
+      # @raise Disconnected
+      # @raise ClosedChannel
+      # @raise TimeoutError
+      def wait_for(strregex, opts = { })
+        assert_channel!
+        shell.wait_for(strregex, {:timeout => @timeout, :log => self }.merge(opts))
+      end
 
       def debug(msg = nil, &blk)
         super("#{host} #{msg}", &blk)
@@ -346,7 +352,6 @@ module EventMachine
         super("#{host} #{msg}", &blk)
       end
 
-
     private
     # TODO move private stuff down to private
     #      e.g., #open, #connect,

data/lib/em-ssh/version.rb

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

data/lib/em-ssh.rb

@@ -52,7 +52,7 @@ module EventMachine
       #      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})")
+        opts[:logger] || logger.debug("#{self}.connect(#{host}, #{user}, #{opts})")
         options = { :host => host, :user => user, :port => DEFAULT_PORT }.merge(opts)
         EM.connect(options[:host], options[:port], Connection, options, &blk)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-ssh
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-23 00:00:00.000000000 Z
+date: 2013-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -86,6 +86,8 @@ extra_rdoc_files: []
 files:
 - lib/em-ssh/authentication-session.rb
 - lib/em-ssh/callbacks.rb
+- lib/em-ssh/connection/channel/interactive.rb
+- lib/em-ssh/connection/channel/null-logger.rb
 - lib/em-ssh/connection.rb
 - lib/em-ssh/ext/net/ssh/connection/channel.rb
 - lib/em-ssh/log.rb
@@ -97,6 +99,7 @@ files:
 - lib/em-ssh.rb
 - bin/em-ssh
 - bin/em-ssh-shell
+- CHANGELOG.md
 - README.md
 homepage: http://github.com/simulacre/em-ssh
 licenses: