sshake 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 314760390e24b395431def2b202b606569f833dce1148bdedc556c7ca7869c3f
-  data.tar.gz: 82eee2aa19795c54837ebe9b3c20c5d2349c7f8402240ac3bc13c07692ee46d2
+  metadata.gz: 95a0f6a6db803ff62826997e18e0b5d5ec81977046833bc32c10e29ebdbfd883
+  data.tar.gz: 8a2c9aa526b96827b3d50d25cd8b479bf3310eb6857822790410e79a38ac8423
 SHA512:
-  metadata.gz: a2310a628972c8062ae526c569b135dd2cc4ee37a057f2924d81e43605f2aaaa8d42fb39c3078cf20e766857fbdc8c081bf6efad9c61d184f04ac1b0fafd33b9
-  data.tar.gz: 67cb1c5689970aaac6c7987bb4e19d15152bf18dd36e2fa0bdaada484019ffd690b35025489c9cc7e8128c6c0d151c5f887aa62d9802d09c089c78d630c1fc55
+  metadata.gz: dc53e93b8e027f96c6078acb1626a056512dbf932a5650a1e4e4dfa53d28d72c219cff4acb392ca3d46fcbd5cd136aa7114b3edca27884817f86ace0648ec0c5
+  data.tar.gz: 25e70b953ed507800fa3f1a0531c926023d383f8a73caf8de201e12db2b4dd4e864af0080bf657952ad00112528572368e6c9eced39adf254858897e9487a6e3

data/lib/sshake/base_session.rb

@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 require 'securerandom'
-require 'sshake/logger'
+require 'klogger'
+require 'sshake/klogger'
 require 'sshake/execution_options'
 
 module SSHake
   class BaseSession
+
     # A logger for this session
     #
-    # @return [Logger, nil]
-    attr_accessor :logger
+    # @return [Klogger, nil]
+    attr_accessor :klogger
 
     # An ID for this session
     #
@@ -19,58 +23,65 @@ module SSHake
     # @return [Boolean]
     attr_accessor :raise_on_error
 
-    def initialize(*args)
+    def initialize(*_args, klogger: nil)
       @id = SecureRandom.hex(4)
+      @klogger = klogger || SSHake.klogger
     end
 
     # Connect to the SSH server
     #
     # @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,23 +90,12 @@ module SSHake
       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)
+        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 +105,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/klogger.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SSHake
+
+  class << self
+
+    def klogger
+      @klogger ||= Klogger.new(:ssh, destination: $stdout, formatter: :go)
+    end
+    attr_writer :klogger
+
+  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,16 +9,14 @@ module SSHake
         @captures = []
       end
 
-      attr_accessor :command
-      attr_accessor :options
-      attr_accessor :captures
+      attr_accessor :command, :options, :captures
 
       def store
-        @session ? @session.store : nil
+        @session&.store
       end
 
       def written_files
-        @session ? @session.written_files : nil
+        @session&.written_files
       end
 
     end

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,27 +9,48 @@ 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 = nil, **options)
       super
       @host = host
-      @session_options = args
+      @username = username
+      @session_options = options
+      @session_options.delete(:klogger)
+    end
+
+    # Return the username for the connection
+    #
+    # @return [String]
+    def user
+      @user || ENV.fetch('USER', nil)
+    end
+
+    # Return the port that will be connected to
+    #
+    # @return [Integer]
+    def port
+      @session_options[:port] || 22
     end
 
     # Connect to the SSH server
     #
     # @return [void]
     def connect
-      log :debug, "Creating connection to #{@host}"
-      log :debug, "Session options: #{@session_options.inspect}"
-      @session = Net::SSH.start(@host, *@session_options)
+      klogger.debug 'Connecting', id: @id, host: @host, user: @user, port: @session_options[:port] || 22
+      @session = Net::SSH.start(@host, user, @session_options)
       true
     end
 
@@ -47,11 +68,11 @@ module SSHake
       return false if @session.nil?
 
       begin
-        log :debug, 'Closing connectiong'
+        klogger.debug 'Closing connection', id: @id, host: @host
         @session.close
-        log :debug, 'Connection closed successfully'
+        klogger.debug 'Connection closed', id: @id, host: @host
       rescue StandardError => e
-        log :debug, "Connection not closed: #{e.message} (#{e.class})"
+        logger.exception(e, 'Connection not closed')
         nil
       end
       @session = nil
@@ -60,12 +81,13 @@ module SSHake
 
     # Kill the underlying connection
     def kill!
-      log :debug, "Attempting kill/shutdown of session"
+      klogger.debug 'Attemping to shutdown', id: @id, host: @host
       @session.shutdown!
-      log :debug, "Session shutdown success"
+      klogger.debug 'Shutdown success', id: @id, host: @host
       @session = nil
     end
 
+    # rubocop:disable Metrics/AbcSize
     def execute(commands, options = nil, &block)
       options = create_options(options, block)
       command_to_execute = prepare_commands(commands, options)
@@ -75,91 +97,111 @@ module SSHake
       response.command = command_to_execute
       connect unless connected?
 
-      # Log the command
-      log :info, "Executing: #{command_to_execute}"
-      log :debug, "Timeout: #{options.timeout}"
+      klogger.group(id: @id, host: @host) do
+        klogger.info 'Executing command', command: command_to_execute, 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_to_execute) do |_, success|
-              raise "Command \"#{command_to_execute}\" was unable to execute" unless success
-
-              if options.stdin
-                ch.send_data(options.stdin)
-              end
+        begin
+          channel = nil
 
-              if options.file_to_stream.nil?
-                ch.eof!
-              end
+          Timeout.timeout(options.timeout) do
+            channel = @session.open_channel do |ch|
+              response.start_time = Time.now
 
-              ch.on_data do |_, data|
-                response.stdout += data
-                options.stdout&.call(data)
-                log :debug, data.gsub(/[\r]/, '')
-              end
+              channel.exec(command_to_execute) do |_, success|
+                raise "Command \"#{command_to_execute}\" was unable to execute" unless success
+
+                ch.send_data(options.stdin) if options.stdin
 
-              ch.on_extended_data do |_, _, data|
-                response.stderr += data.delete("\r")
-                options.stderr&.call(data)
-                log :debug, data
-                if data =~ /^\[sudo\] password for/
-                  log :debug, 'Sending sudo password'
-                  ch.send_data "#{options.sudo_password}\n"
+                if options.file_to_stream.nil? && options.sudo_password.nil?
+                  klogger.debug 'Sending EOF to channel'
+                  ch.eof!
                 end
-              end
 
-              ch.on_request('exit-status') do |_, data|
-                response.exit_code = data.read_long&.to_i
-                log :debug, "Exit code: #{response.exit_code}"
-              end
+                ch.on_data do |_, data|
+                  response.stdout += data
+                  options.stdout&.call(data)
+                  klogger.debug "[stdout] #{data.gsub(/\r/, '').strip}"
+                end
 
-              ch.on_request('exit-signal') do |_, data|
-                response.exit_signal = data.read_long
-              end
+                ch.on_extended_data do |_, _, data|
+                  response.stderr += data.delete("\r")
+                  options.stderr&.call(data)
+                  klogger.debug "[stderr] #{data.gsub(/\r/, '').strip}"
+                  if options.sudo_password && data =~ /^\[sshake-sudo-password\]:\s\z/
+                    klogger.debug 'Sending sudo password', length: options.sudo_password.length
+                    ch.send_data "#{options.sudo_password}\n"
 
-              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
+                    if options.file_to_stream.nil?
+                      klogger.debug 'Sending EOF after password'
                       ch.eof!
                     end
                   end
                 end
+
+                ch.on_request('exit-status') do |_, data|
+                  response.exit_code = data.read_long&.to_i
+                  klogger.info 'Exited', 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
-          channel.wait
+        rescue Timeout::Error
+          klogger.debug 'Command timed out'
+          kill!
+          response.timeout!
+        ensure
+          response.finish_time = Time.now
         end
-      rescue Timeout::Error => e
-        log :debug, "Got timeout error while executing command"
-        kill!
-        response.timeout!
-      ensure
-        response.finish_time = Time.now
       end
 
       handle_response(response, options)
     end
+    # rubocop:enable Metrics/AbcSize
 
     def write_data(path, data, options = nil, &block)
       connect unless connected?
       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 = '2.0.0'
+
 end

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: sshake
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Adam Cooke
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-04 00:00:00.000000000 Z
+date: 2023-03-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: klogger-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: net-sftp
   requirement: !ruby/object:Gem::Requirement
@@ -50,21 +70,25 @@ files:
 - lib/sshake/error.rb
 - lib/sshake/execution_options.rb
 - lib/sshake/execution_options_dsl.rb
-- lib/sshake/logger.rb
+- lib/sshake/klogger.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/recorded_session.rb
+- lib/sshake/recorder.rb
+- lib/sshake/recording.rb
 - lib/sshake/response.rb
 - lib/sshake/session.rb
 - lib/sshake/version.rb
 homepage: https://github.com/adamcooke/sshake
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -72,15 +96,15 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.32
+signing_key:
 specification_version: 4
 summary: A wrapper for net/ssh to make running commands more fun
 test_files: []

data/lib/sshake/logger.rb

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