sshkit 1.7.1 → 1.8.0

data/lib/sshkit/formatters/simple_text.rb

@@ -1,54 +1,16 @@
-
 module SSHKit
 
   module Formatter
 
-    class SimpleText < Abstract
-
-      def write(obj)
-        return if obj.verbosity < SSHKit.config.output_verbosity
-        case obj
-        when SSHKit::Command    then write_command(obj)
-        when SSHKit::LogMessage then write_log_message(obj)
-        else
-          original_output << "Output formatter doesn't know how to handle #{obj.class}\n"
-        end
-      end
-      alias :<< :write
-
-      private
-
-      def write_command(command)
-        unless command.started?
-          original_output << "Running #{String(command)} #{command.host.user ? "as #{command.host.user}@" : "on "}#{command.host}\n"
-          if SSHKit.config.output_verbosity == Logger::DEBUG
-            original_output << "Command: #{command.to_command}" + "\n"
-          end
-        end
-
-        if SSHKit.config.output_verbosity == Logger::DEBUG
-          unless command.stdout.empty?
-            command.stdout.lines.each do |line|
-              original_output << "\t" + line
-              original_output << "\n" unless line[-1] == "\n"
-            end
-          end
-
-          unless command.stderr.empty?
-            command.stderr.lines.each do |line|
-              original_output << "\t" + line
-              original_output << "\n" unless line[-1] == "\n"
-            end
-          end
-        end
+    class SimpleText < Pretty
 
-        if command.finished?
-          original_output << "Finished in #{sprintf('%5.3f seconds', command.runtime)} with exit status #{command.exit_status} (#{ command.failure? ? 'failed' : 'successful' }).\n"
-        end
+      # Historically, SimpleText formatter was used to disable coloring, so we maintain that behaviour
+      def colorize(obj, _color, _mode=nil)
+        obj.to_s
       end
 
-      def write_log_message(log_message)
-        original_output << log_message.to_s + "\n"
+      def format_message(_verbosity, message, _uuid=nil)
+        message
       end
 
     end

data/lib/sshkit/host.rb

@@ -1,5 +1,4 @@
 require 'ostruct'
-require 'etc'
 
 module SSHKit
 
@@ -26,7 +25,7 @@ module SSHKit
       if host_string_or_options_hash == :local
         @local = true
         @hostname = "localhost"
-        @user = Etc.getpwuid.name
+        @user = ENV['USER'] || ENV['LOGNAME'] || ENV['USERNAME']
       elsif !host_string_or_options_hash.is_a?(Hash)
         suitable_parsers = [
           SimpleHostParser,
@@ -100,7 +99,7 @@ module SSHKit
   class SimpleHostParser
 
     def self.suitable?(host_string)
-      !host_string.match /[:|@]/
+      !host_string.match(/[:|@]/)
     end
 
     def initialize(host_string)
@@ -128,7 +127,7 @@ module SSHKit
   class HostWithPortParser < SimpleHostParser
 
     def self.suitable?(host_string)
-      !host_string.match /[@|\[|\]]/
+      !host_string.match(/[@|\[|\]]/)
     end
 
     def port
@@ -145,7 +144,7 @@ module SSHKit
   # :nodoc:
   class HostWithUsernameAndPortParser < SimpleHostParser
     def self.suitable?(host_string)
-      host_string.match /@.*:\d+/
+      host_string.match(/@.*:\d+/)
     end
     def username
       @host_string.split(/:|@/)[0]
@@ -163,7 +162,7 @@ module SSHKit
   class IPv6HostWithPortParser < SimpleHostParser
 
     def self.suitable?(host_string)
-      host_string.match /[a-fA-F0-9:]+:\d+/
+      host_string.match(/[a-fA-F0-9:]+:\d+/)
     end
 
     def port

data/lib/sshkit/logger.rb

@@ -1,6 +1,5 @@
 module SSHKit
   class Logger
-    TRACE = -1
     DEBUG = 0
     INFO  = 1
     WARN  = 2

data/lib/sshkit/mapping_interaction_handler.rb

@@ -0,0 +1,47 @@
+module SSHKit
+
+  class MappingInteractionHandler
+
+    def initialize(mapping, log_level=nil)
+      @log_level = log_level
+      @mapping_proc = case mapping
+        when Hash
+          lambda do |server_output|
+            first_matching_key_value = mapping.find { |k, _v| k === server_output }
+            first_matching_key_value.nil? ? nil : first_matching_key_value.last
+          end
+        when Proc
+          mapping
+        else
+          raise "Unsupported mapping type: #{mapping.class} - only Hash and Proc mappings are supported"
+      end
+    end
+
+    def on_data(_command, stream_name, data, channel)
+      log("Looking up response for #{stream_name} message #{data.inspect}")
+
+      response_data = @mapping_proc.call(data)
+
+      if response_data.nil?
+        log("Unable to find interaction handler mapping for #{stream_name}: #{data.inspect} so no response was sent")
+      else
+        log("Sending #{response_data.inspect}")
+        if channel.respond_to?(:send_data) # Net SSH Channel
+          channel.send_data(response_data)
+        elsif channel.respond_to?(:write) # Local IO
+          channel.write(response_data)
+        else
+          raise "Unable to write response data to channel #{channel.inspect} - does not support 'send_data' or 'write'"
+        end
+      end
+    end
+
+    private
+
+    def log(message)
+      SSHKit.config.output.send(@log_level, message) unless @log_level.nil?
+    end
+
+  end
+
+end

data/lib/sshkit/runners/parallel.rb

@@ -11,7 +11,7 @@ module SSHKit
           threads << Thread.new(host) do |h|
             begin
               backend(h, &block).run
-            rescue Exception => e
+            rescue StandardError => e
               e2 = ExecuteError.new e
               raise e2, "Exception while executing #{host.user ? "as #{host.user}@" : "on host "}#{host}: #{e.message}"
             end

data/lib/sshkit/runners/sequential.rb

@@ -19,7 +19,7 @@ module SSHKit
       private
       def run_backend(host, &block)
         backend(host, &block).run
-      rescue Exception => e
+      rescue StandardError => e
         e2 = ExecuteError.new e
         raise e2, "Exception while executing #{host.user ? "as #{host.user}@" : "on host "}#{host}: #{e.message}"
       end

data/lib/sshkit/version.rb

@@ -1,3 +1,3 @@
 module SSHKit
-  VERSION = "1.7.1"
+  VERSION = "1.8.0"
 end

data/sshkit.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency('net-ssh',  '>= 2.8.0')
   gem.add_runtime_dependency('net-scp',  '>= 1.1.2')
-  gem.add_runtime_dependency('colorize', '>= 0.7.0')
 
   gem.add_development_dependency('minitest', ['>= 2.11.3', '< 2.12.0'])
   gem.add_development_dependency('rake')

data/test/functional/backends/test_local.rb

@@ -6,13 +6,14 @@ module SSHKit
     class TestLocal < MiniTest::Unit::TestCase
 
       def setup
+        super
         SSHKit.config.output = SSHKit::Formatter::BlackHole.new($stdout)
       end
 
       def test_capture
         captured_command_result = ''
         Local.new do
-          captured_command_result = capture(:echo, 'foo')
+          captured_command_result = capture(:echo, 'foo', strip: false)
         end.run
         assert_equal "foo\n", captured_command_result
       end
@@ -35,6 +36,18 @@ module SSHKit
         assert_equal true,  succeeded_test_result
         assert_equal false, failed_test_result
       end
+
+      def test_interaction_handler
+        captured_command_result = nil
+        Local.new do
+          command = 'echo Enter Data; read the_data; echo Captured $the_data;'
+          captured_command_result = capture(command, interaction_handler: {
+            "Enter Data\n" => "SOME DATA\n",
+            "Captured SOME DATA\n" => nil
+          })
+        end.run
+        assert_equal("Enter Data\nCaptured SOME DATA", captured_command_result)
+      end
     end
   end
 end

data/test/functional/backends/test_netssh.rb

@@ -10,59 +10,45 @@ module SSHKit
 
       def setup
         super
-        SSHKit.config.output = SSHKit::Formatter::BlackHole.new($stdout)
-      end
-
-      def block_to_run
-        lambda do |host|
-          execute 'date'
-          execute :ls, '-l', '/some/directory'
-          with rails_env: :production do
-            within '/tmp' do
-              as :root do
-                execute :touch, 'restart.txt'
-              end
-            end
-          end
-        end
+        @output = String.new
+        SSHKit.config.output_verbosity = :debug
+        SSHKit.config.output = SSHKit::Formatter::SimpleText.new(@output)
       end
 
       def a_host
         VagrantWrapper.hosts['one']
       end
 
-      def printer
-        Netssh.new(a_host, &block_to_run)
-      end
+      def test_simple_netssh
+        Netssh.new(a_host) do
+          execute 'date'
+          execute :ls, '-l'
+          with rails_env: :production do
+           within '/tmp' do
+             as :root do
+               execute :touch, 'restart.txt'
+             end
+           end
+          end
+        end.run
 
-      def simple_netssh
-        SSHKit.capture_output(sio) do
-          printer.run
-        end
-        sio.rewind
-        result = sio.read
-        assert_equal <<-EOEXPECTED.unindent, result
-          if test ! -d /opt/sites/example.com; then echo "Directory does not exist '/opt/sites/example.com'" 2>&1; false; fi
-          cd /opt/sites/example.com && /usr/bin/env date
-          cd /opt/sites/example.com && /usr/bin/env ls -l /some/directory
-          if test ! -d /opt/sites/example.com/tmp; then echo "Directory does not exist '/opt/sites/example.com/tmp'" 2>&1; false; fi
-          if ! sudo su -u root whoami > /dev/null; then echo "You cannot switch to user 'root' using sudo, please check the sudoers file" 2>&1; false; fi
-          cd /opt/sites/example.com/tmp && ( RAILS_ENV=production ( sudo su -u root /usr/bin/env touch restart.txt ) )
+        command_lines = @output.lines.select { |line| line.start_with?('Command:') }
+        assert_equal <<-EOEXPECTED.unindent, command_lines.join
+          Command: /usr/bin/env date
+          Command: /usr/bin/env ls -l
+          Command: if test ! -d /tmp; then echo \"Directory does not exist '/tmp'\" 1>&2; false; fi
+          Command: if ! sudo -u root whoami > /dev/null; then echo \"You cannot switch to user 'root' using sudo, please check the sudoers file\" 1>&2; false; fi
+          Command: cd /tmp && ( export RAILS_ENV="production" ; sudo -u root RAILS_ENV="production" -- sh -c '/usr/bin/env touch restart.txt' )
         EOEXPECTED
       end
 
       def test_capture
-        File.open('/dev/null', 'w') do |dnull|
-          SSHKit.capture_output(dnull) do
-            captured_command_result = nil
-            Netssh.new(a_host) do |host|
-              captured_command_result = capture(:uname)
-            end.run
-
-            assert captured_command_result
-            assert_match captured_command_result, /Linux|Darwin/
-          end
-        end
+        captured_command_result = nil
+        Netssh.new(a_host) do |_host|
+          captured_command_result = capture(:uname)
+        end.run
+
+        assert_includes %W(Linux Darwin), captured_command_result
       end
 
       def test_ssh_option_merge
@@ -76,9 +62,19 @@ module SSHKit
         assert_equal({ forward_agent: false, paranoid: true }, host_ssh_options)
       end
 
+      def test_env_vars_substituion_in_subshell
+        captured_command_result = nil
+        Netssh.new(a_host) do |_host|
+          with some_env_var: :some_value do
+           captured_command_result = capture(:echo, '$SOME_ENV_VAR')
+          end
+        end.run
+        assert_equal "some_value", captured_command_result
+      end
+
       def test_execute_raises_on_non_zero_exit_status_and_captures_stdout_and_stderr
         err = assert_raises SSHKit::Command::Failed do
-          Netssh.new(a_host) do |host|
+          Netssh.new(a_host) do |_host|
             execute :echo, "'Test capturing stderr' 1>&2; false"
           end.run
         end
@@ -86,27 +82,27 @@ module SSHKit
       end
 
       def test_test_does_not_raise_on_non_zero_exit_status
-        Netssh.new(a_host) do |host|
+        Netssh.new(a_host) do |_host|
           test :false
         end.run
       end
 
-      def test_upload_file
-        file_contents = ""
+      def test_upload_and_then_capture_file_contents
+        actual_file_contents = ""
         file_name = File.join("/tmp", SecureRandom.uuid)
         File.open file_name, 'w+' do |f|
-          f.write 'example_file'
+          f.write "Some Content\nWith a newline and trailing spaces    \n "
         end
         Netssh.new(a_host) do
           upload!(file_name, file_name)
-          file_contents = capture(:cat, file_name)
+          actual_file_contents = capture(:cat, file_name, strip: false)
         end.run
-        assert_equal "example_file", file_contents
+        assert_equal "Some Content\nWith a newline and trailing spaces    \n ", actual_file_contents
       end
 
       def test_upload_string_io
         file_contents = ""
-        Netssh.new(a_host) do |host|
+        Netssh.new(a_host) do |_host|
           file_name = File.join("/tmp", SecureRandom.uuid)
           upload!(StringIO.new('example_io'), file_name)
           file_contents = download!(file_name)
@@ -128,6 +124,18 @@ module SSHKit
         end.run
         assert_equal File.open(file_name).read, file_contents
       end
+
+      def test_interaction_handler
+        captured_command_result = nil
+        Netssh.new(a_host) do
+          command = 'echo Enter Data; read the_data; echo Captured $the_data;'
+          captured_command_result = capture(command, interaction_handler: {
+            "Enter Data\n" => "SOME DATA\n",
+            "Captured SOME DATA\n" => nil
+          })
+        end.run
+        assert_equal("Enter Data\nCaptured SOME DATA", captured_command_result)
+      end
     end
 
   end

data/test/helper.rb

@@ -40,7 +40,7 @@ class FunctionalTest < MiniTest::Unit::TestCase
   def create_user_with_key(username, password = :secret)
     username, password = username.to_s, password.to_s
 
-    keys = VagrantWrapper.hosts.collect do |name, host|
+    keys = VagrantWrapper.hosts.collect do |_name, host|
       Net::SSH.start(host.hostname, host.user, port: host.port, password: host.password) do |ssh|
 
         # Remove the user, make it again, force-generate a key for him
@@ -70,7 +70,7 @@ class FunctionalTest < MiniTest::Unit::TestCase
       end
     end
 
-    Hash[VagrantWrapper.hosts.collect { |n, h| n.to_sym }.zip(keys)]
+    Hash[VagrantWrapper.hosts.collect { |n, _h| n.to_sym }.zip(keys)]
   end
 
 end

data/test/unit/backends/test_abstract.rb

@@ -0,0 +1,145 @@
+require 'helper'
+
+module SSHKit
+
+  module Backend
+
+    class TestAbstract < UnitTest
+
+      def test_make
+        backend = ExampleBackend.new do
+          make %w(some command)
+        end
+
+        backend.run
+
+        assert_equal '/usr/bin/env make some command', backend.executed_command.to_command
+      end
+
+      def test_rake
+        backend = ExampleBackend.new do
+          rake %w(a command)
+        end
+
+        backend.run
+
+        assert_equal '/usr/bin/env rake a command', backend.executed_command.to_command
+      end
+
+      def test_execute_creates_and_executes_command_with_default_options
+        backend = ExampleBackend.new do
+          execute :ls, '-l', '/some/directory'
+        end
+
+        backend.run
+
+        assert_equal '/usr/bin/env ls -l /some/directory', backend.executed_command.to_command
+        assert_equal(
+          {:raise_on_non_zero_exit=>true, :run_in_background=>false, :in=>nil, :env=>nil, :host=>ExampleBackend.example_host, :user=>nil, :group=>nil},
+          backend.executed_command.options
+        )
+      end
+
+      def test_test_method_creates_and_executes_command_with_false_raise_on_non_zero_exit
+        backend = ExampleBackend.new do
+          test '[ -d /some/file ]'
+        end
+
+        backend.run
+
+        assert_equal '[ -d /some/file ]', backend.executed_command.to_command
+        assert_equal false, backend.executed_command.options[:raise_on_non_zero_exit], 'raise_on_non_zero_exit option'
+      end
+
+      def test_capture_creates_and_executes_command_and_returns_stripped_output
+        output = nil
+        backend = ExampleBackend.new do
+          output = capture :cat, '/a/file'
+        end
+        backend.full_stdout = "Some stdout\n     "
+
+        backend.run
+
+        assert_equal '/usr/bin/env cat /a/file', backend.executed_command.to_command
+        assert_equal 'Some stdout', output
+      end
+
+      def test_capture_supports_disabling_strip
+        output = nil
+        backend = ExampleBackend.new do
+          output = capture :cat, '/a/file', :strip => false
+        end
+        backend.full_stdout = "Some stdout\n     "
+
+        backend.run
+
+        assert_equal '/usr/bin/env cat /a/file', backend.executed_command.to_command
+        assert_equal "Some stdout\n     ", output
+      end
+
+      def test_background_logs_deprecation_warnings
+        deprecation_out = ''
+        SSHKit.config.deprecation_output = deprecation_out
+
+        ExampleBackend.new do
+          background :ls
+        end.run
+
+        lines = deprecation_out.lines.to_a
+
+        assert_equal 2, lines.length
+
+        assert_equal("[Deprecated] The background method is deprecated. Blame badly behaved pseudo-daemons!\n", lines[0])
+        assert_match(/    \(Called from.*test_abstract.rb:\d+:in `block in test_background_logs_deprecation_warnings'\)\n/, lines[1])
+      end
+
+      def test_calling_abstract_with_undefined_execute_command_raises_exception
+        abstract =  Abstract.new(ExampleBackend.example_host) do
+          execute(:some_command)
+        end
+
+        assert_raises(SSHKit::Backend::MethodUnavailableError) do
+          abstract.run
+        end
+      end
+
+      def test_abstract_backend_can_be_configured
+        Abstract.configure do |config|
+          config.some_option = 100
+        end
+
+        assert_equal 100, Abstract.config.some_option
+      end
+
+      def test_invoke_raises_no_method_error
+        assert_raises NoMethodError do
+          ExampleBackend.new.invoke :echo
+        end
+      end
+
+      # Use a concrete ExampleBackend rather than a mock for improved assertion granularity
+      class ExampleBackend < Abstract
+        attr_writer :full_stdout
+        attr_reader :executed_command
+
+        def initialize(&block)
+          block = block.nil? ? lambda {} : block
+          super(ExampleBackend.example_host, &block)
+        end
+
+        def execute_command(command)
+          @executed_command = command
+          command.on_stdout(nil, @full_stdout) unless @full_stdout.nil?
+        end
+
+        def ExampleBackend.example_host
+          Host.new(:'example.com')
+        end
+
+      end
+
+    end
+
+  end
+
+end