inspec 4.18.51 → 4.18.85

data/lib/inspec/plugin/v2/loader.rb

@@ -1,321 +0,0 @@
-require "inspec/log"
-require "inspec/version"
-require "inspec/plugin/v2/config_file"
-require "inspec/plugin/v2/filter"
-
-module Inspec::Plugin::V2
-  class Loader
-    attr_reader :conf_file, :registry, :options
-
-    # For {inspec|train}_plugin_name?
-    include Inspec::Plugin::V2::FilterPredicates
-    extend Inspec::Plugin::V2::FilterPredicates
-
-    def initialize(options = {})
-      @options = options
-      @registry = Inspec::Plugin::V2::Registry.instance
-
-      # User plugins are those installed by the user via `inspec plugin install`
-      # and are installed under ~/.inspec/gems
-      unless options[:omit_user_plugins]
-        @conf_file = Inspec::Plugin::V2::ConfigFile.new
-        read_conf_file_into_registry
-      end
-
-      # Old-style (v0, v1) co-distributed plugins were called 'bundles'
-      # and were located in lib/bundles
-      detect_bundled_plugins unless options[:omit_bundles]
-
-      # New-style (v2) co-distributed plugins are in lib/plugins,
-      # and may be safely loaded
-      detect_core_plugins unless options[:omit_core_plugins]
-
-      # Identify plugins that inspec is co-installed with
-      detect_system_plugins unless options[:omit_sys_plugins]
-    end
-
-    def load_all
-      # This fixes the gem paths on some bundles
-      Gem.path << plugin_gem_path
-      Gem.refresh
-
-      # Be careful not to actually iterate directly over the registry here;
-      # we want to allow "sidecar loading", in which case a plugin may add an entry to the registry.
-      registry.plugin_names.dup.each do |plugin_name|
-        plugin_details = registry[plugin_name]
-        # We want to capture literally any possible exception here, since we are storing them.
-        # rubocop: disable Lint/RescueException
-        begin
-          # We could use require, but under testing, we need to repeatedly reload the same
-          # plugin.  However, gems only work with require (rubygems dooes not overload `load`)
-          if plugin_details.installation_type == :user_gem
-            activate_managed_gems_for_plugin(plugin_name)
-            require plugin_details.entry_point
-          else
-            load_path = plugin_details.entry_point
-            load_path += ".rb" unless plugin_details.entry_point.end_with?(".rb")
-            load load_path
-          end
-          plugin_details.loaded = true
-          annotate_status_after_loading(plugin_name)
-        rescue ::Exception => ex
-          plugin_details.load_exception = ex
-          Inspec::Log.error "Could not load plugin #{plugin_name}: #{ex.message}"
-        end
-        # rubocop: enable Lint/RescueException
-      end
-    end
-
-    # This should possibly be in either lib/inspec/cli.rb or Registry
-    def exit_on_load_error
-      if registry.any_load_failures?
-        Inspec::Log.error "Errors were encountered while loading plugins..."
-        registry.plugin_statuses.select(&:load_exception).each do |plugin_status|
-          Inspec::Log.error "Plugin name: " + plugin_status.name.to_s
-          Inspec::Log.error "Error: " + plugin_status.load_exception.message
-          if ARGV.include?("--debug")
-            Inspec::Log.error "Exception: " + plugin_status.load_exception.class.name
-            Inspec::Log.error "Trace: " + plugin_status.load_exception.backtrace.join("\n")
-          end
-        end
-        Inspec::Log.error("Run again with --debug for a stacktrace.") unless ARGV.include?("--debug")
-        exit 2
-      end
-    end
-
-    def activate_mentioned_cli_plugins(cli_args = ARGV)
-      # Get a list of CLI plugin activation hooks
-      registry.find_activators(plugin_type: :cli_command).each do |act|
-        next if act.activated?
-
-        # Decide whether to activate.  Several conditions, so split them out for clarity.
-        # Assume no, to start.  Each condition may flip it true, which will short-circuit
-        # all following ||= ops.
-        activate_me = false
-
-        # If the user invoked `inspec help`, `inspec --help`, or only `inspec`
-        # then activate all CLI plugins so they can display their usage message.
-        activate_me ||= ["help", "--help", nil].include?(cli_args.first)
-
-        # If there is anything in the CLI args with the same name, activate it.
-        # This is the expected usual activation for individual plugins.
-        # `inspec dosomething` => activate the :dosomething hook
-        activate_me ||= cli_args.include?(act.activator_name.to_s)
-
-        # OK, activate.
-        if activate_me
-          act.activate
-          act.implementation_class.register_with_thor
-        end
-      end
-    end
-
-    def plugin_gem_path
-      self.class.plugin_gem_path
-    end
-
-    def self.plugin_gem_path
-      require "rbconfig"
-      ruby_abi_version = RbConfig::CONFIG["ruby_version"]
-      # TODO: why are we installing under the api directory for plugins?
-      base_dir = Inspec.config_dir
-      base_dir = File.realpath base_dir if File.exist? base_dir
-      File.join(base_dir, "gems", ruby_abi_version)
-    end
-
-    # Lists all gems found in the plugin_gem_path.
-    # @return [Array[Gem::Specification]] Specs of all gems found.
-    def self.list_managed_gems
-      Dir.glob(File.join(plugin_gem_path, "specifications", "*.gemspec")).map { |p| Gem::Specification.load(p) }
-    end
-
-    def list_managed_gems
-      self.class.list_managed_gems
-    end
-
-    # Lists all plugin gems found in the plugin_gem_path.
-    # This is simply all gems that begin with train- or inspec-
-    # and are not on the exclusion list.
-    # @return [Array[Gem::Specification]] Specs of all gems found.
-    def self.list_installed_plugin_gems
-      list_managed_gems.select { |spec| valid_plugin_name?(spec.name) }
-    end
-
-    def list_installed_plugin_gems
-      self.class.list_managed_gems
-    end
-
-    private
-
-    # 'Activating' a gem adds it to the load path, so 'require "gemname"' will work.
-    # Given a gem name, this activates the gem and all of its dependencies, respecting
-    # version pinning needs.
-    def activate_managed_gems_for_plugin(plugin_gem_name, version_constraint = "> 0")
-      # TODO: enforce first-level version pinning
-      plugin_deps = [Gem::Dependency.new(plugin_gem_name.to_s, version_constraint)]
-      managed_gem_set = Gem::Resolver::VendorSet.new
-      list_managed_gems.each { |spec| managed_gem_set.add_vendor_gem(spec.name, spec.gem_dir) }
-
-      # TODO: Next two lines merge our managed gems with the other gems available
-      # in our "local universe" - which may be the system, or it could be in a Bundler microcosm,
-      # or rbenv, etc. Do we want to merge that, though?
-      distrib_gem_set = Gem::Resolver::CurrentSet.new
-      installed_gem_set = Gem::Resolver.compose_sets(managed_gem_set, distrib_gem_set)
-
-      # So, given what we need, and what we have available, what activations are needed?
-      resolver = Gem::Resolver.new(plugin_deps, installed_gem_set)
-      begin
-        solution = resolver.resolve
-      rescue Gem::UnsatisfiableDependencyError => gem_ex
-        # If you broke your install, or downgraded to a plugin with a bad gemspec, you could get here.
-        ex = Inspec::Plugin::V2::LoadError.new(gem_ex.message)
-        raise ex
-      end
-      solution.each do |activation_request|
-        next if activation_request.full_spec.activated?
-
-        activation_request.full_spec.activate
-        # TODO: If we are under Bundler, inform it that we loaded a gem
-      end
-    end
-
-    def annotate_status_after_loading(plugin_name)
-      status = registry[plugin_name]
-      return if status.api_generation == 2 # Gen2 have self-annotating superclasses
-      return if status.api_generation == :'train-1' # Train plugins are here as a courtesy, don't poke them
-
-      case status.installation_type
-      when :bundle
-        annotate_bundle_plugin_status_after_load(plugin_name)
-      else
-        # TODO: are there any other cases? can this whole thing be eliminated?
-        raise "I only know how to annotate :bundle plugins when trying to load plugin #{plugin_name}" unless status.installation_type == :bundle
-      end
-    end
-
-    def annotate_bundle_plugin_status_after_load(plugin_name)
-      # HACK: we're relying on the fact that all bundles are gen0 and cli type
-      status = registry[plugin_name]
-      status.api_generation = 0
-      act = Activator.new
-      act.activated = true
-      act.plugin_type = :cli_command
-      act.plugin_name = plugin_name
-      act.activator_name = :default
-      status.activators = [act]
-
-      v0_subcommand_name = plugin_name.to_s.gsub("inspec-", "")
-      status.plugin_class = Inspec::Plugins::CLI.subcommands[v0_subcommand_name][:klass]
-    end
-
-    def detect_bundled_plugins
-      bundle_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "bundles"))
-      globs = [
-        File.join(bundle_dir, "inspec-*.rb"),
-        File.join(bundle_dir, "train-*.rb"),
-      ]
-      Dir.glob(globs).each do |loader_file|
-        name = File.basename(loader_file, ".rb").to_sym
-        status = Inspec::Plugin::V2::Status.new
-        status.name = name
-        status.entry_point = loader_file
-        status.installation_type = :bundle
-        status.loaded = false
-        registry[name] = status
-      end
-    end
-
-    def detect_core_plugins
-      core_plugins_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "plugins"))
-      # These are expected to be organized as proper separate projects,
-      # with lib/ dirs, etc.
-      Dir.glob(File.join(core_plugins_dir, "inspec-*")).each do |plugin_dir|
-        status = Inspec::Plugin::V2::Status.new
-        status.name = File.basename(plugin_dir).to_sym
-        status.entry_point = File.join(plugin_dir, "lib", status.name.to_s + ".rb")
-        status.installation_type = :core
-        status.loaded = false
-        registry[status.name.to_sym] = status
-      end
-    end
-
-    def read_conf_file_into_registry
-      conf_file.each do |plugin_entry|
-        status = Inspec::Plugin::V2::Status.new
-        status.name = plugin_entry[:name]
-        status.loaded = false
-        status.installation_type = (plugin_entry[:installation_type] || :user_gem)
-        case status.installation_type
-        when :user_gem
-          status.entry_point = status.name.to_s
-          status.version = plugin_entry[:version]
-        when :path
-          status.entry_point = plugin_entry[:installation_path]
-        end
-
-        # Train plugins are not true InSpec plugins; we need to decorate them a
-        # bit more to integrate them.
-        fixup_train_plugin_status(status) if train_plugin_name?(plugin_entry[:name])
-
-        registry[status.name] = status
-      end
-    end
-
-    def fixup_train_plugin_status(status)
-      status.api_generation = :'train-1'
-      if status.installation_type == :user_gem
-        # Activate the gem. This allows train to 'require' the gem later.
-        activate_managed_gems_for_plugin(status.entry_point)
-      end
-    end
-
-    def find_inspec_gemspec(name, ver)
-      Gem::Specification.find_by_name(name, ver)
-    rescue Gem::MissingSpecError
-      nil
-    end
-
-    def detect_system_plugins
-      # Find the gemspec for inspec
-      inspec_gemspec =
-        find_inspec_gemspec("inspec",      "=#{Inspec::VERSION}") ||
-        find_inspec_gemspec("inspec-core", "=#{Inspec::VERSION}")
-
-      unless inspec_gemspec
-        Inspec::Log.warn "inspec gem not found, skipping detecting of system plugins"
-        return
-      end
-
-      # Make a RequestSet that represents the dependencies of inspec
-      inspec_deps_request_set = Gem::RequestSet.new(*inspec_gemspec.dependencies)
-      inspec_deps_request_set.remote = false
-
-      # Resolve the request against the installed gem universe
-      gem_resolver = Gem::Resolver::CurrentSet.new
-      runtime_solution = inspec_deps_request_set.resolve(gem_resolver)
-
-      inspec_gemspec.dependencies.each do |inspec_dep|
-        next unless inspec_plugin_name?(inspec_dep.name) || train_plugin_name?(inspec_dep.name)
-
-        plugin_spec = runtime_solution.detect { |s| s.name == inspec_dep.name }.spec
-
-        status = Inspec::Plugin::V2::Status.new
-        status.name = inspec_dep.name
-        status.entry_point = inspec_dep.name # gem-based, just 'require' the name
-        status.version = plugin_spec.version.to_s
-        status.loaded = false
-        status.installation_type = :system_gem
-
-        if train_plugin_name?(status[:name])
-          # Train plugins are not true InSpec plugins; we need to decorate them a
-          # bit more to integrate them.
-          fixup_train_plugin_status(status)
-        else
-          status.api_generation = 2
-        end
-
-        registry[status.name.to_sym] = status
-      end
-    end
-  end
-end

data/lib/inspec/plugin/v2/plugin_base.rb

@@ -1,112 +0,0 @@
-module Inspec::Plugin::V2
-  # Base class for all plugins.  Specific plugin types *may* inherit from this; but they must register with it.
-  class PluginBase
-    # rubocop: disable Style/ClassVars
-    @@plugin_type_classes = {}
-    # rubocop: enable Style/ClassVars
-
-    #=====================================================================#
-    #                         Management Methods
-    #=====================================================================#
-
-    # The global registry.
-    # @returns [Inspec::Plugin::V2::Registry] the singleton Plugin Registry object.
-    def self.registry
-      Inspec::Plugin::V2::Registry.instance
-    end
-
-    # Inform the plugin system of a new plgin type.
-    # This has the following effects:
-    #  * enables Inspec.plugin(2, :your_type_here) to return the plugin
-    #    type base class
-    #  * defines the DSL method with the same name as the plugin type.
-    #
-    # @param [Symbol] plugin_type_name
-    # @param [Class] the plugin type class, defaults to assuming inheritance
-    def self.register_plugin_type(plugin_type_name, new_plugin_type_base_class = self)
-      new_dsl_method_name = plugin_type_name
-
-      # This lets the Inspec.plugin(2,:your_plugin_type) work
-      @@plugin_type_classes[plugin_type_name] = new_plugin_type_base_class
-
-      # This part defines the DSL command to register a concrete plugin's implementation of a plugin type
-      Inspec::Plugin::V2::PluginBase.define_singleton_method(new_dsl_method_name) do |hook_name, &hook_body|
-        plugin_concrete_class = self
-
-        # Verify class is registered (i.e. plugin_name has been called)
-        status = registry.find_status_by_class(plugin_concrete_class)
-        if status.nil?
-          raise Inspec::Plugin::V2::LoadError, "You must call 'plugin_name' prior to calling #{plugin_type_name} for plugin class #{plugin_concrete_class}"
-        end
-
-        # Construct the Activator record
-        activator = Inspec::Plugin::V2::Activator.new
-        activator.plugin_name = plugin_concrete_class.plugin_name
-        activator.plugin_type = plugin_type_name
-        activator.activator_name = hook_name.to_sym
-        activator.activation_proc = hook_body
-
-        status.activators << activator
-      end
-    end
-
-    # Determine the base class for a given plugin type
-    # @param [Symbol] plugin_type_name
-    # @returns [Class] the plugin type base class
-    def self.base_class_for_type(plugin_type_name)
-      @@plugin_type_classes[plugin_type_name]
-    end
-
-    def self.find_name_by_implementation_class(impl_class)
-      # This is super awkward
-      activators = Inspec::Plugin::V2::Registry.instance.find_activators
-      activator = activators.detect { |a| a.implementation_class == impl_class }
-      activator.plugin_name
-    end
-
-    #=====================================================================#
-    #                           DSL Methods
-    #=====================================================================#
-
-    # If no name provided, looks up a known plugin by class and returns the name.
-    #
-    # DSL method to declare a plugin.  Once this has been called, the plugin will certainly be
-    # registered (known) with the Registry, and is eligible to be activated.
-    # This mainly handles status annotation.
-    #
-    # @param [Symbol] Name of the plugin.  If a string is provided, it is converted to a Symbol.
-    # @returns [Symbol] Name of the plugin
-    def self.plugin_name(name = nil)
-      reg = Inspec::Plugin::V2::Registry.instance
-      if name.nil?
-        # If called from a Plugin definition class...
-        stat = reg.find_status_by_class(self)
-        return stat.name if stat
-
-        # Called from an implementation class
-        return find_name_by_implementation_class(self)
-      end
-
-      name = name.to_sym
-
-      # Typically our status will already exist in the registry, from loading the
-      # plugin.json. If we're being loaded, presumably entry_point,
-      # installation_type, version
-      # are known.
-      unless reg.known_plugin?(name)
-        # Under some testing situations, we may not pre-exist.
-        status = Inspec::Plugin::V2::Status.new
-        reg.register(name, status)
-        status.entry_point = "inline"
-        status.installation_type = :mock_inline
-      end
-
-      status = reg[name]
-      status.api_generation = 2
-      status.plugin_class = self
-      status.name = name
-
-      name
-    end
-  end
-end

data/lib/inspec/plugin/v2/plugin_types/cli.rb

@@ -1,49 +0,0 @@
-require "inspec/base_cli"
-
-# The InSpec load order has this file being loaded before `inspec/base_cli` can
-# finish being loaded. So, we must define Inspec::BaseCLI here first to avoid
-# a NameError below.
-class Inspec::BaseCLI < Thor; end
-
-module Inspec::Plugin::V2::PluginType
-  class CliCommand < Inspec::BaseCLI
-    # initialize log options for plugins
-    def initialize(args, options, config)
-      super(args, options, config)
-      class_options = config.fetch(:class_options, nil)
-      if class_options
-        Inspec::Log.init(class_options["log_location"]) if class_options.key?("log_location")
-        Inspec::Log.level = get_log_level(class_options["log_level"]) if class_options.key?("log_level")
-      end
-    end
-
-    # This class MUST inherit from Thor, which makes it a bit awkward to register the plugin subtype
-    # Since we can't inherit from PluginBase, we use the two-arg form of register_plugin_type
-    Inspec::Plugin::V2::PluginBase.register_plugin_type(:cli_command, self)
-
-    # Provide a description for the command group.
-    def self.subcommand_desc(usage_msg, desc_msg)
-      @usage_msg = usage_msg
-      @desc_msg = desc_msg
-    end
-
-    # Register the command group with Thor.  This must be called on the implementation class AFTER
-    # the the cli_command activator has been called
-    def self.register_with_thor
-      # Figure out my activator name (= subcommand group name)
-      subcommand_name = Inspec::Plugin::V2::Registry.instance \
-        .find_activators(plugin_type: :cli_command, implementation_class: self) \
-        .first.activator_name.to_s
-
-      # Register with Thor
-      Inspec::InspecCLI.register(self, subcommand_name, @usage_msg, @desc_msg, {})
-    end
-
-    # Allow plugins to use inspec log settings
-    class_option :log_level, type: :string,
-                 desc: "Set the log level: info (default), debug, warn, error"
-
-    class_option :log_location, type: :string,
-                desc: "Location to send diagnostic log messages to. (default: $stdout or Inspec::Log.error)"
-  end
-end