inspec 4.18.51 → 4.18.85

data/lib/inspec/profile_context.rb

@@ -1,203 +0,0 @@
-require "inspec/log"
-require "inspec/rule"
-require "inspec/resource"
-require "inspec/library_eval_context"
-require "inspec/control_eval_context"
-require "inspec/require_loader"
-require "securerandom"
-require "inspec/input_registry"
-
-module Inspec
-  class ProfileContext
-    def self.for_profile(profile, backend)
-      new(profile.name, backend, { "profile" => profile, "check_mode" => profile.check_mode })
-    end
-
-    attr_reader :backend, :profile_name, :profile_id, :resource_registry
-    attr_accessor :rules
-    def initialize(profile_id, backend, conf)
-      if backend.nil?
-        raise "ProfileContext is initiated with a backend == nil. " \
-             "This is a backend error which must be fixed upstream."
-      end
-      @profile_id = profile_id
-      @backend = backend
-      @conf = conf.dup
-      @profile_name = @conf.key?("profile") ? @conf["profile"].profile_name : @profile_id
-      @skip_only_if_eval = @conf["check_mode"]
-      @rules = {}
-      @control_subcontexts = []
-      @lib_subcontexts = []
-      @require_loader = ::Inspec::RequireLoader.new
-      Inspec::InputRegistry.register_profile_alias(@profile_id, @profile_name) if @profile_id != @profile_name
-      # TODO: consider polling input source plugins; this is a bulk fetch opportunity
-
-      # A local resource registry that only contains resources defined
-      # in the transitive dependency tree of the loaded profile.
-      @resource_registry = Inspec::Resource.new_registry
-      @library_eval_context = Inspec::LibraryEvalContext.create(@resource_registry, @require_loader)
-      @current_load = nil
-    end
-
-    def attributes
-      Inspec::AttributeRegistry.list_attributes_for_profile(@profile_id)
-    end
-
-    def dependencies
-      if @conf["profile"].nil?
-        {}
-      else
-        @conf["profile"].locked_dependencies
-      end
-    end
-
-    def to_resources_dsl
-      Inspec::Resource.create_dsl(self)
-    end
-
-    def control_eval_context
-      @control_eval_context ||= begin
-                                  ctx = Inspec::ControlEvalContext.create(self, to_resources_dsl)
-                                  ctx.new(@backend, @conf, dependencies, @require_loader, @skip_only_if_eval)
-                                end
-    end
-
-    def reload_dsl
-      @control_eval_context = nil
-    end
-
-    def profile_supports_platform?
-      return true if @conf["profile"].nil?
-
-      @conf["profile"].supports_platform?
-    end
-
-    def profile_supports_inspec_version?
-      return true if @conf["profile"].nil?
-
-      @conf["profile"].supports_runtime?
-    end
-
-    def remove_rule(id)
-      @rules[id] = nil if @rules.key?(id)
-      @control_subcontexts.each do |c|
-        c.remove_rule(id)
-      end
-    end
-
-    def all_controls
-      ret = @rules.values
-      ret += @control_subcontexts.map(&:all_rules).flatten
-      ret
-    end
-    alias all_rules all_controls
-
-    def subcontext_by_name(name)
-      found = @lib_subcontexts.find { |c| c.profile_id == name }
-      unless found
-        @lib_subcontexts.each do |c|
-          found = c.subcontext_by_name(name)
-          break if found
-        end
-      end
-
-      found
-    end
-
-    def add_resources(context)
-      @resource_registry.merge!(context.resource_registry)
-      control_eval_context.add_resources(context)
-      @lib_subcontexts << context
-      reload_dsl
-    end
-
-    def add_subcontext(context)
-      @control_subcontexts << context
-    end
-
-    def load_libraries(libs)
-      lib_prefix = "libraries" + File::SEPARATOR
-      autoloads = []
-
-      libs.sort_by! { |l| l[1] } # Sort on source path so load order is deterministic
-      libs.each do |content, source, line|
-        path = source
-        if source.start_with?(lib_prefix)
-          path = source.sub(lib_prefix, "")
-          autoloads.push(path) if File.dirname(path) == "."
-        end
-
-        @require_loader.add(path, content, source, line)
-      end
-
-      # load all files directly that are flat inside the libraries folder
-      autoloads.each do |path|
-        next unless path.end_with?(".rb")
-
-        load_library_file(*@require_loader.load(path)) unless @require_loader.loaded?(path)
-      end
-      reload_dsl
-    end
-
-    def load_control_file(*args)
-      # Set `skip_file` to `false` between file loads to prevent skips from spanning multiple control files
-      control_eval_context.skip_file = false
-      load_with_context(control_eval_context, *args)
-    end
-    alias load load_control_file
-
-    def load_library_file(*args)
-      load_with_context(@library_eval_context, *args)
-    end
-
-    def load_with_context(context, content, source = nil, line = nil)
-      Inspec::Log.debug("Loading #{source || "<anonymous content>"} into #{self}")
-      @current_load = { file: source }
-      if content.is_a? Proc
-        context.instance_eval(&content)
-      elsif source.nil? && line.nil?
-        context.instance_eval(content)
-      else
-        context.instance_eval(content, source || "unknown", line || 1)
-      end
-    end
-
-    def unregister_rule(id)
-      @rules.delete(full_id(@profile_id, id))
-    end
-
-    attr_reader :current_load
-
-    def register_rule(r)
-      # get the full ID
-      file = if @current_load.nil?
-               "unknown"
-             else
-               @current_load[:file] || "unknown"
-             end
-      r.instance_variable_set(:@__file, file)
-      r.instance_variable_set(:@__group_title, current_load[:title])
-
-      # add the rule to the registry
-      fid = full_id(Inspec::Rule.profile_id(r), Inspec::Rule.rule_id(r))
-      existing = @rules[fid]
-      if existing.nil?
-        @rules[fid] = r
-      else
-        Inspec::Rule.merge(existing, r)
-      end
-    end
-
-    def set_header(field, val)
-      @current_load[field] = val
-    end
-
-    private
-
-    def full_id(pid, rid)
-      return rid.to_s if pid.to_s.empty?
-
-      pid.to_s + "/" + rid.to_s
-    end
-  end
-end

data/lib/inspec/profile_vendor.rb

@@ -1,84 +0,0 @@
-require "inspec/profile"
-require "inspec/config"
-
-module Inspec
-  class ProfileVendor
-    attr_reader :profile_path
-
-    def initialize(path)
-      @profile_path = Pathname.new(File.expand_path(path))
-    end
-
-    def vendor!
-      vendor_dependencies
-    end
-
-    # The URL fetcher uses a Tempfile to retrieve the vendored
-    # profile, which creates a file that is only readable by
-    # the current user. In most circumstances, this is likely OK.
-    # However, in environments like a Habitat package, these files
-    # need to be readable by all users or the Habitat Supervisor
-    # may not be able to start InSpec correctly.
-    #
-    # This method makes sure all vendored files are mode 644 for this
-    # use case. This method is not called by default - the caller
-    # vendoring the profile must make the decision as to whether this
-    # is necessary.
-    def make_readable
-      Dir.glob("#{cache_path}/**/*") do |e|
-        FileUtils.chmod(0644, e) if File.file?(e)
-      end
-    end
-
-    def cache_path
-      profile_path.join("vendor")
-    end
-
-    def lockfile
-      profile_path.join("inspec.lock")
-    end
-
-    private
-
-    def profile
-      @profile ||= Inspec::Profile.for_target(profile_path.to_s, profile_opts)
-    end
-
-    def profile_opts
-      {
-        vendor_cache: Inspec::Cache.new(cache_path.to_s),
-        backend: Inspec::Backend.create(Inspec::Config.mock),
-      }
-    end
-
-    def vendor_dependencies
-      delete_vendored_data
-      File.write(lockfile, profile.generate_lockfile.to_yaml)
-      extract_archives
-    end
-
-    def delete_vendored_data
-      FileUtils.rm_rf(cache_path) if cache_path.exist?
-      File.delete(lockfile) if lockfile.exist?
-    end
-
-    def extract_archives
-      Dir.glob(File.join(cache_path, "*")).each do |filepath|
-        # Get SHA without extension
-        # We use split since '.' is not valid in a SHA checksum
-        destination_dir_name = File.basename(filepath).split(".")[0]
-        destination_path = File.join(cache_path, destination_dir_name)
-
-        provider = FileProvider.for_path(filepath)
-
-        next unless provider.is_a?(ZipProvider) || provider.is_a?(TarProvider)
-
-        Inspec::Log.debug("Extracting '#{filepath}' to '#{destination_path}'")
-        provider.extract(destination_path)
-
-        Inspec::Log.debug("Deleting archive '#{filepath}'")
-        File.delete(filepath)
-      end
-    end
-  end
-end

data/lib/inspec/reporters.rb

@@ -1,73 +0,0 @@
-require "inspec/reporters/base"
-require "inspec/reporters/cli"
-require "inspec/reporters/json"
-require "inspec/reporters/json_automate"
-require "inspec/reporters/json_min"
-require "inspec/reporters/junit"
-require "inspec/reporters/automate"
-require "inspec/reporters/yaml"
-
-module Inspec::Reporters
-  # rubocop:disable Metrics/CyclomaticComplexity
-  def self.render(reporter, run_data)
-    name, config = reporter.dup
-    config[:run_data] = run_data
-    case name
-    when "cli"
-      reporter = Inspec::Reporters::CLI.new(config)
-    when "json"
-      reporter = Inspec::Reporters::Json.new(config)
-    # This reporter is only used for Chef internal. We reserve the
-    # right to introduce breaking changes to this reporter at any time.
-    when "json-automate"
-      reporter = Inspec::Reporters::JsonAutomate.new(config)
-    when "json-min"
-      reporter = Inspec::Reporters::JsonMin.new(config)
-    when "junit"
-      reporter = Inspec::Reporters::Junit.new(config)
-    when "automate"
-      reporter = Inspec::Reporters::Automate.new(config)
-    when "yaml"
-      reporter = Inspec::Reporters::Yaml.new(config)
-    else
-      raise NotImplementedError, "'#{name}' is not a valid reporter type."
-    end
-
-    # optional send_report method on reporter
-    return reporter.send_report if defined?(reporter.send_report)
-
-    reporter.render
-    output = reporter.rendered_output
-
-    if config["file"]
-      # create destination directory if it does not exist
-      dirname = File.dirname(config["file"])
-      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
-
-      File.write(config["file"], output)
-    elsif config["stdout"] == true
-      print output
-      $stdout.flush
-    end
-  end
-
-  def self.report(reporter, run_data)
-    name, config = reporter.dup
-    config[:run_data] = run_data
-    case name
-    when "json"
-      reporter = Inspec::Reporters::Json.new(config)
-    when "json-min"
-      reporter = Inspec::Reporters::JsonMin.new(config)
-    when "json-automate"
-      reporter = Inspec::Reporters::JsonAutomate.new(config)
-    when "yaml"
-      reporter = Inspec::Reporters::Yaml.new(config)
-    else
-      # use base run_data hash for any other report
-      return run_data
-    end
-
-    reporter.report
-  end
-end

data/lib/inspec/reporters/automate.rb

@@ -1,78 +0,0 @@
-require "json"
-require "net/http"
-
-module Inspec::Reporters
-  class Automate < JsonAutomate
-    def initialize(config)
-      super(config)
-
-      # allow the insecure flag
-      @config["verify_ssl"] = !@config["insecure"] if @config.key?("insecure")
-
-      # default to not verifying ssl for sending reports
-      @config["verify_ssl"] = @config["verify_ssl"] || false
-    end
-
-    def enriched_report
-      # grab the report from the parent class
-      final_report = report
-
-      # Label this content as an inspec_report
-      final_report[:type] = "inspec_report"
-
-      final_report[:end_time] = Time.now.utc.strftime("%FT%TZ")
-      final_report[:node_uuid] = @config["node_uuid"] || @config["target_id"]
-      raise Inspec::ReporterError, "Cannot find a UUID for your node. Please specify one via json-config." if final_report[:node_uuid].nil?
-
-      final_report[:report_uuid] = @config["report_uuid"] || uuid_from_string(final_report[:end_time] + final_report[:node_uuid])
-
-      final_report
-    end
-
-    def send_report
-      headers = { "Content-Type" => "application/json" }
-      headers["x-data-collector-token"] = @config["token"]
-      headers["x-data-collector-auth"] = "version=1.0"
-
-      uri = URI(@config["url"])
-      req = Net::HTTP::Post.new(uri.path, headers)
-      req.body = enriched_report.to_json
-      begin
-        Inspec::Log.debug "Posting report to Chef Automate: #{uri.path}"
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = uri.scheme == "https"
-        if @config["verify_ssl"] == true
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        else
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-
-        res = http.request(req)
-        if res.is_a?(Net::HTTPSuccess)
-          return true
-        else
-          Inspec::Log.error "send_report: POST to #{uri.path} returned: #{res.body}"
-          return false
-        end
-      rescue => e
-        Inspec::Log.error "send_report: POST to #{uri.path} returned: #{e.message}"
-        return false
-      end
-    end
-
-    private
-
-    # This hashes the passed string into SHA1.
-    # Then it downgrades the 160bit SHA1 to a 128bit
-    # then we format it as a valid UUIDv5.
-    def uuid_from_string(string)
-      hash = Digest::SHA1.new
-      hash.update(string)
-      ary = hash.digest.unpack("NnnnnN")
-      ary[2] = (ary[2] & 0x0FFF) | (5 << 12)
-      ary[3] = (ary[3] & 0x3FFF) | 0x8000
-      # rubocop:disable Style/FormatString
-      "%08x-%04x-%04x-%04x-%04x%08x" % ary
-    end
-  end
-end

data/lib/inspec/reporters/base.rb

@@ -1,25 +0,0 @@
-module Inspec::Reporters
-  class Base
-    attr_reader :run_data
-
-    def initialize(config)
-      @config = config
-      @run_data = config[:run_data]
-      @output = ""
-    end
-
-    def output(str, newline = true)
-      @output << str
-      @output << "\n" if newline
-    end
-
-    def rendered_output
-      @output
-    end
-
-    # each reporter must implement #render
-    def render
-      raise NotImplementedError, "#{self.class} must implement a `#render` method to format its output."
-    end
-  end
-end