train 3.2.14 → 3.2.20

data/lib/train/platforms/detect/uuid.rb

@@ -1,32 +0,0 @@
-require "digest/sha1"
-require "securerandom"
-require "json"
-
-module Train::Platforms::Detect
-  class UUID
-    include Train::Platforms::Detect::Helpers::OSCommon
-
-    def initialize(platform)
-      @platform = platform
-      @backend = @platform.backend
-    end
-
-    def find_or_create_uuid
-      # for api transports uuid is defined on the connection
-      if defined?(@backend.unique_identifier)
-        uuid_from_string(@backend.unique_identifier)
-      elsif @platform.unix?
-        unix_uuid
-      elsif @platform.windows?
-        windows_uuid
-      else
-        if @platform[:uuid_command]
-          result = @backend.run_command(@platform[:uuid_command])
-          return uuid_from_string(result.stdout.chomp) if result.exit_status == 0 && !result.stdout.empty?
-        end
-
-        raise "Could not find platform uuid! Please set a uuid_command for your platform."
-      end
-    end
-  end
-end

data/lib/train/platforms/family.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-module Train::Platforms
-  class Family
-    include Train::Platforms::Common
-    attr_accessor :children, :condition, :families, :name
-
-    def initialize(name, condition)
-      @name = name
-      @condition = condition
-      @families = {}
-      @children = {}
-      @detect = nil
-      @title = "#{name.to_s.capitalize} Family"
-
-      # add itself to the families list
-      Train::Platforms.families[@name.to_s] = self
-    end
-
-    def title(title = nil)
-      return @title if title.nil?
-
-      @title = title
-      self
-    end
-
-    def inspect
-      "%p[%s]" % [self.class, name]
-    end
-  end
-end

data/lib/train/platforms/platform.rb

@@ -1,109 +0,0 @@
-# encoding: utf-8
-
-module Train::Platforms
-  class Platform
-    include Train::Platforms::Common
-    attr_accessor :backend, :condition, :families, :family_hierarchy, :platform
-
-    def initialize(name, condition = {})
-      @name = name
-      @condition = condition
-      @families = {}
-      @family_hierarchy = []
-      @platform = {}
-      @detect = nil
-      @title = name.to_s.capitalize
-
-      # add itself to the platform list
-      Train::Platforms.list[name] = self
-    end
-
-    def direct_families
-      @families.collect { |k, _v| k.name }
-    end
-
-    def find_family_hierarchy(platform = self)
-      families = platform.families.map { |k, v| [k.name, find_family_hierarchy(k)] }
-
-      @family_hierarchy = families.flatten
-    end
-
-    def family
-      @platform[:family] || @family_hierarchy[0]
-    end
-
-    def name
-      # Override here incase a updated name was set
-      # during the detect logic
-      clean_name
-    end
-
-    def clean_name(force: false)
-      @cleaned_name = nil if force
-      @cleaned_name ||= (@platform[:name] || @name).downcase.tr(" ", "_")
-    end
-
-    def uuid
-      @uuid ||= Train::Platforms::Detect::UUID.new(self).find_or_create_uuid.downcase
-    end
-
-    # This is for backwords compatability with
-    # the current inspec os resource.
-    def[](name)
-      if respond_to?(name)
-        send(name)
-      else
-        "unknown"
-      end
-    end
-
-    def title(title = nil)
-      return @title if title.nil?
-
-      @title = title
-      self
-    end
-
-    def to_hash
-      @platform
-    end
-
-    # Add generic family? and platform methods to an existing platform
-    #
-    # This is done later to add any custom
-    # families/properties that were created
-    def add_platform_methods
-      # Redo clean name if there is a detect override
-      clean_name(force: true) unless @platform[:name].nil?
-
-      # Add in family methods
-      family_list = Train::Platforms.families
-      family_list.each_value do |k|
-        name = "#{k.name}?"
-
-        next if respond_to?(name)
-
-        define_singleton_method(name) do
-          family_hierarchy.include?(k.name)
-        end
-      end
-
-      # Helper methods for direct platform info
-      @platform.each_key do |m|
-        next if respond_to?(m)
-
-        define_singleton_method(m) do
-          @platform[m]
-        end
-      end
-
-      # Create method for name if its not already true
-      m = name + "?"
-      return if respond_to?(m)
-
-      define_singleton_method(m) do
-        true
-      end
-    end
-  end
-end

data/lib/train/plugin_test_helper.rb

@@ -1,51 +0,0 @@
-# This file is intended to be 'require'd by plugin authors who are developing a
-# plugin outside of the Train source tree.
-
-# Load Train.  We certainly need the plugin system, and also several other parts
-# that are tightly coupled.  Train itself is fairly light, and non-invasive.
-require_relative "../train"
-
-# You can select from a number of test harnesses.  Since Train is closely related
-# to InSpec, and InSpec uses Spec-style controls in profile code, you will
-# probably want to use something like minitest/spec, which provides Spec-style
-# tests.
-require "minitest/spec"
-require "minitest/autorun"
-
-# Data formats commonly used in testing
-require "json"
-require "ostruct"
-
-# Utilities often needed
-require "fileutils"
-require "tmpdir"
-require "pathname"
-
-# You might want to put some debugging tools here.  We run tests to find bugs,
-# after all.
-require "byebug"
-
-# Configure MiniTest to expose things like `let`
-class Module
-  include Minitest::Spec::DSL
-end
-
-# Finally, let's make some modules that can help us out.
-module TrainPluginBaseHelper
-  # Sneakily detect the location of the plugin
-  # source code when they include this Module
-  def self.included(base)
-    plugin_test_helper_path = Pathname.new(caller_locations(4, 1).first.absolute_path)
-    plugin_src_root = plugin_test_helper_path.parent.parent
-    base.let(:plugin_src_path) { plugin_src_root }
-    base.let(:plugin_fixtures_path) { File.join(plugin_src_root, "test", "fixtures") }
-  end
-
-  let(:train_src_path) { File.expand_path(File.join(__FILE__, "..", "..")) }
-  let(:train_fixtures_path) { File.join(train_src_path, "test", "fixtures") }
-  let(:registry) { Train::Plugins.registry }
-end
-
-module TrainPluginFunctionalHelper
-  include TrainPluginBaseHelper
-end

data/lib/train/plugins.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-#
-# Author:: Dominik Richter (<dominik.richter@gmail.com>)
-# Author:: Christoph Hartmann (<chris@lollyrock.com>)
-
-require_relative "errors"
-
-module Train
-  class Plugins
-    require_relative "plugins/transport"
-
-    class << self
-      # Retrieve the current plugin registry, containing all plugin names
-      # and their transport handlers.
-      #
-      # @return [Hash] map with plugin names and plugins
-      def registry
-        @registry ||= {}
-      end
-    end
-  end
-
-  # Create a new plugin by inheriting from the class returned by this method.
-  # Create a versioned plugin by providing the transport layer plugin version
-  # to this method. It will then select the correct class to inherit from.
-  #
-  # The plugin version determins what methods will be available to your plugin.
-  #
-  # @param [Int] version = 1 the plugin version to use
-  # @return [Transport] the versioned transport base class
-  def self.plugin(version = 1)
-    if version != 1
-      raise ClientError,
-        "Only understand train plugin version 1. You are trying to "\
-        "initialize a train plugin #{version}, which is not supported "\
-        "in the current release of train."
-    end
-    ::Train::Plugins::Transport
-  end
-end

data/lib/train/plugins/base_connection.rb

@@ -1,198 +0,0 @@
-# encoding: utf-8
-
-require_relative "../errors"
-require_relative "../extras"
-require_relative "../file"
-require "logger"
-
-class Train::Plugins::Transport
-  # A Connection instance can be generated and re-generated, given new
-  # connection details such as connection port, hostname, credentials, etc.
-  # This object is responsible for carrying out the actions on the remote
-  # host such as executing commands, transferring files, etc.
-  #
-  # @author Fletcher Nichol <fnichol@nichol.ca>
-  class BaseConnection
-    include Train::Extras
-
-    # Create a new Connection instance.
-    #
-    # @param options [Hash] connection options
-    # @yield [self] yields itself for block-style invocation
-    def initialize(options = nil)
-      @options = options || {}
-      @logger = @options.delete(:logger) || Logger.new($stdout, level: :fatal)
-      Train::Platforms::Detect::Specifications::OS.load
-      Train::Platforms::Detect::Specifications::Api.load
-
-      # default caching options
-      @cache_enabled = {
-        file: true,
-        command: false,
-        api_call: false,
-      }
-
-      @cache = {}
-      @cache_enabled.each_key do |type|
-        clear_cache(type)
-      end
-    end
-
-    def with_sudo_pty
-      yield
-    end
-
-    # Returns cached client if caching enabled. Otherwise returns whatever is
-    # given in the block.
-    #
-    # @example
-    #
-    #   def demo_client
-    #     cached_client(:api_call, :demo_connection) do
-    #       DemoClient.new(args)
-    #     end
-    #   end
-    #
-    # @param [symbol] type one of [:api_call, :file, :command]
-    # @param [symbol] key for your cached connection
-    def cached_client(type, key)
-      return yield unless cache_enabled?(type)
-
-      @cache[type][key] ||= yield
-    end
-
-    def cache_enabled?(type)
-      @cache_enabled[type.to_sym]
-    end
-
-    # Enable caching types for Train. Currently we support
-    # :api_call, :file and :command types
-    def enable_cache(type)
-      raise Train::UnknownCacheType, "#{type} is not a valid cache type" unless @cache_enabled.keys.include?(type.to_sym)
-
-      @cache_enabled[type.to_sym] = true
-    end
-
-    def disable_cache(type)
-      raise Train::UnknownCacheType, "#{type} is not a valid cache type" unless @cache_enabled.keys.include?(type.to_sym)
-
-      @cache_enabled[type.to_sym] = false
-      clear_cache(type.to_sym)
-    end
-
-    # Closes the session connection, if it is still active.
-    def close
-      # this method may be left unimplemented if that is applicable
-    end
-
-    def to_json
-      {
-        "files" => Hash[@cache[:file].map { |x, y| [x, y.to_json] }],
-      }
-    end
-
-    def load_json(j)
-      require_relative "../transports/mock"
-      j["files"].each do |path, jf|
-        @cache[:file][path] = Train::Transports::Mock::Connection::File.from_json(jf)
-      end
-    end
-
-    def force_platform!(name, platform_details = nil)
-      plat = Train::Platforms.name(name)
-      plat.backend = self
-      plat.platform = platform_details unless platform_details.nil?
-      plat.find_family_hierarchy
-      plat.add_platform_methods
-      plat
-    end
-
-    def inspect
-      "%s[%s]" % [self.class, (@options[:backend] || "Unknown")]
-    end
-
-    alias direct_platform force_platform!
-
-    # Get information on the operating system which this transport connects to.
-    #
-    # @return [Platform] system information
-    def platform
-      @platform ||= Train::Platforms::Detect.scan(self)
-    end
-    # we need to keep os as a method for backwards compatibility with inspec
-    alias os platform
-
-    # This is the main command call for all connections. This will call the private
-    # run_command_via_connection on the connection with optional caching
-    #
-    # This command accepts an optional data handler block. When provided,
-    # inbound data will be published vi `data_handler.call(data)`. This can allow
-    # callers to receive and render updates from remote command execution.
-    def run_command(cmd, &data_handler)
-      return run_command_via_connection(cmd, &data_handler) unless cache_enabled?(:command)
-
-      @cache[:command][cmd] ||= run_command_via_connection(cmd, &data_handler)
-    end
-
-    # This is the main file call for all connections. This will call the private
-    # file_via_connection on the connection with optional caching
-    def file(path, *args)
-      return file_via_connection(path, *args) unless cache_enabled?(:file)
-
-      @cache[:file][path] ||= file_via_connection(path, *args)
-    end
-
-    # Builds a LoginCommand which can be used to open an interactive
-    # session on the remote host.
-    #
-    # @return [LoginCommand] array of command line tokens
-    def login_command
-      raise NotImplementedError, "#{self.class} does not implement #login_command()"
-    end
-
-    # Block and return only when the remote host is prepared and ready to
-    # execute command and upload files. The semantics and details will
-    # vary by implementation, but a round trip through the hosted
-    # service is preferred to simply waiting on a socket to become
-    # available.
-    def wait_until_ready
-      # this method may be left unimplemented if that is applicablelog
-    end
-
-    private
-
-    # Execute a command using this connection.
-    #
-    # @param command [String] command string to execute
-    # @param &data_handler(data) [Proc] proc that is called when data arrives from
-    # the connection.  This block is optional. Individual transports will need
-    # to explicitly invoke the block in their implementation of run_command_via_connection;
-    # if they do not, the block is ignored and will not be used to report data back to the caller.
-    #
-    # @return [CommandResult] contains the result of running the command
-    def run_command_via_connection(_command, &_data_handler)
-      raise NotImplementedError, "#{self.class} does not implement #run_command_via_connection()"
-    end
-
-    # Interact with files on the target. Read, write, and get metadata
-    # from files via the transport.
-    #
-    # @param [String] path which is being inspected
-    # @return [FileCommon] file object that allows for interaction
-    def file_via_connection(_path, *_args)
-      raise NotImplementedError, "#{self.class} does not implement #file_via_connection(...)"
-    end
-
-    def clear_cache(type)
-      @cache[type.to_sym] = {}
-    end
-
-    # @return [Logger] logger for reporting information
-    # @api private
-    attr_reader :logger
-
-    # @return [Hash] connection options
-    # @api private
-    attr_reader :options
-  end
-end