train 0.29.2 → 0.30.0

data/lib/train/platforms/family.rb

@@ -0,0 +1,26 @@
+# 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
+  end
+end

data/lib/train/platforms/platform.rb

@@ -0,0 +1,80 @@
+# 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 name
+      # Override here incase a updated name was set
+      # during the detect logic
+      @platform[:name] || @name
+    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
+      family_list = Train::Platforms.families
+      family_list.each_value do |k|
+        next if respond_to?(k.name + '?')
+        define_singleton_method(k.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
+      plat_name = name.downcase.tr(' ', '_') + '?'
+      return if respond_to?(plat_name)
+      define_singleton_method(plat_name) do
+        true
+      end
+    end
+  end
+end

data/lib/train/plugins/base_connection.rb

@@ -1,8 +1,4 @@
 # encoding: utf-8
-#
-# Author:: Salim Afiune (<salim@afiunemaya.com.mx>)
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-# Author:: Dominik Richter (<dominik.richter@gmail.com>)
 
 require 'train/errors'
 require 'train/extras'
@@ -19,9 +15,6 @@ class Train::Plugins::Transport
   class BaseConnection
     include Train::Extras
 
-    # Provide access to the files cache.
-    attr_reader :files
-
     # Create a new Connection instance.
     #
     # @param options [Hash] connection options
@@ -29,7 +22,35 @@ class Train::Plugins::Transport
     def initialize(options = nil)
       @options = options || {}
       @logger = @options.delete(:logger) || Logger.new(STDOUT)
-      @files = {}
+      Train::Platforms::Detect::Specifications::OS.load
+
+      # default caching options
+      @cache_enabled = {
+        file: true,
+        command: false,
+      }
+
+      @cache = {}
+      @cache_enabled.each_key do |type|
+        clear_cache(type)
+      end
+    end
+
+    def cache_enabled?(type)
+      @cache_enabled[type.to_sym]
+    end
+
+    # Enable caching types for Train. Currently we support
+    # :file and :command types
+    def enable_cache(type)
+      fail 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)
+      fail 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.
@@ -39,39 +60,45 @@ class Train::Plugins::Transport
 
     def to_json
       {
-        'files' => Hash[@files.map { |x, y| [x, y.to_json] }],
+        'files' => Hash[@cache[:file].map { |x, y| [x, y.to_json] }],
       }
     end
 
     def load_json(j)
       require 'train/transports/mock'
       j['files'].each do |path, jf|
-        @files[path] = Train::Transports::Mock::Connection::File.from_json(jf)
+        @cache[:file][path] = Train::Transports::Mock::Connection::File.from_json(jf)
       end
     end
 
-    # Execute a command using this connection.
-    #
-    # @param command [String] command string to execute
-    # @return [CommandResult] contains the result of running the command
-    def run_command(_command)
-      fail Train::ClientError, "#{self.class} does not implement #run_command()"
+    # Is this a local transport?
+    def local?
+      false
     end
 
     # Get information on the operating system which this transport connects to.
     #
-    # @return [OSCommon] operating system information
-    def os
-      fail Train::ClientError, "#{self.class} does not implement #os()"
+    # @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
 
-    # 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(_path, *_args)
-      fail Train::ClientError, "#{self.class} does not implement #file(...)"
+    # This is the main command call for all connections. This will call the private
+    # run_command_via_connection on the connection with optional caching
+    def run_command(cmd)
+      return run_command_via_connection(cmd) unless cache_enabled?(:command)
+
+      @cache[:command][cmd] ||= run_command_via_connection(cmd)
+    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
@@ -79,7 +106,7 @@ class Train::Plugins::Transport
     #
     # @return [LoginCommand] array of command line tokens
     def login_command
-      fail Train::ClientError, "#{self.class} does not implement #login_command()"
+      fail NotImplementedError, "#{self.class} does not implement #login_command()"
     end
 
     # Block and return only when the remote host is prepared and ready to
@@ -93,6 +120,27 @@ class Train::Plugins::Transport
 
     private
 
+    # Execute a command using this connection.
+    #
+    # @param command [String] command string to execute
+    # @return [CommandResult] contains the result of running the command
+    def run_command_via_connection(_command)
+      fail 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)
+      fail 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

data/lib/train/transports/docker.rb

@@ -69,22 +69,27 @@ class Train::Transports::Docker
       # nothing to do at the moment
     end
 
-    def os
-      @os ||= OS.new(self)
+    def uri
+      if @container.nil?
+        "docker://#{@id}"
+      else
+        "docker://#{@container.id}"
+      end
     end
 
-    def file(path)
-      @files[path] ||=\
-        if os.aix?
-          Train::File::Remote::Aix.new(self, path)
-        elsif os.solaris?
-          Train::File::Remote::Unix.new(self, path)
-        else
-          Train::File::Remote::Linux.new(self, path)
-        end
+    private
+
+    def file_via_connection(path)
+      if os.aix?
+        Train::File::Remote::Aix.new(self, path)
+      elsif os.solaris?
+        Train::File::Remote::Unix.new(self, path)
+      else
+        Train::File::Remote::Linux.new(self, path)
+      end
     end
 
-    def run_command(cmd)
+    def run_command_via_connection(cmd)
       cmd = @cmd_wrapper.run(cmd) unless @cmd_wrapper.nil?
       stdout, stderr, exit_status = @container.exec(
         [
@@ -97,21 +102,5 @@ class Train::Transports::Docker
       # @TODO: differentiate any other error
       raise
     end
-
-    def uri
-      if @container.nil?
-        "docker://#{@id}"
-      else
-        "docker://#{@container.id}"
-      end
-    end
-
-    class OS < OSCommon
-      def initialize(backend)
-        # hardcoded to unix/linux for now, until other operating systems
-        # are supported
-        super(backend, { family: 'unix' })
-      end
-    end
   end
 end

data/lib/train/transports/local.rb

@@ -17,42 +17,41 @@ module Train::Transports
     end
 
     class Connection < BaseConnection
-      require 'train/transports/local_os'
-
       def initialize(options)
         super(options)
         @cmd_wrapper = nil
         @cmd_wrapper = CommandWrapper.load(self, options)
       end
 
-      def run_command(cmd)
-        cmd = @cmd_wrapper.run(cmd) unless @cmd_wrapper.nil?
-        res = Mixlib::ShellOut.new(cmd)
-        res.run_command
-        CommandResult.new(res.stdout, res.stderr, res.exitstatus)
-      rescue Errno::ENOENT => _
-        CommandResult.new('', '', 1)
+      def login_command
+        nil # none, open your shell
       end
 
-      def os
-        @os ||= OS.new(self)
+      def uri
+        'local://'
       end
 
-      def file(path)
-        @files[path] ||= \
-          if os.windows?
-            Train::File::Local::Windows.new(self, path)
-          else
-            Train::File::Local::Unix.new(self, path)
-          end
+      def local?
+        true
       end
 
-      def login_command
-        nil # none, open your shell
+      private
+
+      def run_command_via_connection(cmd)
+        cmd = @cmd_wrapper.run(cmd) unless @cmd_wrapper.nil?
+        res = Mixlib::ShellOut.new(cmd)
+        res.run_command
+        CommandResult.new(res.stdout, res.stderr, res.exitstatus)
+      rescue Errno::ENOENT => _
+        CommandResult.new('', '', 1)
       end
 
-      def uri
-        'local://'
+      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
     end
   end

data/lib/train/transports/mock.rb

@@ -1,7 +1,4 @@
 # encoding: utf-8
-#
-# author: Dominik Richter
-# author: Christoph Hartmann
 
 require 'train/plugins'
 require 'digest'
@@ -34,7 +31,7 @@ module Train::Transports
         'Train::Transports::Mock::Connection::File' =>
           Connection::FileCommon.instance_methods(false),
         'Train::Transports::Mock::Connection::OS' =>
-          Connection::OSCommon.instance_methods(false),
+          Train::Platform.instance_methods(false),
       }
 
       # rubocop:disable Metrics/ParameterLists
@@ -60,13 +57,13 @@ end
 
 class Train::Transports::Mock
   class Connection < BaseConnection
-    attr_accessor :files, :commands
     attr_reader :os
 
     def initialize(conf = nil)
       super(conf)
       mock_os
-      @commands = {}
+      enable_cache(:file)
+      enable_cache(:command)
     end
 
     def uri
@@ -76,13 +73,41 @@ class Train::Transports::Mock
     def mock_os(value = {})
       # if a user passes a nil value, set to an empty hash so the merge still succeeds
       value ||= {}
+      value.each { |k, v| value[k] = 'unknown' if v.nil? }
+      value = { name: 'mock', family: 'mock', release: 'unknown', arch: 'unknown' }.merge(value)
 
-      os_params = { name: 'unknown', family: 'unknown', release: 'unknown', arch: 'unknown' }.merge(value)
-      @os = OS.new(self, os_params)
+      platform = Train::Platforms.name(value[:name])
+      platform.family_hierarchy = mock_os_hierarchy(platform).flatten
+      platform.platform = value
+      platform.add_platform_methods
+      @os = platform
+    end
+
+    def mock_os_hierarchy(plat)
+      plat.families.each_with_object([]) do |(k, _v), memo|
+        memo << k.name
+        memo << mock_os_hierarchy(k) unless k.families.empty?
+      end
+    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)
-      @commands[cmd] = Command.new(stdout || '', stderr || '', exit_status)
+      @cache[:command][cmd] = Command.new(stdout || '', stderr || '', exit_status)
     end
 
     def command_not_found(cmd)
@@ -95,43 +120,32 @@ class Train::Transports::Mock
       mock_command(cmd, nil, nil, 1)
     end
 
-    def run_command(cmd)
-      @commands[cmd] ||
-        @commands[Digest::SHA256.hexdigest cmd.to_s] ||
-        command_not_found(cmd)
-    end
-
     def file_not_found(path)
       STDERR.puts('File not mocked: '+path.to_s) if @options[:verbose]
       File.new(self, path)
     end
 
-    def file(path)
-      @files[path] ||= file_not_found(path)
-    end
-
     def to_s
       'Mock Connection'
     end
-  end
-end
 
-class Train::Transports::Mock::Connection
-  Command = Struct.new(:stdout, :stderr, :exit_status)
-end
+    private
 
-class Train::Transports::Mock::Connection
-  class OS < OSCommon
-    def initialize(backend, desc)
-      super(backend, desc)
+    def run_command_via_connection(cmd)
+      @cache[:command][Digest::SHA256.hexdigest cmd.to_s] ||
+        command_not_found(cmd)
     end
 
-    def detect_family
-      # no op, we do not need to detect the os
+    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)