train 3.2.14 → 3.2.20

data/lib/train.rb

@@ -1,193 +0,0 @@
-# encoding: utf-8
-#
-# Author:: Dominik Richter (<dominik.richter@gmail.com>)
-
-require_relative "train/version"
-require_relative "train/options"
-require_relative "train/plugins"
-require_relative "train/errors"
-require_relative "train/platforms"
-require "uri"
-
-module Train
-  # Create a new transport instance, with the plugin indicated by the
-  # given name.
-  #
-  # @param [String] name of the plugin
-  # @param [Array] *args list of arguments for the plugin
-  # @return [Transport] instance of the new transport or nil
-  def self.create(name, *args)
-    cls = load_transport(name)
-    cls.new(*args) unless cls.nil?
-  end
-
-  # Retrieve the configuration options of a transport plugin.
-  #
-  # @param [String] name of the plugin
-  # @return [Hash] map of default options
-  def self.options(name)
-    cls = load_transport(name)
-    cls.default_options unless cls.nil?
-  end
-
-  # Load the transport plugin indicated by name. If the plugin is not
-  # yet found in the plugin registry, it will be attempted to load from
-  # `train/transports/plugin_name`.
-  #
-  # @param [String] name of the plugin
-  # @return [Train::Transport] the transport plugin
-  def self.load_transport(transport_name)
-    transport_name = transport_name.to_s
-    transport_class = Train::Plugins.registry[transport_name]
-    return transport_class unless transport_class.nil?
-
-    # Try to load the transport name from the core transports...
-    require "train/transports/" + transport_name
-    Train::Plugins.registry[transport_name]
-  rescue LoadError => _
-    begin
-      # If it's not in the core transports, try loading from a train plugin gem.
-      gem_name = "train-" + transport_name
-      require gem_name
-      return Train::Plugins.registry[transport_name]
-      # rubocop: disable Lint/HandleExceptions
-    rescue LoadError => _
-      # rubocop: enable Lint/HandleExceptions
-      # Intentionally empty rescue - we're handling it below anyway
-    end
-
-    ex = Train::PluginLoadError.new("Can't find train plugin #{transport_name}. Please install it first.")
-    ex.transport_name = transport_name
-    raise ex
-  end
-
-  # Legacy code to unpack a series of items from an incoming Hash
-  # Inspec::Config.unpack_train_credentials now handles this in most cases that InSpec needs
-  # If you need to unpack a URI, use unpack_target_from_uri
-  # TODO: deprecate; can't issue a warning because train doesn't have a logger until the connection is setup (See base_connection.rb)
-  def self.target_config(config = nil)
-    conf = config.dup
-    # Symbolize keys
-    conf.keys.each do |key|
-      unless key.is_a? Symbol
-        conf[key.to_sym] = conf.delete(key)
-      end
-    end
-
-    group_keys_and_keyfiles(conf) # TODO: move logic into SSH plugin
-    return conf if conf[:target].to_s.empty?
-
-    unpack_target_from_uri(conf[:target], conf).merge(conf)
-  end
-
-  # Given a string that looks like a URI, unpack connection credentials.
-  # The name of the desired transport is always taken from the 'scheme' slot of the URI;
-  # the remaining portion of the URI is parsed as if it were an HTTP URL, and then
-  # the URL components are stored in the credentials hash.  It is up to the transport
-  # to interpret the fields in a sensible way for that transport.
-  # New transport authors are encouraged to use transport://credset format (see
-  # inspec/inspec/issues/3661) rather than inventing a new field mapping.
-  def self.unpack_target_from_uri(uri_string, opts = {}) # rubocop: disable Metrics/AbcSize
-    creds = {}
-    return creds if uri_string.empty?
-
-    # split up the target's host/scheme configuration
-    uri = parse_uri(uri_string)
-    unless uri.host.nil? && uri.scheme.nil?
-      creds[:backend]  ||= uri.scheme
-      creds[:host]     ||= uri.hostname
-      creds[:port]     ||= uri.port
-      creds[:user]     ||= uri.user
-      creds[:path]     ||= uri.path
-      creds[:password] ||=
-        if opts[:www_form_encoded_password] && !uri.password.nil?
-          URI.decode_www_form_component(uri.password)
-        else
-          uri.password
-        end
-    end
-
-    # ensure path is nil, if its empty; e.g. required to reset defaults for winrm # TODO: move logic into winrm plugin
-    creds[:path] = nil if !creds[:path].nil? && creds[:path].to_s.empty?
-
-    # compact! is available in ruby 2.4+
-    # TODO: rewrite next line using compact! once we drop support for ruby 2.3
-    creds = creds.delete_if { |_, value| value.nil? }
-
-    # return the updated config
-    creds
-  end
-
-  # Parse a URI. Supports empty URI's with paths, e.g. `mock://`
-  #
-  # @param string [string] URI string, e.g. `schema://domain.com`
-  # @return [URI::Generic] parsed URI object
-  def self.parse_uri(string)
-    URI.parse(string)
-  rescue URI::InvalidURIError => e
-    # A use-case we want to catch is parsing empty URIs with a schema
-    # e.g. mock://. To do this, we match it manually and fake the hostname
-    case string
-    when %r{^([a-z]+)://$}
-      string += "dummy"
-    when /^([a-z]+):$/
-      string += "//dummy"
-    else
-      raise Train::UserError, e
-    end
-
-    uri = URI.parse(string)
-    uri.host = nil
-    uri
-  end
-  private_class_method :parse_uri
-
-  # Examine the given credential information, and if all is well,
-  # return the transport name.
-  # TODO: this actually does no validation of the credential options whatsoever
-  def self.validate_backend(credentials, default_transport_name = "local")
-    return default_transport_name if credentials.nil?
-
-    transport_name = credentials[:backend]
-
-    # TODO: Determine if it is ever possible (or supported) for transport_name to be 'localhost'
-    # TODO: After inspec/inspec/pull/3750 is merged, should be able to remove nil from the list
-    if credentials[:sudo] && [nil, "local", "localhost"].include?(transport_name)
-      raise Train::UserError, "Sudo is only valid when running against a remote host. "\
-        "To run this locally with elevated privileges, run the command with `sudo ...`."
-    end
-
-    return transport_name unless transport_name.nil?
-
-    unless credentials[:target].nil?
-      # We should not get here, because if target_uri unpacking was successful,
-      # it would have set credentials[:backend]
-      raise Train::UserError, "Cannot determine backend from target "\
-           "configuration #{credentials[:target]}. Valid example: ssh://192.168.0.1"
-    end
-
-    unless credentials[:host].nil?
-      raise Train::UserError, "Host configured, but no backend was provided. Please "\
-           "specify how you want to connect. Valid example: ssh://192.168.0.1"
-    end
-
-    credentials[:backend] = default_transport_name
-  end
-
-  def self.group_keys_and_keyfiles(conf)
-    # in case the user specified a key-file, register it that way
-    # we will clear the list of keys and put keys and key_files separately
-    keys_mixed = conf[:keys]
-    return if keys_mixed.nil?
-
-    conf[:key_files] = []
-    conf[:keys] = []
-    keys_mixed.each do |key|
-      if !key.nil? && File.file?(key)
-        conf[:key_files].push(key)
-      else
-        conf[:keys].push(key)
-      end
-    end
-  end
-end

data/lib/train/errors.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-#
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-# Author:: Dominik Richter (<dominik.richter@gmail.com>)
-# Author:: Christoph Hartmann (<chris@lollyrock.com>)
-#
-# Copyright (C) 2013, Fletcher Nichol
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-
-module Train
-  # Base exception for any exception explicitly raised by the Train library.
-  class Error < ::StandardError
-    attr_reader :reason
-
-    def initialize(message = "", reason = :not_provided)
-      super(message)
-      @reason = reason
-    end
-  end
-
-  # Base exception class for all exceptions that are caused by user input
-  # errors.
-  class UserError < Error; end
-
-  # We could not load a plugin, because of a user error
-  class PluginLoadError < UserError
-    attr_accessor :transport_name
-  end
-
-  # Base exception class for all exceptions that are caused by incorrect use
-  # of an API.
-  class ClientError < Error; end
-
-  # Base exception class for all exceptions that are caused by other failures
-  # in the transport layer.
-  class TransportError < Error; end
-
-  # Exception for when no platform can be detected.
-  class PlatformDetectionFailed < Error; end
-
-  # Exception for when a invalid cache type is passed.
-  class UnknownCacheType < Error; end
-end

data/lib/train/extras.rb

@@ -1,11 +0,0 @@
-# encoding: utf-8
-#
-# Author:: Dominik Richter (<dominik.richter@gmail.com>)
-
-module Train::Extras
-  require_relative "extras/command_wrapper"
-  require_relative "extras/stat"
-
-  CommandResult = Struct.new(:stdout, :stderr, :exit_status)
-  LoginCommand = Struct.new(:command, :arguments)
-end

data/lib/train/extras/command_wrapper.rb

@@ -1,201 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require "base64"
-require_relative "../errors"
-
-module Train::Extras
-  # Define the interface of all command wrappers.
-  class CommandWrapperBase
-    # Verify that the command wrapper is initialized properly and working.
-    #
-    # @return [Any] verification result, nil if all went well, otherwise a message
-    def verify
-      raise Train::ClientError, "#{self.class} does not implement #verify()"
-    end
-
-    # Wrap a command and return the augmented command which can be executed.
-    #
-    # @param [Strin] command that will be wrapper
-    # @return [String] result of wrapping the command
-    def run(_command)
-      raise Train::ClientError, "#{self.class} does not implement #run(command)"
-    end
-  end
-
-  # Wrap linux commands and add functionality like sudo.
-  class LinuxCommand < CommandWrapperBase
-    Train::Options.attach(self)
-
-    option :shell,         default: false
-    option :shell_options, default: nil
-    option :shell_command, default: nil
-    option :sudo,          default: false
-    option :sudo_options,  default: nil
-    option :sudo_password, default: nil
-    option :sudo_command,  default: nil
-    option :user
-
-    attr_reader :backend
-
-    def initialize(backend, options)
-      @backend = backend
-      validate_options(options)
-
-      @shell         = options[:shell]
-      @shell_options = options[:shell_options] # e.g. '--login'
-      @shell_command = options[:shell_command] # e.g. '/bin/sh'
-      @sudo          = options[:sudo]
-      @sudo_options  = options[:sudo_options]
-      @sudo_password = options[:sudo_password]
-      @sudo_command  = options[:sudo_command]
-      @user          = options[:user]
-    end
-
-    # (see CommandWrapperBase::verify)
-    def verify
-      cmd = if @sudo
-              # Wrap it up. It needs /dev/null on the outside to disable stdin
-              # NOTE: can't use @sudo_command because -v conflicts with -E.
-              #       See test-kitchen's use of this variable for conflict.
-              "sh -c '(sudo -v) < /dev/null'"
-            else
-              run("echo")
-            end
-
-      # rubocop:disable Style/BlockDelimiters
-      res = @backend.with_sudo_pty {
-        @backend.run_command(cmd)
-      }
-      return nil if res.exit_status == 0
-
-      rawerr = "#{res.stdout} #{res.stderr}".strip
-
-      case rawerr
-      when "Sorry, try again"
-        ["Wrong sudo password.", :bad_sudo_password]
-      when "sudo: no tty present and no askpass program specified"
-        ["Sudo requires a password, please configure it.", :sudo_password_required]
-      when "sudo: command not found"
-        ["Can't find sudo command. Please either install and "\
-          "configure it on the target or deactivate sudo.", :sudo_command_not_found]
-      when "sudo: sorry, you must have a tty to run sudo"
-        ["Sudo requires a TTY. Please see the README on how to configure "\
-          "sudo to allow for non-interactive usage.", :sudo_no_tty]
-      else
-        [rawerr, nil]
-      end
-    end
-
-    def verify!
-      msg, reason = verify
-      return nil unless msg
-
-      raise Train::UserError.new("Sudo failed: #{msg}", reason)
-    end
-
-    # (see CommandWrapperBase::run)
-    def run(command)
-      shell_wrap(sudo_wrap(command))
-    end
-
-    def self.active?(options)
-      options.is_a?(Hash) && (
-        options[:sudo] ||
-        options[:shell]
-      )
-    end
-
-    private
-
-    # wrap the cmd in a sudo command
-    def sudo_wrap(cmd)
-      return cmd unless @sudo
-      return cmd if @user == "root"
-
-      res = (@sudo_command || "sudo") + " "
-
-      if @sudo_password
-        str = safe_string(@sudo_password + "\n")
-        res = "#{str} | #{res}-S "
-      end
-
-      res << "#{@sudo_options} " if @sudo_options
-
-      res + cmd
-    end
-
-    # wrap the cmd in a subshell allowing for options to
-    # passed to the subshell
-    def shell_wrap(cmd)
-      return cmd unless @shell
-
-      shell = @shell_command || "$SHELL"
-      options = " #{@shell_options}" if @shell_options
-
-      "#{safe_string(cmd)} | #{shell}#{options}"
-    end
-
-    # encapsulates encoding the string into a safe form, and decoding for use.
-    # @return [String] A command line snippet that can be used as part of a pipeline.
-    def safe_string(str)
-      b64str = Base64.strict_encode64(str)
-      "echo #{b64str} | base64 --decode"
-    end
-  end
-
-  # Wrap windows commands.
-  class WindowsCommand < CommandWrapperBase
-    Train::Options.attach(self)
-
-    option :shell_command, default: nil
-
-    def initialize(backend, options)
-      @backend = backend
-      validate_options(options)
-
-      @shell_command = options[:shell_command] # e.g. 'powershell'
-    end
-
-    # (see CommandWrapperBase::run)
-    def run(command)
-      powershell_wrap(command)
-    end
-
-    private
-
-    # Wrap the cmd in an encoded command to allow pipes and quotes
-    def powershell_wrap(cmd)
-      shell = @shell_command || "powershell"
-
-      # Prevent progress stream from leaking into stderr
-      script = "$ProgressPreference='SilentlyContinue';" + cmd
-
-      # Encode script so PowerShell can use it
-      script = script.encode("UTF-16LE", "UTF-8")
-      base64_script = Base64.strict_encode64(script)
-
-      cmd = "#{shell} -NoProfile -EncodedCommand #{base64_script}"
-      cmd
-    end
-  end
-
-  class CommandWrapper
-    include_options LinuxCommand
-    include_options WindowsCommand
-
-    def self.load(transport, options)
-      if transport.platform.unix?
-        return nil unless LinuxCommand.active?(options)
-
-        res = LinuxCommand.new(transport, options)
-        res.verify!
-
-        res
-      elsif transport.platform.windows?
-        WindowsCommand.new(transport, options)
-      end
-    end
-  end
-end