facter 4.0.28

data/facter.gemspec

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require_relative 'config/config'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'facter'
+  spec.version       = FACTER_VERSION
+  spec.authors       = ['Puppet']
+  spec.email         = ['team-nw@puppet.com']
+
+  spec.summary       = 'New version of Facter'
+  spec.description   = 'New version of Facter'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  # On our internal Jenkins, there is no git. As it is a clean machine, we don't need to worry about anything else.
+  spec.files = if system('git --help > /dev/null')
+                 `git ls-files -z`.split("\x0")
+               else
+                 Dir.glob('**/*')
+               end
+
+  spec.required_ruby_version = '~> 2.3'
+  spec.files.reject! do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.files.reject! do |f|
+    f == 'bin/facter-ng'
+  end
+
+  spec.bindir = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'coveralls', '~> 0.8.23'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.81.0'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.5.2'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.38'
+  spec.add_development_dependency 'sys-filesystem', '~> 1.3'
+  spec.add_development_dependency 'yard', '~> 0.9'
+
+  spec.add_runtime_dependency 'hocon', '~> 1.3'
+  spec.add_runtime_dependency 'thor', ['>= 1.0.1', '< 2.0']
+end

data/lib/custom_facts/core/aggregate.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+# Aggregates provide a mechanism for facts to be resolved in multiple steps.
+#
+# Aggregates are evaluated in two parts: generating individual chunks and then
+# aggregating all chunks together. Each chunk is a block of code that generates
+# a value, and may depend on other chunks when it runs. After all chunks have
+# been evaluated they are passed to the aggregate block as Hash<name, result>.
+# The aggregate block converts the individual chunks into a single value that is
+# returned as the final value of the aggregate.
+#
+# @api public
+# @since 2.0.0
+module Facter
+  module Core
+    class Aggregate
+      include LegacyFacter::Core::Suitable
+      include LegacyFacter::Core::Resolvable
+
+      # @!attribute [r] name
+      #   @return [Symbol] The name of the aggregate resolution
+      attr_reader :name
+
+      # @!attribute [r] deps
+      #   @api private
+      #   @return [LegacyFacter::Core::DirectedGraph]
+      attr_reader :deps
+
+      # @!attribute [r] confines
+      #   @return [Array<LegacyFacter::Core::Confine>] An array of confines restricting
+      #     this to a specific platform
+      #   @see Facter::Core::Suitable
+      attr_reader :confines
+
+      # @!attribute [r] fact
+      # @return [Facter::Util::Fact]
+      # @api private
+      attr_reader :fact
+
+      def initialize(name, fact)
+        @name = name
+        @fact = fact
+
+        @confines = []
+        @chunks = {}
+
+        @aggregate = nil
+        @deps = LegacyFacter::Core::DirectedGraph.new
+      end
+
+      def options(options)
+        accepted_options = %i[name timeout weight fact_type]
+        accepted_options.each do |option_name|
+          instance_variable_set("@#{option_name}", options.delete(option_name)) if options.key?(option_name)
+        end
+        raise ArgumentError, "Invalid aggregate options #{options.keys.inspect}" unless options.keys.empty?
+      end
+
+      def evaluate(&block)
+        instance_eval(&block)
+      end
+
+      # Define a new chunk for the given aggregate
+      #
+      # @api public
+      #
+      # @example Defining a chunk with no dependencies
+      #   aggregate.chunk(:mountpoints) do
+      #     # generate mountpoint information
+      #   end
+      #
+      # @example Defining an chunk to add mount options
+      #   aggregate.chunk(:mount_options, :require => [:mountpoints]) do |mountpoints|
+      #     # `mountpoints` is the result of the previous chunk
+      #     # generate mount option information based on the mountpoints
+      #   end
+      #
+      # @param name [Symbol] A name unique to this aggregate describing the chunk
+      # @param opts [Hash]
+      # @options opts [Array<Symbol>, Symbol] :require One or more chunks
+      #   to evaluate and pass to this block.
+      # @yield [*Object] Zero or more chunk results
+      #
+      # @return [void]
+      def chunk(name, opts = {}, &block)
+        raise ArgumentError, "#{self.class.name}#chunk requires a block" unless block_given?
+
+        deps = Array(opts.delete(:require))
+
+        unless opts.empty?
+          raise ArgumentError, "Unexpected options passed to #{self.class.name}#chunk: #{opts.keys.inspect}"
+        end
+
+        @deps[name] = deps
+        @chunks[name] = block
+      end
+
+      # Define how all chunks should be combined
+      #
+      # @api public
+      #
+      # @example Merge all chunks
+      #   aggregate.aggregate do |chunks|
+      #     final_result = {}
+      #     chunks.each_value do |chunk|
+      #       final_result.deep_merge(chunk)
+      #     end
+      #     final_result
+      #   end
+      #
+      # @example Sum all chunks
+      #   aggregate.aggregate do |chunks|
+      #     total = 0
+      #     chunks.each_value do |chunk|
+      #       total += chunk
+      #     end
+      #     total
+      #   end
+      #
+      # @yield [Hash<Symbol, Object>] A hash containing chunk names and
+      #   chunk values
+      #
+      # @return [void]
+      def aggregate(&block)
+        raise ArgumentError, "#{self.class.name}#aggregate requires a block" unless block_given?
+
+        @aggregate = block
+      end
+
+      def resolution_type
+        :aggregate
+      end
+
+      private
+
+      # Evaluate the results of this aggregate.
+      #
+      # @see Facter::Core::Resolvable#value
+      # @return [Object]
+      def resolve_value
+        chunk_results = run_chunks
+        aggregate_results(chunk_results)
+      end
+
+      # Order all chunks based on their dependencies and evaluate each one, passing
+      # dependent chunks as needed.
+      #
+      # @return [Hash<Symbol, Object>] A hash containing the chunk that
+      #   generated value and the related value.
+      def run_chunks
+        results = {}
+        order_chunks.each do |(name, block)|
+          input = @deps[name].map { |dep_name| results[dep_name] }
+
+          output = block.call(*input)
+          results[name] = LegacyFacter::Util::Values.deep_freeze(output)
+        end
+
+        results
+      end
+
+      # Process the results of all chunks with the aggregate block and return the
+      # results. If no aggregate block has been specified, fall back to deep
+      # merging the given data structure
+      #
+      # @param results [Hash<Symbol, Object>] A hash of chunk names and the output
+      #   of that chunk.
+      # @return [Object]
+      def aggregate_results(results)
+        if @aggregate
+          @aggregate.call(results)
+        else
+          default_aggregate(results)
+        end
+      end
+
+      def default_aggregate(results)
+        results.values.inject do |result, current|
+          LegacyFacter::Util::Values.deep_merge(result, current)
+        end
+      rescue LegacyFacter::Util::Values::DeepMergeError => e
+        raise ArgumentError, 'Could not deep merge all chunks (Original error: ' \
+                         "#{e.message}), ensure that chunks return either an Array or Hash or " \
+                         'override the aggregate block', e.backtrace
+      end
+
+      # Order chunks based on their dependencies
+      #
+      # @return [Array<Symbol, Proc>] A list of chunk names and blocks in evaluation order.
+      def order_chunks
+        unless @deps.acyclic?
+          raise DependencyError,
+                "Could not order chunks; found the following dependency cycles: #{@deps.cycles.inspect}"
+        end
+
+        sorted_names = @deps.tsort
+
+        sorted_names.map do |name|
+          [name, @chunks[name]]
+        end
+      end
+
+      class DependencyError < StandardError; end
+    end
+  end
+end

data/lib/custom_facts/core/directed_graph.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'tsort'
+
+module LegacyFacter
+  module Core
+    class DirectedGraph < Hash
+      include TSort
+
+      def acyclic?
+        cycles.empty?
+      end
+
+      def cycles
+        cycles = []
+        each_strongly_connected_component do |component|
+          cycles << component if component.size > 1
+        end
+        cycles
+      end
+
+      alias tsort_each_node each_key
+
+      def tsort_each_child(node)
+        fetch(node, []).each do |child|
+          yield child
+        end
+      end
+
+      def tsort
+        missing = Set.new(values.flatten) - Set.new(keys)
+
+        unless missing.empty?
+          raise MissingVertex, "Cannot sort elements; cannot depend on missing elements #{missing.to_a}"
+        end
+
+        super
+      rescue TSort::Cyclic
+        raise CycleError, "Cannot sort elements; found the following cycles: #{cycles.inspect}"
+      end
+
+      class CycleError < StandardError; end
+      class MissingVertex < StandardError; end
+    end
+  end
+end

data/lib/custom_facts/core/execution.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Facter
+  module Core
+    module Execution
+      # require_relative 'execution/base'
+      # require_relative 'execution/windows'
+      # require_relative 'execution/posix'
+
+      @@impl = if LegacyFacter::Util::Config.windows?
+                 Facter::Core::Execution::Windows.new
+               else
+                 Facter::Core::Execution::Posix.new
+               end
+
+      def self.impl
+        @@impl
+      end
+
+      module_function
+
+      # Returns the locations to be searched when looking for a binary. This
+      # is currently determined by the +PATH+ environment variable plus
+      # `/sbin` and `/usr/sbin` when run on unix
+      #
+      # @return [Array<String>] the paths to be searched for binaries
+      # @api private
+      def search_paths
+        @@impl.search_paths
+      end
+
+      # Determines the full path to a binary. If the supplied filename does not
+      # already describe an absolute path then different locations (determined
+      # by {search_paths}) will be searched for a match.
+      #
+      # Returns nil if no matching executable can be found otherwise returns
+      # the expanded pathname.
+      #
+      # @param bin [String] the executable to locate
+      # @return [String,nil] the full path to the executable or nil if not
+      #   found
+      #
+      # @api public
+      def which(bin)
+        @@impl.which(bin)
+      end
+
+      # Determine in a platform-specific way whether a path is absolute. This
+      # defaults to the local platform if none is specified.
+      #
+      # @param path [String] the path to check
+      # @param platform [:posix,:windows,nil] the platform logic to use
+      def absolute_path?(path, platform = nil)
+        case platform
+        when :posix
+          Facter::Core::Execution::Posix.new.absolute_path?(path)
+        when :windows
+          Facter::Core::Execution::Windows.new.absolute_path?(path)
+        else
+          @@impl.absolute_path?(path)
+        end
+      end
+
+      # Given a command line, this returns the command line with the
+      # executable written as an absolute path. If the executable contains
+      # spaces, it has be put in double quotes to be properly recognized.
+      #
+      # @param command [String] the command line
+      #
+      # @return [String, nil] the command line with the executable's path
+      # expanded, or nil if the executable cannot be found.
+      def expand_command(command)
+        @@impl.expand_command(command)
+      end
+
+      # Overrides environment variables within a block of code.  The
+      # specified values will be set for the duration of the block, after
+      # which the original values (if any) will be restored.
+      #
+      # @overload with_env(values, { || ... })
+      #
+      # @param values [Hash<String=>String>] A hash of the environment
+      #   variables to override
+      #
+      # @return [void]
+      #
+      # @api public
+      def with_env(values, &block)
+        @@impl.with_env(values, &block)
+      end
+
+      # Try to execute a command and return the output.
+      #
+      # @param code [String] the program to run
+      #
+      # @return [String] the output of the program, or nil if the command does
+      #   not exist or could not be executed.
+      #
+      # @deprecated Use #{execute} instead
+      # @api public
+      def exec(command)
+        @@impl.execute(command, on_fail: nil)
+      end
+
+      # Execute a command and return the output of that program.
+      #
+      # @param code [String] the program to run
+      # @param options [Hash]
+      #
+      # @option options [Object] :on_fail How to behave when the command could
+      #   not be run. Specifying :raise will raise an error, anything else will
+      #   return that object on failure. Default is :raise.
+      #
+      # @raise [Facter::Core::Execution::ExecutionFailure] If the command does
+      #   not exist or could not be executed.
+      #
+      # @return [String] the output of the program, or the value of :on_fail if
+      #   command execution failed and :on_fail was specified.
+      #
+      # @api public
+      # @since 2.0.1
+      def execute(command, options = {})
+        @@impl.execute(command, options)
+      end
+
+      class ExecutionFailure < StandardError; end
+    end
+  end
+end

data/lib/custom_facts/core/execution/base.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Facter
+  module Core
+    module Execution
+      class Base
+        STDERR_MESSAGE = 'Command %s resulted with the following stderr message: %s'
+
+        # This is part of the public API. No race condition can happen
+        # here because custom facts are executed sequentially
+        def with_env(values)
+          old = {}
+          values.each do |var, value|
+            # save the old value if it exists
+            if (old_val = ENV[var])
+              old[var] = old_val
+            end
+            # set the new (temporary) value for the environment variable
+            ENV[var] = value
+          end
+          # execute the caller's block, capture the return value
+          rv = yield
+        # use an ensure block to make absolutely sure we restore the variables
+        ensure
+          # restore the old values
+          values.each do |var, _value|
+            if old.include?(var)
+              ENV[var] = old[var]
+            else
+              # if there was no old value, delete the key from the current environment variables hash
+              ENV.delete(var)
+            end
+          end
+          # return the captured return value
+          rv
+        end
+
+        def execute(command, options = {})
+          on_fail = options.fetch(:on_fail, :raise)
+          expand = options.fetch(:expand, true)
+          logger = options[:logger]
+
+          expanded_command = if !expand && builtin_command?(command) || logger
+                               command
+                             else
+                               expand_command(command)
+                             end
+
+          if expanded_command.nil?
+            if on_fail == :raise
+              raise Facter::Core::Execution::ExecutionFailure.new,
+                    "Could not execute '#{command}': command not found"
+            end
+
+            return on_fail
+          end
+
+          execute_command(expanded_command, on_fail, logger)
+        end
+
+        private
+
+        def log_stderr(msg, command, logger)
+          return if !msg || msg.empty?
+
+          if logger
+            logger.debug(format(STDERR_MESSAGE, command, msg.strip))
+          else
+            file_name = command.split('/').last
+            logger = Facter::Log.new(file_name)
+            logger.warn(format(STDERR_MESSAGE, command, msg.strip))
+          end
+        end
+
+        def builtin_command?(command)
+          output, _status = Open3.capture2("type #{command}")
+          output.chomp =~ /builtin/ ? true : false
+        end
+
+        def execute_command(command, on_fail, logger = nil)
+          begin
+            # Set LC_ALL and LANG to force i18n to C for the duration of this exec;
+            # this ensures that any code that parses the
+            # output of the command can expect it to be in a consistent / predictable format / locale
+            out, stderr, _status_ = Open3.capture3({ 'LC_ALL' => 'C', 'LANG' => 'C' }, command.to_s)
+            log_stderr(stderr, command, logger)
+          rescue StandardError => e
+            return '' if logger
+            return on_fail unless on_fail == :raise
+
+            raise Facter::Core::Execution::ExecutionFailure.new,
+                  "Failed while executing '#{command}': #{e.message}"
+          end
+
+          out.strip
+        end
+      end
+    end
+  end
+end