train 3.2.14 → 3.2.20

data/lib/train/plugins/transport.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-#
-# Author:: Dominik Richter (<dominik.richter@gmail.com>)
-# Author:: Christoph Hartmann (<chris@lollyrock.com>)
-
-require "logger"
-require_relative "../errors"
-require_relative "../extras"
-require_relative "../options"
-
-class Train::Plugins
-  class Transport
-    include Train::Extras
-    Train::Options.attach(self)
-
-    require_relative "base_connection"
-
-    # Initialize a new Transport object
-    #
-    # @param [Hash] config = nil the configuration for this transport
-    # @return [Transport] the transport object
-    def initialize(options = {})
-      @options = merge_options({}, options || {})
-      @logger = @options[:logger] || Logger.new($stdout, level: :fatal)
-    end
-
-    # Create a connection to the target. Options may be provided
-    # for additional configuration.
-    #
-    # @param [Hash] _options = nil provide optional configuration params
-    # @return [Connection] the connection for this configuration
-    def connection(_options = nil)
-      raise Train::ClientError, "#{self.class} does not implement #connection()"
-    end
-
-    # Register the inheriting class with as a train plugin using the
-    # provided name.
-    #
-    # @param [String] name of the plugin, by which it will be found
-    def self.name(name)
-      Train::Plugins.registry[name] = self
-    end
-
-    private
-
-    # @return [Logger] logger for reporting information
-    attr_reader :logger
-  end
-end

data/lib/train/transports/cisco_ios_connection.rb

@@ -1,133 +0,0 @@
-# encoding: utf-8
-
-class Train::Transports::SSH
-  class CiscoIOSConnection < BaseConnection
-    class BadEnablePassword < Train::TransportError; end
-
-    def initialize(options)
-      super(options)
-
-      # Extract options to avoid passing them in to `Net::SSH.start` later
-      @host = options.delete(:host)
-      @user = options.delete(:user)
-      @port = options.delete(:port)
-      @enable_password = options.delete(:enable_password)
-
-      # Use all options left that are not `nil` for `Net::SSH.start` later
-      @ssh_options = options.reject { |_key, value| value.nil? }
-
-      @prompt = /^\S+[>#]\r\n.*$/
-    end
-
-    def uri
-      "ssh://#{@user}@#{@host}:#{@port}"
-    end
-
-    def unique_identifier
-      result = run_command_via_connection("show version | include Processor")
-      result.stdout.split(" ")[-1]
-    end
-
-    private
-
-    def establish_connection
-      logger.debug("[SSH] opening connection to #{self}")
-
-      Net::SSH.start(@host, @user, @ssh_options)
-    end
-
-    def session
-      return @session unless @session.nil?
-
-      @session = open_channel(establish_connection)
-
-      # Escalate privilege to enable mode if password is given
-      if @enable_password
-        # This verifies we are not in privileged exec mode before running the
-        # enable command. Otherwise, the password will be in history.
-        if run_command_via_connection("show privilege").stdout.split[-1] != "15"
-          # Extra newlines to get back to prompt if incorrect password is used
-          run_command_via_connection("enable\n#{@enable_password}\n\n\n")
-        end
-      end
-
-      # Prevent `--MORE--` by removing terminal length limit
-      run_command_via_connection("terminal length 0")
-
-      @session
-    end
-
-    def run_command_via_connection(cmd, &_data_handler)
-      # Ensure buffer is empty before sending data
-      @buf = ""
-
-      logger.debug("[SSH] Running `#{cmd}` on #{self}")
-      session.send_data(cmd + "\r\n")
-
-      logger.debug("[SSH] waiting for prompt")
-      until @buf =~ @prompt
-        if @buf =~ /Bad (secrets|password)|Access denied/
-          raise BadEnablePassword
-        end
-
-        session.connection.process(0)
-      end
-
-      # Save the buffer and clear it for the next command
-      output = @buf.dup
-      @buf = ""
-
-      format_result(format_output(output, cmd))
-    end
-
-    ERROR_MATCHERS = [
-      "Bad IP address",
-      "Incomplete command",
-      "Invalid input detected",
-      "Unrecognized host",
-    ].freeze
-
-    # IOS commands do not have an exit code so we must compare the command
-    # output with partial segments of known errors. Then, we return a
-    # `CommandResult` with arguments in the correct position based on the
-    # result.
-    def format_result(result)
-      if ERROR_MATCHERS.none? { |e| result.include?(e) }
-        CommandResult.new(result, "", 0)
-      else
-        CommandResult.new("", result, 1)
-      end
-    end
-
-    # The buffer (@buf) contains all data sent/received on the SSH channel so
-    # we need to format the data to match what we would expect from Train
-    def format_output(output, cmd)
-      leading_prompt = /(\r\n|^)\S+[>#]/
-      command_string = /#{Regexp.quote(cmd)}\r\n/
-      trailing_prompt = /\S+[>#](\r\n|$)/
-      trailing_line_endings = /(\r\n)+$/
-
-      output
-        .sub(leading_prompt, "")
-        .sub(command_string, "")
-        .gsub(trailing_prompt, "")
-        .gsub(trailing_line_endings, "")
-    end
-
-    # Create an SSH channel that writes to @buf when data is received
-    def open_channel(ssh)
-      logger.debug("[SSH] opening SSH channel to #{self}")
-      ssh.open_channel do |ch|
-        ch.on_data do |_, data|
-          @buf += data
-        end
-
-        ch.send_channel_request("shell") do |_, success|
-          raise "Failed to open SSH shell" unless success
-
-          logger.debug("[SSH] shell opened")
-        end
-      end
-    end
-  end
-end

data/lib/train/transports/local.rb

@@ -1,240 +0,0 @@
-# encoding: utf-8
-#
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require_relative "../plugins"
-require_relative "../errors"
-require "mixlib/shellout"
-
-module Train::Transports
-  class Local < Train.plugin(1)
-    name "local"
-
-    class PipeError < Train::TransportError; end
-
-    def connection(_ = nil)
-      @connection ||= Connection.new(@options)
-    end
-
-    class Connection < BaseConnection
-      def initialize(options)
-        super(options)
-
-        @runner = if options[:command_runner]
-                    force_runner(options[:command_runner])
-                  else
-                    select_runner(options)
-                  end
-      end
-
-      def login_command
-        nil # none, open your shell
-      end
-
-      def uri
-        "local://"
-      end
-
-      private
-
-      def select_runner(options)
-        if os.windows?
-          # Force a 64 bit poweshell if needed
-          if RUBY_PLATFORM == "i386-mingw32" && os.arch == "x86_64"
-            powershell_cmd = "#{ENV["SystemRoot"]}\\sysnative\\WindowsPowerShell\\v1.0\\powershell.exe"
-          else
-            powershell_cmd = "powershell"
-          end
-
-          # Attempt to use a named pipe but fallback to ShellOut if that fails
-          begin
-            WindowsPipeRunner.new(powershell_cmd)
-          rescue PipeError
-            WindowsShellRunner.new(powershell_cmd)
-          end
-        else
-          GenericRunner.new(self, options)
-        end
-      end
-
-      def force_runner(command_runner)
-        case command_runner
-        when :generic
-          GenericRunner.new(self, options)
-        when :windows_pipe
-          WindowsPipeRunner.new
-        when :windows_shell
-          WindowsShellRunner.new
-        else
-          raise "Runner type `#{command_runner}` not supported"
-        end
-      end
-
-      def run_command_via_connection(cmd, &_data_handler)
-        # Use the runner if it is available
-        return @runner.run_command(cmd) if defined?(@runner)
-
-        # If we don't have a runner, such as at the beginning of setting up the
-        # transport and performing the first few steps of OS detection, fall
-        # back to shelling out.
-        res = Mixlib::ShellOut.new(cmd)
-        res.run_command
-        Local::CommandResult.new(res.stdout, res.stderr, res.exitstatus)
-      rescue Errno::ENOENT => _
-        CommandResult.new("", "", 1)
-      end
-
-      def file_via_connection(path)
-        if os.windows?
-          Train::File::Local::Windows.new(self, path)
-        else
-          Train::File::Local::Unix.new(self, path)
-        end
-      end
-
-      class GenericRunner
-        include_options Train::Extras::CommandWrapper
-
-        def initialize(connection, options)
-          @cmd_wrapper = Local::CommandWrapper.load(connection, options)
-        end
-
-        def run_command(cmd)
-          if defined?(@cmd_wrapper) && !@cmd_wrapper.nil?
-            cmd = @cmd_wrapper.run(cmd)
-          end
-
-          res = Mixlib::ShellOut.new(cmd)
-          res.run_command
-          Local::CommandResult.new(res.stdout, res.stderr, res.exitstatus)
-        end
-      end
-
-      class WindowsShellRunner
-        require "json"
-        require "base64"
-
-        def initialize(powershell_cmd = "powershell")
-          @powershell_cmd = powershell_cmd
-        end
-
-        def run_command(script)
-          # Prevent progress stream from leaking into stderr
-          script = "$ProgressPreference='SilentlyContinue';" + script
-
-          # Encode script so PowerShell can use it
-          script = script.encode("UTF-16LE", "UTF-8")
-          base64_script = Base64.strict_encode64(script)
-
-          cmd = "#{@powershell_cmd} -NoProfile -EncodedCommand #{base64_script}"
-
-          res = Mixlib::ShellOut.new(cmd)
-          res.run_command
-          Local::CommandResult.new(res.stdout, res.stderr, res.exitstatus)
-        end
-      end
-
-      class WindowsPipeRunner
-        require "json"
-        require "base64"
-        require "securerandom"
-
-        def initialize(powershell_cmd = "powershell")
-          @powershell_cmd = powershell_cmd
-          @pipe = acquire_pipe
-          raise PipeError if @pipe.nil?
-        end
-
-        # @param  cmd The command to execute
-        # @return Local::ComandResult with stdout, stderr and exitstatus
-        #         Note that exitstatus ($?) in PowerShell is boolean, but we use a numeric exit code.
-        #         A command that succeeds without setting an exit code will have exitstatus 0
-        #         A command that exits with an exit code will have that value as exitstatus
-        #         A command that fails (e.g. throws exception) before setting an exit code will have exitstatus 1
-        def run_command(cmd)
-          script = "$ProgressPreference='SilentlyContinue';" + cmd
-          encoded_script = Base64.strict_encode64(script)
-          @pipe.puts(encoded_script)
-          @pipe.flush
-          res = OpenStruct.new(JSON.parse(Base64.decode64(@pipe.readline)))
-          Local::CommandResult.new(res.stdout, res.stderr, res.exitstatus)
-        end
-
-        private
-
-        def acquire_pipe
-          pipe_name = "inspec_#{SecureRandom.hex}"
-
-          start_pipe_server(pipe_name)
-
-          pipe = nil
-
-          # PowerShell needs time to create pipe.
-          100.times do
-            begin
-              pipe = open("//./pipe/#{pipe_name}", "r+")
-              break
-            rescue
-              sleep 0.1
-            end
-          end
-
-          pipe
-        end
-
-        def start_pipe_server(pipe_name)
-          require "win32/process"
-
-          script = <<-EOF
-            $ErrorActionPreference = 'Stop'
-
-            $pipeServer = New-Object System.IO.Pipes.NamedPipeServerStream('#{pipe_name}')
-            $pipeReader = New-Object System.IO.StreamReader($pipeServer)
-            $pipeWriter = New-Object System.IO.StreamWriter($pipeServer)
-
-            $pipeServer.WaitForConnection()
-
-            # Create loop to receive and process user commands/scripts
-            $clientConnected = $true
-            while($clientConnected) {
-              $input = $pipeReader.ReadLine()
-              $command = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($input))
-
-              # Execute user command/script and convert result to JSON
-              $scriptBlock = $ExecutionContext.InvokeCommand.NewScriptBlock($command)
-              try {
-                $stdout = & $scriptBlock | Out-String
-                $exit_code = $LastExitCode
-                if ($exit_code -eq $null)
-                {
-                  $exit_code = 0
-                }
-                $result = @{ 'stdout' = $stdout ; 'stderr' = ''; 'exitstatus' = $exit_code }
-              } catch {
-                $stderr = $_ | Out-String
-                $exit_code = $LastExitCode
-                $result = @{ 'stdout' = ''; 'stderr' = $stderr; 'exitstatus' = $exit_code }
-              }
-              $resultJSON = $result | ConvertTo-JSON
-
-              # Encode JSON in Base64 and write to pipe
-              $encodedResult = [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($resultJSON))
-              $pipeWriter.WriteLine($encodedResult)
-              $pipeWriter.Flush()
-            }
-          EOF
-
-          utf8_script = script.encode("UTF-16LE", "UTF-8")
-          base64_script = Base64.strict_encode64(utf8_script)
-          cmd = "#{@powershell_cmd} -NoProfile -ExecutionPolicy bypass -NonInteractive -EncodedCommand #{base64_script}"
-
-          server_pid = Process.create(command_line: cmd).process_id
-
-          # Ensure process is killed when the Train process exits
-          at_exit { Process.kill("KILL", server_pid) }
-        end
-      end
-    end
-  end
-end

data/lib/train/transports/mock.rb

@@ -1,183 +0,0 @@
-require_relative "../plugins"
-require "digest"
-
-module Train::Transports
-  class Mock < Train.plugin(1)
-    name "mock"
-
-    def initialize(conf = nil)
-      @conf = conf || {}
-      trace_calls if @conf[:trace]
-    end
-
-    def connection
-      @connection ||= Connection.new(@conf)
-    end
-
-    def to_s
-      "Mock Transport"
-    end
-
-    private
-
-    def trace_calls
-      interface_methods = {
-        "Train::Transports::Mock" =>
-          Train::Transports::Mock.instance_methods(false),
-        "Train::Transports::Mock::Connection" =>
-          Connection.instance_methods(false),
-        "Train::Transports::Mock::Connection::File" =>
-          Connection::FileCommon.instance_methods(false),
-        "Train::Transports::Mock::Connection::OS" =>
-          Train::Platform.instance_methods(false),
-      }
-
-      # rubocop:disable Metrics/ParameterLists
-      # rubocop:disable Security/Eval
-      set_trace_func(proc { |event, _file, _line, id, binding, classname|
-        unless classname.to_s.start_with?("Train::Transports::Mock") &&
-            (event == "call") &&
-            interface_methods[classname.to_s].include?(id)
-          next
-        end
-
-        # kindly borrowed from the wonderful simple-tracer by matugm
-        arg_names = eval(
-          "method(__method__).parameters.map { |arg| arg[1].to_s }",
-          binding
-        )
-        args = eval("#{arg_names}.map { |arg| eval(arg) }", binding).join(", ")
-        prefix = "-" * (classname.to_s.count(":") - 2) + "> "
-        puts("#{prefix}#{id} #{args}")
-      })
-      # rubocop:enable all
-    end
-  end
-end
-
-class Train::Transports::Mock
-  class Connection < BaseConnection
-    attr_reader :options
-
-    def initialize(conf = nil)
-      super(conf)
-      mock_os
-      enable_cache(:file)
-      enable_cache(:command)
-    end
-
-    def uri
-      "mock://"
-    end
-
-    DEFAULTS = {
-      name: "mock",
-      family: "mock",
-      release: "unknown",
-      arch: "unknown",
-    }.freeze
-
-    def mock_os(value = {})
-      value = DEFAULTS
-        .merge(value || {})
-        .transform_values { |v| v || "unknown" }
-
-      platform = Train::Platforms.name(value[:name])
-      platform.find_family_hierarchy
-      platform.platform = value
-      platform.add_platform_methods
-      @platform = platform
-    end
-
-    def commands=(commands)
-      @cache[:command] = commands
-    end
-
-    def commands
-      @cache[:command]
-    end
-
-    def files=(files)
-      @cache[:file] = files
-    end
-
-    def files
-      @cache[:file]
-    end
-
-    def mock_command(cmd, stdout = nil, stderr = nil, exit_status = 0)
-      @cache[:command][cmd] = Command.new(stdout || "", stderr || "", exit_status)
-    end
-
-    def command_not_found(cmd)
-      if @options[:verbose]
-        $stderr.puts("Command not mocked:")
-        $stderr.puts("    " + cmd.to_s.split("\n").join("\n    "))
-        $stderr.puts("    SHA: " + Digest::SHA256.hexdigest(cmd.to_s))
-      end
-      # return a non-zero exit code
-      mock_command(cmd, nil, nil, 1)
-    end
-
-    def file_not_found(path)
-      $stderr.puts("File not mocked: " + path.to_s) if @options[:verbose]
-      File.new(self, path)
-    end
-
-    def to_s
-      "Mock Connection"
-    end
-
-    private
-
-    def run_command_via_connection(cmd, &_data_handler)
-      @cache[:command][Digest::SHA256.hexdigest cmd.to_s] ||
-        command_not_found(cmd)
-    end
-
-    def file_via_connection(path)
-      file_not_found(path)
-    end
-  end
-end
-
-class Train::Transports::Mock::Connection
-  Command = Struct.new(:stdout, :stderr, :exit_status)
-end
-
-class Train::Transports::Mock::Connection
-  class File < Train::File
-    def self.from_json(json)
-      res = new(json["backend"],
-        json["path"],
-        json["follow_symlink"])
-      res.type = json["type"]
-      Train::File::DATA_FIELDS.each do |f|
-        m = (f.tr("?", "") + "=").to_sym
-        res.method(m).call(json[f])
-      end
-      res
-    end
-
-    Train::File::DATA_FIELDS.each do |m|
-      attr_accessor m.tr("?", "").to_sym
-      next unless m.include?("?")
-
-      define_method m.to_sym do
-        method(m.tr("?", "").to_sym).call
-      end
-    end
-    attr_accessor :type
-
-    def initialize(backend, path, follow_symlink = true)
-      super(backend, path, follow_symlink)
-      @type = :unknown
-      @exist = false
-    end
-
-    def mounted
-      @mounted ||=
-        @backend.run_command("mount | grep -- ' on #{@path}'")
-    end
-  end
-end