expect-behaviors 0.1.1

data/lib/expect/match.rb

@@ -0,0 +1,39 @@
+module Expect
+  class Match
+    attr_reader :buffer, :success
+
+    def initialize(expression, buffer)
+      @expression = expression
+      @buffer     = buffer
+      @matches    = @buffer.match(@expression)
+    end
+
+    def exact_match_string
+      @matches.nil? ? nil : @matches[0]
+    end
+
+    def expr_substring_to_match
+      Regexp.new(".*?#{@expression.source}", @expression.options | Regexp::MULTILINE)
+    end
+
+    def nil?
+      @matches.nil?
+    end
+
+    def substring_up_to_match
+      @matches.nil? ? nil : @buffer.match(expr_substring_to_match)[0]
+    end
+    alias_method :to_s, :substring_up_to_match
+
+    def substring_remainder
+      if @matches.nil?
+        @buffer
+      else
+        start_index = substring_up_to_match.length
+        @buffer[start_index..-1]
+      end
+    end
+    alias_method :remainder, :substring_remainder
+
+  end
+end

data/lib/expect/ssh.rb

@@ -0,0 +1,161 @@
+require 'net/ssh'
+require 'logger'
+require 'timeout'
+
+require 'expect/behavior'
+
+module Expect
+
+  ##
+  # An SSH Accessor with expect-like behaviors.  See also Expect::Behavior.
+  class SSH
+    include Expect::Behavior
+    # :Required methods to be created by the class mixing Expect::Behaviors :
+    #   #exp_process - should do one iteration of handle input and append buffer
+    #   #exp_buffer - provide the current buffer contents and empty it
+
+    attr_reader :auth_methods
+
+    def initialize(hostname, username,
+                   # keyword args follow
+                   port: 22,
+                   password: nil, # password for login
+                   ignore_known_hosts: false, # ignore host key mismatches?
+                   key_file: nil, # path to private key file
+                   logout_command: "exit", # command to exit/logout SSH session on remote host
+                   wait_interval_sec: 0.1, # process interval
+                   log_level: Logger::WARN)
+      @hostname = hostname
+      @username = username
+      @port = port
+      @password = password
+      @ignore_known_hosts = ignore_known_hosts
+      @key_file = key_file
+      @logout_command = logout_command
+      @wait_interval_sec = wait_interval_sec
+      @auth_methods = ['none', 'publickey', 'password']
+      @ssh = nil
+      @logger = Logger.new($stdout)
+      @logger.level = log_level if log_level
+      @receive_buffer = ''
+    end
+
+    ##
+    # Transmit the contents of +command+ using the SSH @channel
+    def send_data(command)
+      @logger.debug("[Expect::SSH##{__method__}] [@hostname=#{@hostname}] [command=#{command}]")
+      command += "\n" unless command.end_with?("\n")
+      @channel.send_data(command)
+    end
+
+    ##
+    # Initiate SSH connection
+    def start
+      $stdout.puts(
+          "[Expect::SSH##{__method__}] [@hostname=#{@hostname}] [@username=#{@username}] [options=#{options}]"
+      )
+      @ssh = Net::SSH.start(@hostname, @username, options)
+      raise(RuntimeError, "[Expect::SSH##{__method__}]: SSH Start Failed") unless @ssh
+      @channel = request_channel_pty_shell
+    end
+
+    ##
+    # Close SSH connection
+    def stop
+      @logger.debug("[Expect::SSH##{__method__}]: Closing Channel")
+      @channel.send_data(@logout_command + "\n")
+      @channel.close
+      begin
+        # A net-ssh quirk is that if you send a graceful close but you don't send an exit, it'll hang forever
+        # ...see also: http://stackoverflow.com/questions/25576454/ruby-net-ssh-script-not-closing
+        # I send an exit but just in case, also force the shutdown if it doesn't happen in 1 second.  #NotPatient
+        Timeout::timeout(1) do
+          @logger.debug("[Expect::SSH##{__method__}]: Closing Session")
+          @ssh.close
+        end
+      rescue Timeout::Error
+        @logger.debug("[Expect::SSH##{__method__}]: FORCE Closing Session")
+        @ssh.shutdown!
+      end
+    end
+
+    ##
+    # exp_buffer - provide the current buffer contents and empty it
+    def exp_buffer
+      result = @receive_buffer
+      @receive_buffer = ''
+      result
+    end
+
+    ##
+    # exp_process - should do one iteration of handle input and append buffer
+    def exp_process
+      sleep(@wait_sec.to_f)
+      @ssh.process(0)
+    end
+
+    ################
+    private
+    ################
+
+    ##
+    # Sets up the channel, pty, and shell.
+    # Configures callbacks for handling incoming data.
+    def request_channel_pty_shell
+      channel = @ssh.open_channel do |channel|
+        request_pty(channel)
+        request_shell(channel)
+        register_callbacks(channel)
+      end
+      @logger.debug("[Expect::SSH##{__method__}] complete")
+      channel
+    end
+
+    def request_pty(channel)
+      @logger.debug("[Expect::SSH##{__method__}]: Requesting PTY")
+      channel.request_pty do |_ch, success|
+        raise(RuntimeError, "[Expect::SSH##{__method__}]: Unable to get PTY") unless success
+      end
+    end
+
+    def request_shell(channel)
+      @logger.debug("[Expect::SSH##{__method__}]: Requesting Shell")
+      channel.send_channel_request("shell") do |_ch, success|
+        raise(RuntimeError, "[Expect::SSH##{__method__}]: Unable to get SHELL") unless success
+      end
+    end
+
+    def register_callbacks(channel)
+      @logger.debug("[Expect::SSH##{__method__}]: Registering Callbacks")
+      channel.on_data do |_ch, data|
+        @logger.debug("[Expect::SSH] [on_data=#{data}]")
+        @receive_buffer << data
+        false
+      end
+      channel.on_extended_data do |_ch, type, data|
+        @logger.debug("[Expect::SSH] [on_extended_data=#{data}]")
+        @receive_buffer << data if type == 1
+        false
+      end
+      channel.on_close do
+        @logger.debug("[Expect::SSH]: Close Channel")
+      end
+    end
+
+    ##
+    # Construct the options hash to feed Net::SSH
+    def options
+      override_options = {
+          :auth_methods => auth_methods,
+          :logger => @logger,
+          :port => @port,
+      }
+      override_options[:keys] = [@key_file] if @key_file
+      override_options[:user_known_hosts_file] = '/dev/null' if @ignore_known_hosts
+      override_options[:password] = @password if @password
+      Net::SSH.configuration_for(@host).merge(override_options)
+    end
+
+  end
+
+end

data/lib/expect/timeout_error.rb

@@ -0,0 +1,4 @@
+module Expect
+  class TimeoutError < StandardError
+  end
+end

data/tasks/doc.rake

@@ -0,0 +1,10 @@
+require 'rdoc/task'
+
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "expect-behaviors #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/tasks/jeweler.rake

@@ -0,0 +1,14 @@
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "expect-behaviors"
+  gem.homepage = "http://github.com/francisluong/expect-behaviors"
+  gem.license = "MIT"
+  gem.summary = %Q{Ruby Mixin to add Expect Behaviors}
+  gem.description = %Q{Ruby Mixin to add Expect Behaviors to SSH/Serial/Telnet controllers}
+  gem.email = "me@francisluong.com"
+  gem.authors = ["Francis Luong (Franco)"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new

data/tasks/test.rake

@@ -0,0 +1,32 @@
+require 'rake/testtask'
+
+
+namespace :test do
+
+  test_libs = {
+    :default => ['lib', 'test']
+  }
+
+  test_suites = [:unit, :acceptance]
+
+  task :all do
+    test_suites.each do |suite_sym|
+      test_name = "test:#{suite_sym}"
+      Rake::Task[test_name].invoke
+    end
+  end
+
+  test_suites.each do |subtest_sym|
+    Rake::TestTask.new(subtest_sym) do |test|
+      libs = test_libs[subtest_sym]
+      libs ||= test_libs[:default]
+      test.libs +=  libs
+      test.pattern = "test/#{subtest_sym.to_s}/**/test_*.rb"
+      test.verbose = true
+    end
+  end
+
+end
+
+desc "Run All Tests"
+task :test => 'test:all'

data/test/acceptance/sshd/erb/ssh_config.erb

@@ -0,0 +1,8 @@
+Port <%= @port %>
+AddressFamily inet
+IdentityFile <%= SSHD_CLIENT_KEY_PATH %>
+GlobalKnownHostsFile /dev/null
+GSSAPIAuthentication no
+KbdInteractiveAuthentication no
+PasswordAuthentication no
+StrictHostKeyChecking no

data/test/acceptance/sshd/erb/sshd_config.erb

@@ -0,0 +1,65 @@
+#	$OpenBSD: sshd_config,v 1.89 2013/02/06 00:20:42 dtucker Exp $
+
+# This is the sshd server system-wide configuration file.  See
+# sshd_config(5) for more information.
+
+# This sshd was compiled with PATH=/usr/bin:/bin:/usr/sbin:/sbin
+
+# The strategy used for options in the default sshd_config shipped with
+# OpenSSH is to specify options with their default value where
+# possible, but leave them commented.  Uncommented options override the
+# default value.
+
+# See sshd_config(5) for details on setting the Port and Listen values on Mac OS X
+Port <%= @port %>
+#AddressFamily any
+ListenAddress <%= @address %>
+#ListenAddress ::
+
+# The default requires explicit activation of protocol 1
+#Protocol 2
+
+HostKey <%= SSHD_RSA_HOST_KEY_PATH %>
+HostKey <%= SSHD_DSA_HOST_KEY_PATH %>
+
+# Lifetime and size of ephemeral version 1 server key
+#KeyRegenerationInterval 1h
+#ServerKeyBits 1024
+
+# Logging
+# obsoletes QuietMode and FascistLogging
+SyslogFacility AUTHPRIV
+#LogLevel INFO
+
+# Authentication:
+
+#LoginGraceTime 2m
+#PermitRootLogin yes
+#StrictModes yes
+#MaxAuthTries 6
+#MaxSessions 10
+
+#RSAAuthentication yes
+PubkeyAuthentication yes
+
+# The default is to check both .ssh/authorized_keys and .ssh/authorized_keys2
+# but this is overridden so installations will only check .ssh/authorized_keys
+AuthorizedKeysFile	<%= SSHD_AUTHORIZED_KEYS_PATH %>
+
+
+#AuthorizedPrincipalsFile none
+
+#AuthorizedKeysCommand none
+#AuthorizedKeysCommandUser nobody
+
+# For this to work you will also need host keys in /etc/ssh/ssh_known_hosts
+#RhostsRSAAuthentication no
+# similar for protocol version 2
+#HostbasedAuthentication no
+# Change to yes if you don't trust ~/.ssh/known_hosts for
+# RhostsRSAAuthentication and HostbasedAuthentication
+#IgnoreUserKnownHosts no
+# Don't read the user's ~/.rhosts and ~/.shosts files
+#IgnoreRhosts yes
+
+PidFile	<%= PIDFILE_PATH %>

data/test/acceptance/test_expect_behaviors_slow_tests.rb

@@ -0,0 +1,109 @@
+require 'helper'
+require 'expect/behavior'
+require 'class_including_expect_behavior'
+gem 'mocha'
+require 'mocha/test_unit'
+
+class TestExpectBehaviorsSlowTests < Test::Unit::TestCase
+
+  ####################################
+  context "expect" do
+    setup do
+      @values = []
+      @values << "the sun is a mass"
+      @values << "\nof incandescent gas"
+      @values << "\nswitch-prompt#"
+      @values << "\nblip blip"
+      @values << "\nblah blah"
+      @values << "\nswitch-prompt2#"
+      @includer = ClassIncludingExpectBehavior.new(values: @values)
+      @wait_sec = 0.5
+    end
+
+    should "not timeout for switch-prompt2# if expect_continue for blip" do
+      @includer.wait_sec = @wait_sec * 1
+      result = @includer.expect do
+        when_matching(/switch-prompt2#/) do
+          @exp_match
+        end
+        when_matching(/blip/) do
+          exp_continue
+        end
+        when_timeout(@wait_sec * 4) do
+          "timed out"
+        end
+      end
+      expected = "the sun is a mass\nof incandescent gas\nswitch-prompt#\nblip blip\nblah blah\nswitch-prompt2#"
+      assert_equal(expected, result.to_s)
+    end
+
+    should "timeout for switch-prompt2# if expect_continue for incandescent" do
+      @includer.wait_sec = @wait_sec * 1
+      result = @includer.expect do
+        when_matching(/switch-prompt2#/) do
+          @exp_match
+        end
+        when_matching(/incandescent/) do
+          exp_continue
+        end
+        when_timeout(@wait_sec * 3) do
+          "timed out"
+        end
+      end
+      expected = "timed out"
+      assert_equal(expected, result.to_s)
+    end
+
+  end
+
+
+  ####################################
+  context "timeout" do
+    setup do
+      @wait_sec = 0.5
+      @includer = ClassIncludingExpectBehavior.new(wait: @wait_sec * 2)
+    end
+
+    should "raise TimeoutError when timeout is reached before match is found" do
+      @includer.exp_timeout_sec = 1
+      assert_raises(Expect::TimeoutError) do
+        @includer.expect do
+          when_matching(/bob/) do
+            return_value
+          end
+        end
+      end
+    end
+
+    should "execute arbitrary block on timeout with override" do
+      result = @includer.expect do
+        when_matching(/bob/) do
+          return_value
+        end
+        when_timeout(@wait_sec * 1) do
+          "timeout"
+        end
+      end
+      assert_equal('timeout', result)
+    end
+
+    should "revert to previous timeout after an expect block" do
+      assert_equal(nil, @includer.instance_variable_get(:@exp_timeout_sec))
+      result = @includer.expect do
+        when_matching(/bob/) { @exp_match }
+        when_timeout(1) { "timeout" }
+      end
+      assert_equal('timeout', result)
+      assert_equal(10, @includer.instance_variable_get(:@exp_timeout_sec))
+      @includer.exp_timeout_sec = 2
+      assert_equal(2, @includer.instance_variable_get(:@exp_timeout_sec))
+      result = @includer.expect do
+        when_matching(/bob/) { @exp_match }
+        when_timeout(1) { "timeout" }
+      end
+      assert_equal('timeout', result)
+      assert_equal(2, @includer.instance_variable_get(:@exp_timeout_sec))
+    end
+  end
+
+end