sshake 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 100663608c7ad37ad009f8e8390bb8529a310f67
-  data.tar.gz: 5941b458f2d5157b8e94affd1da506c9208d2a78
+SHA256:
+  metadata.gz: 708fa3da7960099e94421e102ad22c9b8243a586b5bc6b978b6a8083857f4a68
+  data.tar.gz: d6711b1debc1e0dacd0d1f0880e3508f3ce939e142036d647e6471ce920e2011
 SHA512:
-  metadata.gz: 373f8dfeffe16e7287d08566587c63ecbc58fe99749e5acc21b176bf13eac1964b933c24d14e7eff1fd8f66df41543a4a099ae7e45652c8f579cf709fc6bbf93
-  data.tar.gz: f0e6974235d398df3e19f8acc4cee2322148750f66f7591ff7a6de7b2afc44cc82c9ffa13726e9f424f352a8674cd10c8764d949d5e3cd1a2fd9080d924209d1
+  metadata.gz: 70f79029d3b42745a2661ea1627e3f8cd73201d50d6bf00abdb983e02663077fb3df4667ddc4d5dcf5920f4cfac2fb7b0927df7a7a8382a8354d65cd7f90c5ad
+  data.tar.gz: 60cdd9feff7600fecc5bec047eef5d7bd513baf9fcb4ba280b4c1f2e964e9e5e81c0a1828d7cfabe32c30216ea3b5893eb6cad4a1941fd7e21cffec6fa724a77

data/lib/sshake.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'sshake/session'
+require 'sshake/version'

data/lib/sshake/base_session.rb

@@ -0,0 +1,114 @@
+require 'securerandom'
+require 'sshake/logger'
+require 'sshake/execution_options'
+
+module SSHake
+  class BaseSession
+    # A logger for this session
+    #
+    # @return [Logger, nil]
+    attr_accessor :logger
+
+    # An ID for this session
+    #
+    # @return [String]
+    attr_reader :id
+
+    # Specify the default behaviour for raising erors
+    #
+    # @return [Boolean]
+    attr_accessor :raise_on_error
+
+    def initialize(*args)
+      @id = SecureRandom.hex(4)
+    end
+
+    # Connect to the SSH server
+    #
+    # @return [void]
+    def connect
+      raise "Override #connect in sub-sessions"
+    end
+
+    # Is there an established SSH connection
+    #
+    # @return [Boolean]
+    def connected?
+      raise "Override #connected? in sub-sessions"
+    end
+
+    # Disconnect the underlying SSH connection
+    #
+    # @return [void]
+    def disconnect
+      raise "Override #disconnect in sub-sessions"
+    end
+
+    # Kill the underlying connection
+    def kill!
+      raise "Override #kill! in sub-sessions"
+    end
+
+    # Execute a command
+    #
+    def execute(commands, options = nil, &block)
+      raise "Override #execute in sub-sessions"
+    end
+
+    def write_data(path, data, options = nil, &block)
+      raise "Override #write_data in sub-sessions"
+    end
+
+    private
+
+    def add_sudo_to_commands_array(commands, user)
+      commands.map do |command|
+        "sudo -u #{user} --stdin #{command}"
+      end
+    end
+
+    def create_options(hash, block)
+      if block && hash
+        raise Error, 'You cannot provide a block and options'
+      elsif block
+        ExecutionOptions.from_block(&block)
+      elsif hash.is_a?(Hash)
+        ExecutionOptions.from_hash(hash)
+      else
+        ExecutionOptions.new
+      end
+    end
+
+    def log(type, text, options = {})
+      logger = @logger || SSHake.logger
+      return unless logger
+
+      prefix = "[#{@id}] [#{@host}] "
+
+      text.split(/\n/).each do |line|
+        logger.send(type, prefix + line)
+      end
+    end
+
+    def prepare_commands(commands, execution_options, **options)
+      commands = [commands] unless commands.is_a?(Array)
+
+      # Map sudo onto command
+      if execution_options.sudo_user && options[:add_sudo] != false
+        commands = add_sudo_to_commands_array(commands, execution_options.sudo_user)
+      end
+
+      # Construct a full command string to execute
+      commands.join(' && ')
+    end
+
+    def handle_response(response, options)
+      if !response.success? && ((options.raise_on_error.nil? && @raise_on_error) || options.raise_on_error?)
+        raise ExecutionError, response
+      else
+        response
+      end
+    end
+
+  end
+end

data/lib/sshake/error.rb

@@ -6,7 +6,7 @@ module SSHake
 
   class ExecutionError < Error
     def initialize(response)
-      response
+      @response = response
     end
 
     attr_reader :response

data/lib/sshake/execution_options.rb

@@ -41,6 +41,12 @@ module SSHake
     # @return [Proc]
     attr_accessor :stderr
 
+    # A file that you wish to stream to the remote channel
+    # with the current commend
+    #
+    # @return [File]
+    attr_accessor :file_to_stream
+
     # Should errors be raised
     #
     # @return [Boolean]
@@ -76,6 +82,7 @@ module SSHake
         options.stdin = hash[:stdin]
         options.stdout = hash[:stdout]
         options.stderr = hash[:stderr]
+        options.file_to_stream = hash[:file_to_stream]
         options
       end
 

data/lib/sshake/execution_options_dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SSHake
   class ExecutionOptionsDSL
     def initialize(options)
@@ -13,8 +15,12 @@ module SSHake
       @options.sudo_password = options[:password]
     end
 
-    def raise_on_error
-      @options.raise_on_error = true
+    def raise_on_error(bool = true)
+      @options.raise_on_error = bool
+    end
+
+    def dont_raise_on_error
+      @options.raise_on_error = false
     end
 
     def stdin(value)
@@ -28,5 +34,9 @@ module SSHake
     def stderr(&block)
       @options.stderr = block
     end
+
+    def file_to_stream(file)
+      @options.file_to_stream = file
+    end
   end
 end

data/lib/sshake/mock/command.rb

@@ -0,0 +1,36 @@
+require 'sshake/response'
+
+module SSHake
+  module Mock
+    class Command
+
+      def initialize(matcher, &block)
+        @matcher = matcher
+        @block = block
+      end
+
+      def match(command)
+        command = command.to_s
+        case @matcher
+        when String
+          @matcher == command ? [] : nil
+        when Regexp
+          if match = command.match(/\A#{@matcher}\z/)
+            match.captures
+          end
+        end
+      end
+
+      def make_response(environment)
+        response = SSHake::Response.new
+        response.start_time = Time.now
+        if @block
+          @block.call(response, environment)
+        end
+        response.finish_time = Time.now
+        response
+      end
+
+    end
+  end
+end

data/lib/sshake/mock/command_set.rb

@@ -0,0 +1,28 @@
+require 'sshake/mock/command'
+
+module SSHake
+  module Mock
+    class CommandSet
+
+      def initialize
+        @commands = []
+      end
+
+      def add(matcher, &block)
+        command = Command.new(matcher, &block)
+        @commands << command
+        command
+      end
+
+      def match(given_command)
+        @commands.each do |command|
+          if matches = command.match(given_command)
+            return [command, matches]
+          end
+        end
+        nil
+      end
+
+    end
+  end
+end

data/lib/sshake/mock/environment.rb

@@ -0,0 +1,24 @@
+module SSHake
+  module Mock
+    class Environment
+
+      def initialize(session)
+        @session = session
+        @captures = []
+      end
+
+      attr_accessor :command
+      attr_accessor :options
+      attr_accessor :captures
+
+      def store
+        @session ? @session.store : nil
+      end
+
+      def written_files
+        @session ? @session.written_files : nil
+      end
+
+    end
+  end
+end

data/lib/sshake/mock/executed_command.rb

@@ -0,0 +1,17 @@
+module SSHake
+  module Mock
+    class ExecutedCommand
+
+      attr_reader :command
+      attr_reader :environment
+      attr_reader :response
+
+      def initialize(command, environment, response)
+        @command = command
+        @environment = environment
+        @response = response
+      end
+
+    end
+  end
+end

data/lib/sshake/mock/session.rb

@@ -0,0 +1,101 @@
+require 'net/ssh/errors'
+require 'sshake/base_session'
+require 'sshake/mock/command_set'
+require 'sshake/mock/environment'
+require 'sshake/mock/unsupported_command_error'
+require 'sshake/mock/executed_command'
+
+module SSHake
+  module Mock
+    class Session < BaseSession
+
+      attr_reader :command_set
+      attr_reader :store
+      attr_reader :written_files
+      attr_reader :executed_commands
+
+      def initialize(**options)
+        @options = options
+        @command_set = options[:command_set] || CommandSet.new
+        @executed_commands = []
+        @store = {}
+        @written_files = {}
+        @connected = false
+        yield(self) if block_given?
+      end
+
+      def connect
+        case @options[:connection_error]
+        when :timeout
+          raise Net::SSH::ConnectionTimeout
+        when :authentication_failed
+          raise Net::SSH::AuthenticationFailed
+        when :connection_refused
+          raise Errno::ECONNREFUSED
+        when :host_unreachable
+          raise Errno::EHOSTUNREACH
+        else
+          @connected = true
+        end
+      end
+
+      def connected?
+        @connected == true
+      end
+
+      def disconnect
+        @connected = false
+      end
+
+      def kill!
+        disconnect
+      end
+
+      def execute(commands, options = nil, &block)
+        connect unless connected?
+
+        environment = Environment.new(self)
+
+        environment.options = create_options(options, block)
+        environment.command = prepare_commands(commands, environment.options, :add_sudo => false)
+
+        command, environment.captures = @command_set.match(environment.command)
+
+        if command.nil?
+          raise UnsupportedCommandError.new(environment.command)
+        end
+
+        response = command.make_response(environment)
+
+        if environment.options.file_to_stream
+          response.bytes_streamed = environment.options.file_to_stream.size
+        end
+
+        @executed_commands << ExecutedCommand.new(command, environment, response)
+        handle_response(response, environment.options)
+      end
+
+      def write_data(path, data, options = nil, &block)
+        connect unless connected?
+        @written_files[path] = data
+        true
+      end
+
+      def find_executed_commands(matcher)
+        if matcher.is_a?(Regexp)
+          matcher = /\A#{matcher}\z/
+        else
+          matcher = /\A#{Regexp.escape(matcher.to_s)}\z/
+        end
+        @executed_commands.select do |command|
+          command.environment.command =~ matcher
+        end
+      end
+
+      def has_executed_command?(matcher)
+        find_executed_commands(matcher).size > 0
+      end
+
+    end
+  end
+end

data/lib/sshake/mock/unsupported_command_error.rb

@@ -0,0 +1,17 @@
+require 'sshake/error'
+
+module SSHake
+  module Mock
+    class UnsupportedCommandError < Error
+
+      def initialize(command)
+        @command = command
+      end
+
+      def to_s
+        "Executed command is not support by the mock session (`#{@command}`)"
+      end
+
+    end
+  end
+end

data/lib/sshake/response.rb

@@ -5,6 +5,8 @@ module SSHake
     def initialize
       @stdout = ''
       @stderr = ''
+      @exit_code = 0
+      @bytes_streamed = 0
     end
 
     attr_accessor :command
@@ -14,6 +16,7 @@ module SSHake
     attr_accessor :exit_signal
     attr_accessor :start_time
     attr_accessor :finish_time
+    attr_accessor :bytes_streamed
 
     def success?
       @exit_code == 0
@@ -26,5 +29,9 @@ module SSHake
     def timeout?
       @exit_code == -255
     end
+
+    def timeout!
+      @exit_code = -255
+    end
   end
 end

data/lib/sshake/session.rb

@@ -4,26 +4,21 @@ require 'net/ssh'
 require 'net/sftp'
 require 'timeout'
 require 'sshake/error'
-require 'sshake/logger'
 require 'sshake/response'
-require 'sshake/execution_options'
+require 'sshake/base_session'
 
 module SSHake
-  class Session
+  class Session < BaseSession
     # The underlying net/ssh session
     #
     # @return [Net::SSH::Session]
     attr_reader :session
 
-    # A logger for this session
-    #
-    # @return [Logger, nil]
-    attr_accessor :logger
-
     # Create a new SSH session
     #
     # @return [Sshake::Session]
     def initialize(host, *args)
+      super
       @host = host
       @session_options = args
     end
@@ -32,6 +27,8 @@ module SSHake
     #
     # @return [void]
     def connect
+      log :debug, "Creating connection to #{@host}"
+      log :debug, "Session options: #{@session_options.inspect}"
       @session = Net::SSH.start(@host, *@session_options)
       true
     end
@@ -47,9 +44,14 @@ module SSHake
     #
     # @return [void]
     def disconnect
+      return false if @session.nil?
+
       begin
+        log :debug, 'Closing connectiong'
         @session.close
-      rescue StandardError
+        log :debug, 'Connection closed successfully'
+      rescue StandardError => e
+        log :debug, "Connection not closed: #{e.message} (#{e.class})"
         nil
       end
       @session = nil
@@ -58,121 +60,106 @@ module SSHake
 
     # Kill the underlying connection
     def kill!
+      log :debug, "Attempting kill/shutdown of session"
       @session.shutdown!
+      log :debug, "Session shutdown success"
       @session = nil
     end
 
-    # Execute a command
-    #
     def execute(commands, options = nil, &block)
-      commands = [commands] unless commands.is_a?(Array)
-
       options = create_options(options, block)
-
-      # Map sudo onto command
-      if options.sudo_user
-        commands = add_sudo_to_commands_array(commands, options.sudo_user)
-      end
-
-      # Construct a full command string to execute
-      command = commands.join(' && ')
-
-      # Log the command
-      log :info, "\e[44;37m=> #{command}\e[0m"
+      command_to_execute = prepare_commands(commands, options)
 
       # Execute the command
       response = Response.new
-      response.command = command
+      response.command = command_to_execute
       connect unless connected?
+
+      # Log the command
+      log :info, "Executing: #{command_to_execute}"
+      log :debug, "Timeout: #{options.timeout}"
+
       begin
         channel = nil
         Timeout.timeout(options.timeout) do
           channel = @session.open_channel do |ch|
             response.start_time = Time.now
-            channel.exec(command) do |_, success|
-              raise "Command \"#{command}\" was unable to execute" unless success
+            channel.exec(command_to_execute) do |_, success|
+              raise "Command \"#{command_to_execute}\" was unable to execute" unless success
+
+              if options.stdin
+                ch.send_data(options.stdin)
+              end
 
-              ch.send_data(options.stdin) if options.stdin
-              ch.eof!
+              if options.file_to_stream.nil?
+                ch.eof!
+              end
 
               ch.on_data do |_, data|
                 response.stdout += data
                 options.stdout&.call(data)
-                log :debug, data.gsub(/[\r]/, ''), tab: 4
+                log :debug, data.gsub(/[\r]/, '')
               end
 
               ch.on_extended_data do |_, _, data|
                 response.stderr += data.delete("\r")
                 options.stderr&.call(data)
-                log :warn, data, tab: 4
+                log :debug, data
                 if data =~ /^\[sudo\] password for/
+                  log :debug, 'Sending sudo password'
                   ch.send_data "#{options.sudo_password}\n"
                 end
               end
 
               ch.on_request('exit-status') do |_, data|
                 response.exit_code = data.read_long&.to_i
-                log :info, "\e[43;37m=> Exit code: #{response.exit_code}\e[0m"
+                log :debug, "Exit code: #{response.exit_code}"
               end
 
               ch.on_request('exit-signal') do |_, data|
                 response.exit_signal = data.read_long
               end
+
+              if options.file_to_stream
+                ch.on_process do |_, data|
+                  next if ch.eof?
+                  if ch.output.length < 128 * 1024
+                    if data = options.file_to_stream.read(1024 * 1024)
+                      ch.send_data(data)
+                      response.bytes_streamed += data.bytesize
+                    else
+                      ch.eof!
+                    end
+                  end
+                end
+              end
             end
           end
           channel.wait
         end
       rescue Timeout::Error => e
+        log :debug, "Got timeout error while executing command"
         kill!
-        response.exit_code = -255
+        response.timeout!
       ensure
         response.finish_time = Time.now
       end
 
-      if options.raise_on_error? && !response.success?
-        raise ExecutionError, response
-      else
-        response
-      end
+      handle_response(response, options)
     end
 
     def write_data(path, data, options = nil, &block)
       connect unless connected?
       tmp_path = "/tmp/sshake-tmp-file-#{SecureRandom.hex(32)}"
-      @session.sftp.file.open(path, 'w') { |f| f.write(data) }
+      @session.sftp.file.open(tmp_path, 'w') do |f|
+        d = data.dup.force_encoding('BINARY')
+        until d.empty?
+          f.write(d.slice!(0, 1024))
+        end
+      end
       response = execute("mv #{tmp_path} #{path}", options, &block)
       response.success?
     end
 
-    private
-
-    def add_sudo_to_commands_array(commands, user)
-      commands.map do |command|
-        "sudo -u #{user} --stdin #{command}"
-      end
-    end
-
-    def create_options(hash, block)
-      if block && hash
-        raise Error, 'You cannot provide a block and options'
-      elsif block
-        ExecutionOptions.from_block(&block)
-      elsif hash.is_a?(Hash)
-        ExecutionOptions.from_hash(hash)
-      else
-        ExecutionOptions.new
-      end
-    end
-
-    def log(type, text, options = {})
-      logger = @logger || SSHake.logger
-      return unless logger
-
-      prefix = "\e[45;37m[#{@host}]\e[0m"
-      tabs = ' ' * (options[:tab] || 0)
-      text.split(/\n/).each do |line|
-        logger.send(type, prefix + tabs + line)
-      end
-    end
   end
 end

data/lib/sshake/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SSHake
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sshake
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-14 00:00:00.000000000 Z
+date: 2020-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-sftp
@@ -45,10 +45,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/sshake.rb
+- lib/sshake/base_session.rb
 - lib/sshake/error.rb
 - lib/sshake/execution_options.rb
 - lib/sshake/execution_options_dsl.rb
 - lib/sshake/logger.rb
+- lib/sshake/mock/command.rb
+- lib/sshake/mock/command_set.rb
+- lib/sshake/mock/environment.rb
+- lib/sshake/mock/executed_command.rb
+- lib/sshake/mock/session.rb
+- lib/sshake/mock/unsupported_command_error.rb
 - lib/sshake/response.rb
 - lib/sshake/session.rb
 - lib/sshake/version.rb
@@ -71,8 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A wrapper for net/ssh to make running commands more fun