openfact 5.0.0.rc0

data/lib/facter/custom_facts/core/aggregate.rb

@@ -0,0 +1,279 @@
+# 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
+      #
+      # @api public
+      attr_reader :name
+
+      # @!attribute [r] fact_type
+      #
+      # @return [Symbol] The fact type of the aggregate resolution
+      #
+      # @api private
+      attr_reader :fact_type
+
+      # @!attribute [r] deps
+      #
+      # @return [LegacyFacter::Core::DirectedGraph]
+      #
+      # @api private
+      attr_reader :deps
+
+      # @!attribute [r] confines
+      #
+      # @return [Array<LegacyFacter::Core::Confine>] An array of confines restricting
+      #  this to a specific platform
+      #
+      # @api private
+      attr_reader :confines
+
+      # @!attribute [r] fact
+      #
+      # @return [Facter::Util::Fact]
+      #
+      # @api private
+      attr_reader :fact
+
+      # @!attribute [r] last_evaluated
+      #
+      # @return [String]
+      #
+      # @api public
+      attr_reader :last_evaluated
+
+      # Create a new aggregated resolution mechanism.
+      #
+      # @param name [String] The name of the resolution.
+      # @param fact [Facter::Fact] The fact to which this
+      #             resolution will be added.
+      #
+      # @return [Facter::Util::Resolution] The created resolution
+      #
+      # @api private
+      def initialize(name, fact)
+        @name = name
+        @fact = fact
+
+        @confines = []
+        @chunks = {}
+
+        @aggregate = nil
+        @deps = LegacyFacter::Core::DirectedGraph.new
+      end
+
+      # Compares the weight of two aggregate facts
+      #
+      # @return [bool] Weight comparison result
+      #
+      # @api private
+      def <=>(other)
+        weight <=> other.weight
+      end
+
+      # Sets options for the aggregate fact
+      #
+      # @return [nil]
+      #
+      # @api private
+      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
+
+      # Evaluates the given block
+      #
+      # @return [String] Result of the block's evaluation
+      #
+      # @api private
+      def evaluate(&block)
+        if @last_evaluated
+          msg = +"Already evaluated #{@name}"
+          msg << " at #{@last_evaluated}" if msg.is_a? String
+          msg << ', reevaluating anyways'
+          log.warn msg
+        end
+        instance_eval(&block)
+
+        @last_evaluated = block.source_location.join(':')
+      end
+
+      # Define a new chunk for the given aggregate
+      #
+      # @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] Hash with options for the aggregate fact
+      #
+      # @return [Facter::Core::Aggregate] The aggregate object
+      #
+      # @api public
+      def chunk(name, opts = {}, &block)
+        evaluate_params(name, &block)
+
+        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
+        self
+      end
+
+      # Define how all chunks should be combined
+      #
+      # @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 [Facter::Core::Aggregate] The aggregate fact
+      #
+      # @api public
+      def aggregate(&block)
+        raise ArgumentError, "#{self.class.name}#aggregate requires a block" unless block_given?
+
+        @aggregate = block
+        self
+      end
+
+      # Returns the fact's resolution type
+      #
+      # @return [Symbol] The fact's type
+      #
+      # @api private
+      def resolution_type
+        :aggregate
+      end
+
+      private
+
+      def log
+        @log ||= Facter::Log.new(self)
+      end
+
+      def evaluate_params(name)
+        raise ArgumentError, "#{self.class.name}#chunk requires a block" unless block_given?
+        raise ArgumentError, "#{self.class.name}#expected chunk name to be a Symbol" unless name.is_a? Symbol
+      end
+
+      # 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/facter/custom_facts/core/directed_graph.rb

@@ -0,0 +1,45 @@
+# 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, &block)
+        fetch(node, []).each(&block)
+      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/facter/custom_facts/core/execution/base.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative 'popen3'
+
+module Facter
+  module Core
+    module Execution
+      class Base
+        STDERR_MESSAGE = 'Command %s completed with the following stderr message: %s'
+        VALID_OPTIONS = %i[on_fail expand logger timeout].freeze
+        DEFAULT_EXECUTION_TIMEOUT = 300
+        def initialize
+          @log = Log.new(self)
+        end
+
+        # 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, returning its value
+          yield
+        # use an ensure block to make absolutely sure we restore the variables
+        ensure
+          # restore the old values
+          values.each_key do |var|
+            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
+        end
+
+        def execute(command, options = {})
+          on_fail, expand, logger, timeout = extract_options(options)
+
+          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
+
+          out, = execute_command(expanded_command, on_fail, logger, timeout)
+          out
+        end
+
+        def execute_command(command, on_fail = nil, logger = nil, timeout = nil)
+          timeout ||= DEFAULT_EXECUTION_TIMEOUT
+          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
+            opts = { 'LC_ALL' => 'C', 'LANG' => 'C' }
+            require 'timeout'
+            @log.debug("Executing command: #{command}")
+            out, stderr = Popen3.popen3e(opts, command.to_s) do |_, stdout, stderr, pid|
+              stdout_messages = +''
+              stderr_messages = +''
+              out_reader = Thread.new { stdout.read }
+              err_reader = Thread.new { stderr.read }
+              begin
+                Timeout.timeout(timeout) do
+                  stdout_messages << out_reader.value
+                  stderr_messages << err_reader.value
+                end
+              rescue Timeout::Error
+                message = "Timeout encounter after #{timeout}s, killing process with pid: #{pid}"
+                Process.kill('KILL', pid)
+                on_fail == :raise ? (raise StandardError, message) : @log.debug(message)
+              ensure
+                out_reader.kill
+                err_reader.kill
+              end
+              [stdout_messages, stderr_messages]
+            end
+            log_stderr(stderr, command, logger)
+          rescue StandardError => e
+            message = "Failed while executing '#{command}': #{e.message}"
+            if logger
+              @log.debug(message)
+              return +''
+            end
+
+            return on_fail unless on_fail == :raise
+
+            raise Facter::Core::Execution::ExecutionFailure.new, message
+          end
+
+          out.force_encoding(Encoding.default_external) unless out.valid_encoding?
+          [out.strip, stderr]
+        end
+
+        private
+
+        def extract_options(options)
+          on_fail = options.fetch(:on_fail, :raise)
+          expand = options.fetch(:expand, true)
+          logger = options[:logger]
+          timeout = (options[:timeout] || options[:time_limit] || options[:limit]).to_i
+          timeout = timeout.positive? ? timeout : nil
+
+          extra_keys = options.keys - VALID_OPTIONS
+          unless extra_keys.empty?
+            @log.warn("Unexpected key passed to Facter::Core::Execution.execute option: #{extra_keys.join(',')}" \
+                      " - valid keys: #{VALID_OPTIONS.join(',')}")
+          end
+
+          [on_fail, expand, logger, timeout]
+        end
+
+        def log_stderr(msg, command, logger)
+          return if !msg || msg.empty?
+
+          unless logger
+            file_name = command.split('/').last
+            logger = Facter::Log.new(file_name)
+          end
+
+          logger.debug(format(STDERR_MESSAGE, command, msg.strip))
+        end
+
+        def builtin_command?(command)
+          output, _status = Open3.capture2("type #{command}")
+          /builtin/.match?(output.chomp) || false
+        end
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/core/execution/popen3.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+#
+# Because Open3 uses Process.detach the env $? is not set so
+# this class reimplements Open3.popen3 with Process.wait instead.
+# [FACT-2934] When calling Facter::Core::Execution, $? and $CHILD_STATUS
+# ruby env variables should be set.
+#
+
+module Facter
+  module Core
+    module Execution
+      class Popen3
+        @log ||= Log.new(self)
+
+        def self.popen_rune(cmd, opts, child_io, parent_io) # :nodoc:
+          pid = spawn(*cmd, opts)
+          child_io.each(&:close)
+          result = [*parent_io, pid]
+          if defined? yield
+            begin
+              return yield(*result)
+            ensure
+              parent_io.each(&:close)
+              begin
+                Process.wait(pid)
+              rescue Errno::ENOENT
+                # For some reason, the first Process.wait executed in JRuby
+                # always fails with ENOENT. However, the command output is
+                # filled in so we just need to silently continue.
+                # https://github.com/jruby/jruby/issues/5971
+                raise unless RUBY_PLATFORM == 'java'
+
+                @log.debug('Caught ENOENT during Process.wait on JRuby, continuing...')
+              end
+            end
+          end
+          result
+        end
+
+        def self.popen3e(*cmd, &block)
+          opts = if cmd.last.is_a? Hash
+                   cmd.pop.dup
+                 else
+                   {}
+                 end
+          in_r, in_w = IO.pipe
+          opts[:in] = in_r
+          in_w.sync = true
+          out_r, out_w = IO.pipe
+          opts[:out] = out_w
+          err_r, err_w = IO.pipe
+          opts[:err] = err_w
+          popen_rune(cmd, opts, [in_r, out_w, err_w], [in_w, out_r, err_r], &block)
+        end
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/core/execution/posix.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Facter
+  module Core
+    module Execution
+      class Posix < Facter::Core::Execution::Base
+        DEFAULT_SEARCH_PATHS = ['/sbin', '/usr/sbin'].freeze
+
+        def search_paths
+          # Make sure custom_facts is usable even for non-root users. Most commands
+          # in /sbin (like ifconfig) can be run as non privileged users as
+          # long as they do not modify anything - which we do not do with custom_facts
+          ENV['PATH'].split(File::PATH_SEPARATOR) + DEFAULT_SEARCH_PATHS
+        end
+
+        def which(bin)
+          if absolute_path?(bin)
+            return bin if File.executable?(bin) && FileTest.file?(bin)
+          else
+            search_paths.each do |dir|
+              dest = File.join(dir, bin)
+              return dest if File.executable?(dest) && FileTest.file?(dest)
+            end
+          end
+          nil
+        end
+
+        ABSOLUTE_PATH_REGEX = %r{^/}.freeze
+
+        def absolute_path?(path)
+          !!(path =~ ABSOLUTE_PATH_REGEX)
+        end
+
+        DOUBLE_QUOTED_COMMAND = /\A"(.+?)"(?:\s+(.*))?/.freeze
+        SINGLE_QUOTED_COMMAND = /\A'(.+?)'(?:\s+(.*))?/.freeze
+
+        def expand_command(command)
+          exe = nil
+          args = nil
+
+          match = command.match(DOUBLE_QUOTED_COMMAND) || command.match(SINGLE_QUOTED_COMMAND)
+          if match
+            exe, args = match.captures
+          else
+            exe, args = command.split(/ /, 2)
+          end
+
+          return unless exe && (expanded = which(exe))
+
+          expanded = expanded.dup
+          expanded = +"'#{expanded}'" if /\s/.match?(expanded)
+          expanded << " #{args}" if args
+
+          expanded
+        end
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/core/execution/windows.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Facter
+  module Core
+    module Execution
+      class Windows < Facter::Core::Execution::Base
+        def search_paths
+          ENV['PATH'].split(File::PATH_SEPARATOR)
+        end
+
+        DEFAULT_COMMAND_EXTENSIONS = %w[.COM .EXE .BAT .CMD].freeze
+
+        def which(bin)
+          # `echo` is allowed for facter 3.x compatibility, otherwise
+          # all commands much be found on the PATH or absolute.
+          return bin if /^echo$/i.match?(bin)
+
+          if absolute_path?(bin)
+            return bin if File.executable?(bin)
+          else
+            search_paths.each do |dir|
+              dest = File.join(dir, bin)
+              dest.gsub!(File::SEPARATOR, File::ALT_SEPARATOR)
+              if File.extname(dest).empty?
+                exts = ENV['PATHEXT']
+                exts = exts ? exts.split(File::PATH_SEPARATOR) : DEFAULT_COMMAND_EXTENSIONS
+                exts.each do |ext|
+                  destext = dest + ext
+                  return destext if File.executable?(destext)
+                end
+              end
+              return dest if File.executable?(dest)
+            end
+          end
+          nil
+        end
+
+        slash = '[\\\\/]'
+        name = '[^\\\\/]+'
+        ABSOLUTE_PATH_REGEX =
+          /^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))/i.freeze
+
+        def absolute_path?(path)
+          !!(path =~ ABSOLUTE_PATH_REGEX)
+        end
+
+        DOUBLE_QUOTED_COMMAND = /\A"(.+?)"(?:\s+(.*))?/.freeze
+
+        def expand_command(command)
+          exe = nil
+          args = nil
+
+          if (match = command.match(DOUBLE_QUOTED_COMMAND))
+            exe, args = match.captures
+          else
+            exe, args = command.split(/ /, 2)
+          end
+
+          return unless exe && (expanded = which(exe))
+
+          expanded = expanded.dup
+          expanded = +"\"#{expanded}\"" if /\s+/.match?(expanded)
+          expanded << " #{args}" if args
+
+          expanded
+        end
+
+        def execute(command, options = {})
+          expand = options.fetch(:expand, true)
+          raise ArgumentError.new, 'Unsupported argument on Windows expand with value false' unless expand
+
+          super(command, options)
+        end
+      end
+    end
+  end
+end