sshake 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 314760390e24b395431def2b202b606569f833dce1148bdedc556c7ca7869c3f
-  data.tar.gz: 82eee2aa19795c54837ebe9b3c20c5d2349c7f8402240ac3bc13c07692ee46d2
+  metadata.gz: 7f07fcd2695da038870ae9a7c15715524ed1cbd1912a38c9cbd4c3d3d9f39d96
+  data.tar.gz: c941f1f5ae3dd0348da4c694f769fdad2fcaa026777cf0c8a5cd6278d179a87a
 SHA512:
-  metadata.gz: a2310a628972c8062ae526c569b135dd2cc4ee37a057f2924d81e43605f2aaaa8d42fb39c3078cf20e766857fbdc8c081bf6efad9c61d184f04ac1b0fafd33b9
-  data.tar.gz: 67cb1c5689970aaac6c7987bb4e19d15152bf18dd36e2fa0bdaada484019ffd690b35025489c9cc7e8128c6c0d151c5f887aa62d9802d09c089c78d630c1fc55
+  metadata.gz: 0c7636ffe034fc59aa89043bfb44d6e78d156567283f5a77b82eeb98df91f8977e561c2435f2512261166a0242fe0d75b5c7ca8369b9babd6f96729f29323dc5
+  data.tar.gz: bc5eb231a03e4e207a9c478bdb4b3764366f48d82576d6d60b2daa3571cce7383c9f8d6d4d49d786b8c6fbf6582fee132cdb7039f7a40c9a90a44ffd5083856f

data/lib/sshake/base_session.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 require 'sshake/logger'
 require 'sshake/execution_options'
 
 module SSHake
   class BaseSession
+
     # A logger for this session
     #
     # @return [Logger, nil]
@@ -19,7 +22,7 @@ module SSHake
     # @return [Boolean]
     attr_accessor :raise_on_error
 
-    def initialize(*args)
+    def initialize(*_args)
       @id = SecureRandom.hex(4)
     end
 
@@ -27,50 +30,56 @@ module SSHake
     #
     # @return [void]
     def connect
-      raise "Override #connect in sub-sessions"
+      raise 'Override #connect in sub-sessions'
     end
 
     # Is there an established SSH connection
     #
     # @return [Boolean]
     def connected?
-      raise "Override #connected? in sub-sessions"
+      raise 'Override #connected? in sub-sessions'
     end
 
     # Disconnect the underlying SSH connection
     #
     # @return [void]
     def disconnect
-      raise "Override #disconnect in sub-sessions"
+      raise 'Override #disconnect in sub-sessions'
     end
 
     # Kill the underlying connection
     def kill!
-      raise "Override #kill! in sub-sessions"
+      raise 'Override #kill! in sub-sessions'
     end
 
     # Execute a command
     #
-    def execute(commands, options = nil, &block)
-      raise "Override #execute in sub-sessions"
+    def execute(_commands, _options = nil)
+      raise 'Override #execute in sub-sessions'
     end
 
-    def write_data(path, data, options = nil, &block)
-      raise "Override #write_data in sub-sessions"
+    def write_data(_path, _data, _options = nil)
+      raise 'Override #write_data in sub-sessions'
     end
 
     private
 
-    def add_sudo_to_commands_array(commands, user)
+    def add_sudo_to_commands_array(commands, user, password = nil)
+      sudo_prefix = "sudo -u #{user}"
+      unless password.nil?
+        sudo_prefix += " --stdin -p '[sshake-sudo-password]: ' "
+      end
       commands.map do |command|
-        "sudo -u #{user} --stdin #{command}"
+        "#{sudo_prefix} #{command}"
       end
     end
 
     def create_options(hash, block)
       if block && hash
         raise Error, 'You cannot provide a block and options'
-      elsif block
+      end
+
+      if block
         ExecutionOptions.from_block(&block)
       elsif hash.is_a?(Hash)
         ExecutionOptions.from_hash(hash)
@@ -79,7 +88,7 @@ module SSHake
       end
     end
 
-    def log(type, text, options = {})
+    def log(type, text, _options = {})
       logger = @logger || SSHake.logger
       return unless logger
 
@@ -95,7 +104,7 @@ module SSHake
 
       # Map sudo onto command
       if execution_options.sudo_user && options[:add_sudo] != false
-        commands = add_sudo_to_commands_array(commands, execution_options.sudo_user)
+        commands = add_sudo_to_commands_array(commands, execution_options.sudo_user, execution_options.sudo_password)
       end
 
       # Construct a full command string to execute
@@ -105,9 +114,9 @@ module SSHake
     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
+
+      response
     end
 
   end

data/lib/sshake/error.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module SSHake
+
   class Error < StandardError
   end
 
   class ExecutionError < Error
+
     def initialize(response)
       @response = response
     end
@@ -16,7 +18,10 @@ module SSHake
     end
 
     def message
-      "Failed to execute command: #{@response.command} (stderr: #{@response.stderr}) (exit code: #{@response.exit_code})"
+      "Failed to execute command: #{@response.command} " \
+      "(stderr: #{@response.stderr}) (exit code: #{@response.exit_code})"
     end
+
   end
+
 end

data/lib/sshake/execution_options.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'sshake/execution_options_dsl'
 
 module SSHake
   class ExecutionOptions
+
     # The timeout
     #
     # @return [Integer]
@@ -44,7 +47,7 @@ module SSHake
     # A file that you wish to stream to the remote channel
     # with the current commend
     #
-    # @return [File]
+    # @return [File]
     attr_accessor :file_to_stream
 
     # Should errors be raised
@@ -55,6 +58,7 @@ module SSHake
     end
 
     class << self
+
       # Return the default timeout
       #
       # @return [Integer]
@@ -70,15 +74,18 @@ module SSHake
       def from_hash(hash)
         options = new
         options.timeout = hash[:timeout]
-        if hash[:sudo].is_a?(String)
+        case hash[:sudo]
+        when String
           options.sudo_user = hash[:sudo]
-        elsif hash[:sudo].is_a?(Hash)
-          options.sudo_user = hash[:sudo][:user]
+        when Hash
+          options.sudo_user = hash[:sudo][:user] || 'root'
           options.sudo_password = hash[:sudo][:password]
-        elsif hash[:sudo] == true
+        when true
           options.sudo_user = 'root'
         end
+        # rubocop:disable Style/DoubleNegation
         options.raise_on_error = !!hash[:raise_on_error]
+        # rubocop:enable Style/DoubleNegation
         options.stdin = hash[:stdin]
         options.stdout = hash[:stdout]
         options.stderr = hash[:stderr]
@@ -95,6 +102,8 @@ module SSHake
         yield dsl
         options
       end
+
     end
+
   end
 end

data/lib/sshake/execution_options_dsl.rb

@@ -2,6 +2,7 @@
 
 module SSHake
   class ExecutionOptionsDSL
+
     def initialize(options)
       @options = options
     end
@@ -15,9 +16,11 @@ module SSHake
       @options.sudo_password = options[:password]
     end
 
+    # rubocop:disable Style/OptionalBooleanParameter
     def raise_on_error(bool = true)
       @options.raise_on_error = bool
     end
+    # rubocop:enable Style/OptionalBooleanParameter
 
     def dont_raise_on_error
       @options.raise_on_error = false
@@ -38,5 +41,6 @@ module SSHake
     def file_to_stream(file)
       @options.file_to_stream = file
     end
+
   end
 end

data/lib/sshake/logger.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
 module SSHake
+
   class << self
+
     attr_accessor :logger
+
   end
+
 end

data/lib/sshake/mock/command.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sshake/response'
 
 module SSHake
@@ -24,9 +26,7 @@ module SSHake
       def make_response(environment)
         response = SSHake::Response.new
         response.start_time = Time.now
-        if @block
-          @block.call(response, environment)
-        end
+        @block&.call(response, environment)
         response.finish_time = Time.now
         response
       end

data/lib/sshake/mock/command_set.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sshake/mock/command'
 
 module SSHake

data/lib/sshake/mock/environment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SSHake
   module Mock
     class Environment
@@ -7,9 +9,7 @@ module SSHake
         @captures = []
       end
 
-      attr_accessor :command
-      attr_accessor :options
-      attr_accessor :captures
+      attr_accessor :command, :options, :captures
 
       def store
         @session ? @session.store : nil

data/lib/sshake/mock/executed_command.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module SSHake
   module Mock
     class ExecutedCommand
 
-      attr_reader :command
-      attr_reader :environment
-      attr_reader :response
+      attr_reader :command, :environment, :response
 
       def initialize(command, environment, response)
         @command = command

data/lib/sshake/mock/session.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'net/ssh/errors'
 require 'sshake/base_session'
 require 'sshake/mock/command_set'
@@ -9,10 +11,7 @@ module SSHake
   module Mock
     class Session < BaseSession
 
-      attr_reader :command_set
-      attr_reader :store
-      attr_reader :written_files
-      attr_reader :executed_commands
+      attr_reader :command_set, :store, :written_files, :executed_commands
 
       def initialize(**options)
         @options = options
@@ -57,25 +56,21 @@ module SSHake
         environment = Environment.new(self)
 
         environment.options = create_options(options, block)
-        environment.command = prepare_commands(commands, environment.options, :add_sudo => false)
+        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
+        raise UnsupportedCommandError, environment.command if command.nil?
 
         response = command.make_response(environment)
 
-        if environment.options.file_to_stream
-          response.bytes_streamed = environment.options.file_to_stream.size
-        end
+        response.bytes_streamed = environment.options.file_to_stream.size if environment.options.file_to_stream
 
         @executed_commands << ExecutedCommand.new(command, environment, response)
         handle_response(response, environment.options)
       end
 
-      def write_data(path, data, options = nil, &block)
+      def write_data(path, data, _options = nil)
         connect unless connected?
         @written_files[path] = data
         true
@@ -92,9 +87,11 @@ module SSHake
         end
       end
 
+      # rubocop:disable Naming/PredicateName
       def has_executed_command?(matcher)
-        find_executed_commands(matcher).size > 0
+        find_executed_commands(matcher).size.positive?
       end
+      # rubocop:enable Naming/PredicateName
 
     end
   end

data/lib/sshake/mock/unsupported_command_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sshake/error'
 
 module SSHake

data/lib/sshake/recorded_session.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'sshake/base_session'
+require 'sshake/recorder'
+require 'sshake/session'
+
+module SSHake
+  class RecordedSession < BaseSession
+
+    attr_reader :recorder
+    attr_reader :session
+
+    def initialize(recorder, session, **options)
+      super
+      @recorder = recorder
+      @session = session
+    end
+
+    def execute(commands, options = nil, &block)
+      options = create_options(options, block)
+      command_to_execute = prepare_commands(commands, options)
+
+      cached_response = @recorder.play(command_to_execute, options: options, connection: connection_hash)
+      return cached_response if cached_response
+
+      response = @session.execute(commands, options)
+      record(command_to_execute, options, response)
+      response
+    end
+
+    private
+
+    def record(command, options, response)
+      @recorder.record(command, response, options: options, connection: connection_hash)
+      @recorder.save
+    end
+
+    def connection_hash
+      {
+        host: @session.host,
+        user: @session.user,
+        port: @session.port
+      }
+    end
+
+  end
+end

data/lib/sshake/recorder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'yaml'
+module SSHake
+  class Recorder
+
+    class << self
+
+      # Return the root where all recorded sessions should be stored
+      #
+      # @return [nil, String]
+      attr_accessor :save_root
+
+    end
+
+    attr_reader :name
+    attr_reader :cache
+
+    def initialize(name, cache: nil)
+      @name = name
+      @cache = cache || {}
+    end
+
+    def load
+      return if self.class.save_root.nil?
+
+      @cache = YAML.load_file(File.join(self.class.save_root, "#{name}.yml"))
+    end
+
+    def save
+      return if self.class.save_root.nil?
+
+      FileUtils.mkdir_p(self.class.save_root)
+      File.write(File.join(self.class.save_root, "#{name}.yml"), @cache.to_yaml)
+    end
+
+    def play(command, connection: {}, options: nil)
+      possibilities = @cache[command]
+      return nil if possibilities.nil?
+
+      options_as_hash = options_to_hash(options)
+
+      possibility = possibilities.find do |p|
+        p[:options] == options_as_hash &&
+          p[:connection] == connection
+      end
+
+      return nil if possibility.nil?
+
+      response = Response.new(cached: true)
+      possibility[:response].each do |key, value|
+        response.public_send("#{key}=", value)
+      end
+      response
+    end
+
+    def record(command, response, connection: {}, options: nil)
+      @cache[command] ||= []
+      @cache[command] << {
+        connection: connection,
+        options: options_to_hash(options),
+        response: response_to_hash(response)
+      }
+      save
+    end
+
+    private
+
+    def response_to_hash(response)
+      {
+        stdout: response.stdout,
+        stderr: response.stderr,
+        exit_code: response.exit_code,
+        start_time: response.start_time.to_i,
+        finish_time: response.finish_time.to_i
+      }
+    end
+
+    def options_to_hash(options)
+      options = ExecutionOptions.from_hash({}) if options.nil?
+
+      hash = {}
+      hash[:timeout] = options.timeout if options.timeout
+      hash[:sudo_user] = options.sudo_user if options.sudo_user
+      hash[:sudo_password] = options.sudo_password if options.sudo_password
+      hash[:raise_on_error] = true if options.raise_on_error?
+      hash[:stdin] = Digest::SHA1.hexdigest(options.stdin) if options.stdin
+      hash[:file_to_stream] = Digest::SHA1.hexdigest(options.file_to_stream.read) if options.file_to_stream
+
+      hash
+    end
+
+  end
+end

data/lib/sshake/recording.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'sshake/recorder'
+require 'sshake/recorded_session'
+require 'sshake/error'
+
+module SSHake
+
+  class NestedRecordingsUnsupportedError < Error
+  end
+
+  class << self
+
+    def record(name)
+      if Thread.current[:sshake_recorder]
+        raise NestedRecordingsUnsupportedError, 'You cannot nest SSHake.record blocks'
+      end
+
+      recorder = Recorder.new(name)
+      recorder.load
+      Thread.current[:sshake_recorder] = recorder
+      yield
+    ensure
+      Thread.current[:sshake_recorder] = nil
+    end
+
+  end
+
+end

data/lib/sshake/response.rb

@@ -2,24 +2,27 @@
 
 module SSHake
   class Response
-    def initialize
+
+    def initialize(cached: false)
       @stdout = ''
       @stderr = ''
       @exit_code = 0
       @bytes_streamed = 0
+      @cached = cached
     end
 
-    attr_accessor :command
-    attr_accessor :stdout
-    attr_accessor :stderr
-    attr_accessor :exit_code
-    attr_accessor :exit_signal
-    attr_accessor :start_time
-    attr_accessor :finish_time
-    attr_accessor :bytes_streamed
+    attr_accessor :command, :stdout, :stderr, :exit_code, :exit_signal, :start_time, :finish_time, :bytes_streamed
 
     def success?
-      @exit_code == 0
+      @exit_code.zero?
+    end
+
+    def cached?
+      @cached == true
+    end
+
+    def cached!
+      @cached = true
     end
 
     def time
@@ -33,5 +36,6 @@ module SSHake
     def timeout!
       @exit_code = -255
     end
+
   end
 end

data/lib/sshake/session.rb

@@ -9,18 +9,44 @@ require 'sshake/base_session'
 
 module SSHake
   class Session < BaseSession
+
     # The underlying net/ssh session
     #
     # @return [Net::SSH::Session]
     attr_reader :session
 
+    # Return the host to connect to
+    #
+    # @return [String]
+    attr_reader :host
+
     # Create a new SSH session
     #
     # @return [Sshake::Session]
-    def initialize(host, *args)
+    def initialize(host, username_or_options = {}, options_with_username = {})
       super
       @host = host
-      @session_options = args
+      if username_or_options.is_a?(String)
+        @user = username_or_options
+        @session_options = options_with_username
+      else
+        @user = username_or_options.delete(:user)
+        @session_options = username_or_options
+      end
+    end
+
+    # Return the username for the connection
+    #
+    # @return [String]
+    def user
+      @user || ENV['USER']
+    end
+
+    # Return the port that will be connected to
+    #
+    # @return [Integer]
+    def port
+      @session_options[:port] || 22
     end
 
     # Connect to the SSH server
@@ -29,7 +55,7 @@ module SSHake
     def connect
       log :debug, "Creating connection to #{@host}"
       log :debug, "Session options: #{@session_options.inspect}"
-      @session = Net::SSH.start(@host, *@session_options)
+      @session = Net::SSH.start(@host, user, @session_options)
       true
     end
 
@@ -60,9 +86,9 @@ module SSHake
 
     # Kill the underlying connection
     def kill!
-      log :debug, "Attempting kill/shutdown of session"
+      log :debug, 'Attempting kill/shutdown of session'
       @session.shutdown!
-      log :debug, "Session shutdown success"
+      log :debug, 'Session shutdown success'
       @session = nil
     end
 
@@ -87,27 +113,31 @@ module SSHake
             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
 
-              if options.file_to_stream.nil?
+              if options.file_to_stream.nil? && options.sudo_password.nil?
+                log :debug, 'Sending EOF to channel'
                 ch.eof!
               end
 
               ch.on_data do |_, data|
                 response.stdout += data
                 options.stdout&.call(data)
-                log :debug, data.gsub(/[\r]/, '')
+                log :debug, data.gsub(/\r/, '')
               end
 
               ch.on_extended_data do |_, _, data|
                 response.stderr += data.delete("\r")
                 options.stderr&.call(data)
                 log :debug, data
-                if data =~ /^\[sudo\] password for/
+                if options.sudo_password && data =~ /^\[sshake-sudo-password\]:\s\z/
                   log :debug, 'Sending sudo password'
                   ch.send_data "#{options.sudo_password}\n"
+
+                  if options.file_to_stream.nil?
+                    log :debug, 'Sending EOF after sudo password because no file'
+                    ch.eof!
+                  end
                 end
               end
 
@@ -123,6 +153,7 @@ module SSHake
               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)
@@ -137,8 +168,8 @@ module SSHake
           end
           channel.wait
         end
-      rescue Timeout::Error => e
-        log :debug, "Got timeout error while executing command"
+      rescue Timeout::Error
+        log :debug, 'Got timeout error while executing command'
         kill!
         response.timeout!
       ensure
@@ -153,13 +184,25 @@ module SSHake
       tmp_path = "/tmp/sshake-tmp-file-#{SecureRandom.hex(32)}"
       @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
+        f.write(d.slice!(0, 1024)) until d.empty?
       end
       response = execute("mv #{tmp_path} #{path}", options, &block)
       response.success?
     end
 
+    class << self
+
+      def create(*args)
+        session = new(*args)
+
+        if recorder = Thread.current[:sshake_recorder]
+          return RecordedSession.new(recorder, session)
+        end
+
+        session
+      end
+
+    end
+
   end
 end

data/lib/sshake/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module SSHake
-  VERSION = '1.0.2'
+
+  VERSION = '1.1.0'
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sshake
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-04 00:00:00.000000000 Z
+date: 2020-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-sftp
@@ -57,6 +57,9 @@ files:
 - lib/sshake/mock/executed_command.rb
 - lib/sshake/mock/session.rb
 - lib/sshake/mock/unsupported_command_error.rb
+- lib/sshake/recorded_session.rb
+- lib/sshake/recorder.rb
+- lib/sshake/recording.rb
 - lib/sshake/response.rb
 - lib/sshake/session.rb
 - lib/sshake/version.rb
@@ -72,7 +75,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="