sshake 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 100663608c7ad37ad009f8e8390bb8529a310f67
+  data.tar.gz: 5941b458f2d5157b8e94affd1da506c9208d2a78
+SHA512:
+  metadata.gz: 373f8dfeffe16e7287d08566587c63ecbc58fe99749e5acc21b176bf13eac1964b933c24d14e7eff1fd8f66df41543a4a099ae7e45652c8f579cf709fc6bbf93
+  data.tar.gz: f0e6974235d398df3e19f8acc4cee2322148750f66f7591ff7a6de7b2afc44cc82c9ffa13726e9f424f352a8674cd10c8764d949d5e3cd1a2fd9080d924209d1

data/lib/sshake/error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SSHake
+  class Error < StandardError
+  end
+
+  class ExecutionError < Error
+    def initialize(response)
+      response
+    end
+
+    attr_reader :response
+
+    def message
+      "Failed to execute command: #{@response.command} (exit code: #{@response.exit_code})"
+    end
+  end
+end

data/lib/sshake/execution_options.rb

@@ -0,0 +1,93 @@
+require 'sshake/execution_options_dsl'
+
+module SSHake
+  class ExecutionOptions
+    # The timeout
+    #
+    # @return [Integer]
+    def timeout
+      @timeout || self.class.default_timeout
+    end
+    attr_writer :timeout
+
+    # The user to execute sudo commands as. If nil, commands will
+    # not be executed with sudo.
+    #
+    # @return [String]
+    attr_accessor :sudo_user
+
+    # The password to be provided to the interactive sudo prompt
+    #
+    # @return [String]
+    attr_accessor :sudo_password
+
+    # Should errors be raised?
+    #
+    # @return [Boolean]
+    attr_accessor :raise_on_error
+
+    # The data to pass to stdin when executing this command
+    #
+    # @return [String]
+    attr_accessor :stdin
+
+    # A proc to call whenever data is received on stdout
+    #
+    # @return [Proc]
+    attr_accessor :stdout
+
+    # A proc to call whenever data is received on stderr
+    #
+    # @return [Proc]
+    attr_accessor :stderr
+
+    # Should errors be raised
+    #
+    # @return [Boolean]
+    def raise_on_error?
+      !!@raise_on_error
+    end
+
+    class << self
+      # Return the default timeout
+      #
+      # @return [Integer]
+      def default_timeout
+        @default_timeout || 60
+      end
+      attr_writer :default_timeout
+
+      # Create a new set of options from a given hash
+      #
+      # @param [Hash] hash
+      # @return [SSHake::ExecutionOptions]
+      def from_hash(hash)
+        options = new
+        options.timeout = hash[:timeout]
+        if hash[:sudo].is_a?(String)
+          options.sudo_user = hash[:sudo]
+        elsif hash[:sudo].is_a?(Hash)
+          options.sudo_user = hash[:sudo][:user]
+          options.sudo_password = hash[:sudo][:password]
+        elsif hash[:sudo] == true
+          options.sudo_user = 'root'
+        end
+        options.raise_on_error = !!hash[:raise_on_error]
+        options.stdin = hash[:stdin]
+        options.stdout = hash[:stdout]
+        options.stderr = hash[:stderr]
+        options
+      end
+
+      # Create a new set of options from a block
+      #
+      # @return [SSHake::ExecutionOptions]
+      def from_block
+        options = new
+        dsl = ExecutionOptionsDSL.new(options)
+        yield dsl
+        options
+      end
+    end
+  end
+end

data/lib/sshake/execution_options_dsl.rb

@@ -0,0 +1,32 @@
+module SSHake
+  class ExecutionOptionsDSL
+    def initialize(options)
+      @options = options
+    end
+
+    def timeout(timeout)
+      @options.timeout = timeout
+    end
+
+    def sudo(options = {})
+      @options.sudo_user = options[:user] || 'root'
+      @options.sudo_password = options[:password]
+    end
+
+    def raise_on_error
+      @options.raise_on_error = true
+    end
+
+    def stdin(value)
+      @options.stdin = value
+    end
+
+    def stdout(&block)
+      @options.stdout = block
+    end
+
+    def stderr(&block)
+      @options.stderr = block
+    end
+  end
+end

data/lib/sshake/logger.rb

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

data/lib/sshake/response.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SSHake
+  class Response
+    def initialize
+      @stdout = ''
+      @stderr = ''
+    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
+
+    def success?
+      @exit_code == 0
+    end
+
+    def time
+      (finish_time - start_time).to_i
+    end
+
+    def timeout?
+      @exit_code == -255
+    end
+  end
+end

data/lib/sshake/session.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'net/ssh'
+require 'net/sftp'
+require 'timeout'
+require 'sshake/error'
+require 'sshake/logger'
+require 'sshake/response'
+require 'sshake/execution_options'
+
+module SSHake
+  class Session
+    # 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)
+      @host = host
+      @session_options = args
+    end
+
+    # Connect to the SSH server
+    #
+    # @return [void]
+    def connect
+      @session = Net::SSH.start(@host, *@session_options)
+      true
+    end
+
+    # Is there an established SSH connection
+    #
+    # @return [Boolean]
+    def connected?
+      !@session.nil?
+    end
+
+    # Disconnect the underlying SSH connection
+    #
+    # @return [void]
+    def disconnect
+      begin
+        @session.close
+      rescue StandardError
+        nil
+      end
+      @session = nil
+      true
+    end
+
+    # Kill the underlying connection
+    def kill!
+      @session.shutdown!
+      @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"
+
+      # Execute the command
+      response = Response.new
+      response.command = command
+      connect unless connected?
+      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
+
+              ch.send_data(options.stdin) if options.stdin
+              ch.eof!
+
+              ch.on_data do |_, data|
+                response.stdout += data
+                options.stdout&.call(data)
+                log :debug, data.gsub(/[\r]/, ''), tab: 4
+              end
+
+              ch.on_extended_data do |_, _, data|
+                response.stderr += data.delete("\r")
+                options.stderr&.call(data)
+                log :warn, data, tab: 4
+                if data =~ /^\[sudo\] password for/
+                  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"
+              end
+
+              ch.on_request('exit-signal') do |_, data|
+                response.exit_signal = data.read_long
+              end
+            end
+          end
+          channel.wait
+        end
+      rescue Timeout::Error => e
+        kill!
+        response.exit_code = -255
+      ensure
+        response.finish_time = Time.now
+      end
+
+      if options.raise_on_error? && !response.success?
+        raise ExecutionError, response
+      else
+        response
+      end
+    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) }
+      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

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

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: sshake
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-sftp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+description: A wrapper for net/ssh to make running commands more fun
+email:
+- me@adamcooke.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sshake/error.rb
+- lib/sshake/execution_options.rb
+- lib/sshake/execution_options_dsl.rb
+- lib/sshake/logger.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: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: A wrapper for net/ssh to make running commands more fun
+test_files: []