openfact 5.0.0.rc0

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Facter
+  module Core
+    module Execution
+      @@impl = if LegacyFacter::Util::Config.windows? # rubocop:disable Style/ClassVars
+                 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.
+      #
+      # @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
+      #
+      # @api private
+      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 to 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.
+      #
+      # @api private
+      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.
+      #
+      # @param values [Hash<String=>String>] A hash of the environment
+      #   variables to override
+      #
+      # @return [String] The block's return string
+      #
+      # @api private
+      def with_env(values, &block)
+        @@impl.with_env(values, &block)
+      end
+
+      # Try to execute a command and return the output.
+      #
+      # @param command [String] Command to run
+      #
+      # @return [String/nil] 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 command [String] Command to run
+      #
+      # @param options [Hash] Hash with options for the command
+      #
+      # @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.
+      # @option options [Object] :logger Optional logger used to log the
+      #   command's stderr.
+      # @option options :timeout Optional time out for the specified
+      #   command. If no timeout is passed, a default of 300 seconds is used.
+      #
+      # @raise [Facter::Core::Execution::ExecutionFailure] If the command does
+      #   not exist or could not be executed and :on_fail is set to :raise
+      #
+      # @return [String] the output of the program, or the value of :on_fail (if it's different than :raise) if
+      #   command execution failed and :on_fail was specified.
+      #
+      # @api public
+      def execute(command, options = {})
+        @@impl.execute(command, options)
+      end
+
+      # Execute a command and return the stdout and stderr of that program.
+      #
+      # @param command [String] Command to run
+      #
+      # @param on_fail[Object] 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 to not raise.
+      # @param logger Optional logger used to log the command's stderr.
+      # @param timeout Optional time out for the specified command. If no timeout is passed,
+      #   a default of 300 seconds is used.
+      #
+      # @raise [Facter::Core::Execution::ExecutionFailure] If the command does
+      #   not exist or could not be executed and :on_fail is set to :raise
+      #
+      # @return [String, String] the stdout and stderr of the program, or the value of
+      #   :on_fail if command execution failed and :on_fail was specified.
+      #
+      # @api private
+      def execute_command(command, on_fail = nil, logger = nil, timeout = nil)
+        @@impl.execute_command(command, on_fail, logger, timeout)
+      end
+
+      class ExecutionFailure < StandardError; end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../../facter/custom_facts/util/fact'
+require_relative '../../../facter/custom_facts/util/collection'
+require_relative '../../../facter/custom_facts/util/loader'
+require_relative '../../../facter/custom_facts/core/execution/base'
+require_relative '../../../facter/custom_facts/core/execution/windows'
+require_relative '../../../facter/custom_facts/core/execution/posix'
+require_relative '../../../facter/custom_facts/util/values'
+require_relative '../../../facter/custom_facts/util/confine'
+require_relative '../../../facter/custom_facts/util/config'
+
+require_relative '../../../facter/custom_facts/util/normalization'
+require_relative '../../../facter/custom_facts/core/execution'
+require_relative '../../../facter/custom_facts/core/resolvable'
+require_relative '../../../facter/custom_facts/core/suitable'
+require_relative '../../../facter/custom_facts/util/resolution'
+require_relative '../../../facter/custom_facts/core/directed_graph'
+require_relative '../../../facter/custom_facts/core/aggregate'
+require_relative '../../../facter/custom_facts/util/composite_loader'
+require_relative '../../../facter/custom_facts/util/parser'
+require_relative '../../../facter/custom_facts/util/directory_loader'
+require_relative '../../../facter/custom_facts/util/nothing_loader'

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# Facter - Host Fact Detection and Reporting
+#
+# Copyright 2011 Puppet Labs Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'pathname'
+
+require_relative '../../../facter/custom_facts/core/file_loader'
+
+# Functions as a hash of 'facts' about your system system, such as MAC
+# address, IP address, architecture, etc.
+#
+# @example Retrieve a fact
+#     puts Facter['operatingsystem'].value
+#
+# @example Retrieve all facts
+#   Facter.to_hash
+#    => { "kernel"=>"Linux", "uptime_days"=>0, "ipaddress"=>"10.0.0.1" }
+#
+# @api public
+module LegacyFacter
+  # Most core functionality of custom_facts is implemented in `Facter::Util`.
+  # @api public
+
+  include Comparable
+  include Enumerable
+
+  # module methods
+
+  # Accessor for the collection object which holds all the facts
+  # @return [LegacyFacter::Util::Collection] the collection of facts
+  #
+  # @api private
+  def self.collection
+    unless defined?(@collection) && @collection
+      @collection = LegacyFacter::Util::Collection.new(
+        LegacyFacter::Util::Loader.new,
+        LegacyFacter::Util::Config.ext_fact_loader
+      )
+    end
+    @collection
+  end
+
+  # Returns whether the JSON "feature" is available.
+  #
+  # @api private
+  def self.json?
+    require 'json'
+    true
+  rescue LoadError
+    false
+  end
+
+  # Returns a fact object by name.  If you use this, you still have to
+  # call {Facter::Util::Fact#value `value`} on it to retrieve the actual
+  # value.
+  #
+  # @param name [String] the name of the fact
+  #
+  # @return [Facter::Util::Fact, nil] The fact object, or nil if no fact
+  #   is found.
+  #
+  # @api public
+  def self.[](name)
+    collection.fact(name)
+  end
+
+  # (see [])
+  def self.fact(name)
+    collection.fact(name)
+  end
+
+  # Flushes cached values for all facts. This does not cause code to be
+  # reloaded; it only clears the cached results.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.flush
+    collection.flush
+  end
+
+  # Lists all fact names
+  #
+  # @return [Array<String>] array of fact names
+  #
+  # @api public
+  def self.list
+    collection.list
+  end
+
+  # Gets the value for a fact. Returns `nil` if no such fact exists.
+  #
+  # @param name [String] the fact name
+  # @return [Object, nil] the value of the fact, or nil if no fact is
+  #   found
+  #
+  # @api public
+  def self.value(name)
+    collection.value(name)
+  end
+
+  # Gets a hash mapping fact names to their values
+  #
+  # @return [Hash{String => Object}] the hash of fact names and values
+  #
+  # @api public
+  def self.to_hash
+    collection.load_all
+    collection.to_hash
+  end
+
+  # Define a new fact or extend an existing fact.
+  #
+  # @param name [Symbol] The name of the fact to define
+  # @param options [Hash] A hash of options to set on the fact
+  #
+  # @return [Facter::Util::Fact] The fact that was defined
+  #
+  # @api public
+  # @see {Facter::Util::Collection#define_fact}
+  def self.define_fact(name, options = {}, &block)
+    collection.define_fact(name, options, &block)
+  end
+
+  # Adds a {Facter::Util::Resolution resolution} mechanism for a named
+  # fact. This does not distinguish between adding a new fact and adding
+  # a new way to resolve a fact.
+  #
+  # @overload add(name, options = {}, { || ... })
+  # @param name [String] the fact name
+  # @param options [Hash] optional parameters for the fact - attributes
+  #   of {Facter::Util::Fact} and {Facter::Util::Resolution} can be
+  #   supplied here
+  # @option options [Integer] :timeout set the
+  #   {Facter::Util::Resolution#timeout timeout} for this resolution
+  # @param block [Proc] a block defining a fact resolution
+  #
+  # @return [Facter::Util::Fact] the fact object, which includes any previously
+  #   defined resolutions
+  #
+  # @api public
+  def self.add(name, options = {}, &block)
+    collection.add(name, options, &block)
+  end
+
+  # Iterates over fact names and values
+  #
+  # @yieldparam [String] name the fact name
+  # @yieldparam [String] value the current value of the fact
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.each
+    # Make sure all facts are loaded.
+    collection.load_all
+
+    collection.each do |*args|
+      yield(*args)
+    end
+  end
+
+  # Clears all cached values and removes all facts from memory.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.clear
+    LegacyFacter.flush
+    LegacyFacter.reset
+  end
+
+  # Removes all facts from memory. Use this when the fact code has
+  # changed on disk and needs to be reloaded.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.reset
+    @collection = nil
+  end
+
+  # Loads all facts.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.loadfacts
+    collection.load_all
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+# The resolvable mixin defines behavior for evaluating and returning fact
+# resolutions.
+#
+# Classes including this mixin should implement a #name method describing
+# the value being resolved and a #resolve_value that actually executes the code
+# to resolve the value.
+module LegacyFacter
+  module Core
+    module Resolvable
+      # The timeout, in seconds, for evaluating this resolution.
+      # @return [Integer]
+      # @api public
+      attr_accessor :timeout
+      attr_reader :logger
+
+      # Return the timeout period for resolving a value.
+      # (see #timeout)
+      # @return [Numeric]
+      # @comment requiring 'timeout' stdlib class causes Object#timeout to be
+      #   defined which delegates to Timeout.timeout. This method may potentially
+      #   overwrite the #timeout attr_reader on this class, so we define #limit to
+      #   avoid conflicts.
+      def limit
+        @timeout || 0
+      end
+
+      ##
+      # on_flush accepts a block and executes the block when the resolution's value
+      # is flushed.  This makes it possible to model a single, expensive system
+      # call inside of a Ruby object and then define multiple dynamic facts which
+      # resolve by sending messages to the model instance.  If one of the dynamic
+      # facts is flushed then it can, in turn, flush the data stored in the model
+      # instance to keep all of the dynamic facts in sync without making multiple,
+      # expensive, system calls.
+      #
+      # Please see the Solaris zones fact for an example of how this feature may be
+      # used.
+      #
+      # @see Facter::Util::Fact#flush
+      # @see Facter::Util::Resolution#flush
+      #
+      # @api public
+      def on_flush(&block)
+        @on_flush_block = block
+      end
+
+      ##
+      # flush executes the block, if any, stored by the {on_flush} method
+      #
+      # @see Facter::Util::Fact#flush
+      # @see Facter::Util::Resolution#on_flush
+      #
+      # @api private
+      def flush
+        @on_flush_block&.call
+      end
+
+      # Resolves the fact's value or loggs an error if the value
+      # couldn't be resolved.
+      #
+      # @raise Facter::ResolveCustomFactError if an error was raised
+      # (except Timeout::Error or Narmalization::NarmalizationError
+      # in which case an error message is logged and the execution
+      # isn't suspended).
+      #
+      # @return value (hash, string, int, array, etc) or nil
+      #
+      # @api private
+      def value
+        result = nil
+
+        with_timing do
+          Timeout.timeout(limit) do
+            result = resolve_value
+          end
+        end
+
+        LegacyFacter::Util::Normalization.normalize(result)
+      rescue Timeout::Error => e
+        Facter.log_exception(e, "Timed out after #{limit} seconds while resolving #{qualified_name}")
+
+        nil
+      rescue LegacyFacter::Util::Normalization::NormalizationError => e
+        Facter.log_exception(e, "Fact resolution #{qualified_name} resolved to an invalid value: #{e.message}")
+
+        nil
+      rescue StandardError => e
+        Facter.log_exception(e, "Error while resolving custom fact #{qualified_name}: #{e.message}")
+
+        raise Facter::ResolveCustomFactError
+      end
+
+      private
+
+      def with_timing
+        starttime = Time.now.to_f
+
+        yield
+
+        finishtime = Time.now.to_f
+        ms = (finishtime - starttime) * 1000
+        Facter::Log.show_time format('%<qn>s: %<ms>.2fms', qn: qualified_name, ms: ms)
+      end
+
+      def qualified_name
+        "fact='#{@fact.name}', resolution='#{@name || '<anonymous>'}'"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# The Suitable mixin provides mechanisms for confining objects to run on
+# certain platforms and determining the run precedence of these objects.
+#
+# Classes that include the Suitable mixin should define a `#confines` method
+# that returns an Array of zero or more Facter::Util::Confine objects.
+module LegacyFacter
+  module Core
+    module Suitable
+      # Sets the weight of this resolution. If multiple suitable resolutions
+      # are found, the one with the highest weight will be used.  If weight
+      # is not given, the number of confines set on a resolution will be
+      # used as its weight (so that the most specific resolution is used).
+      #
+      # @param weight [Integer] the weight of this resolution
+      #
+      # @return [void]
+      #
+      # @api public
+      def has_weight(weight) # rubocop:disable Naming/PredicatePrefix
+        @weight = weight
+        self
+      end
+
+      # Sets the conditions for this resolution to be used.  This method accepts
+      # multiple forms of arguments to determine suitability.
+      #
+      # @return [void]
+      #
+      # @api public
+      #
+      # @overload confine(confines)
+      #   Confine a fact to a specific fact value or values.  This form takes a
+      #   hash of fact names and values. Every fact must match the values given for
+      #   that fact, otherwise this resolution will not be considered suitable. The
+      #   values given for a fact can be an array, in which case the value of the
+      #   fact must be in the array for it to match.
+      #   @param [Hash{String,Symbol=>String,Array<String>}] confines set of facts identified by the hash keys whose
+      #     fact value must match the argument value.
+      #   @example Confining to Linux
+      #       Facter.add(:powerstates) do
+      #         # This resolution only makes sense on linux systems
+      #         confine :kernel => "Linux"
+      #         setcode do
+      #           File.read('/sys/power/states')
+      #         end
+      #       end
+      #
+      # @overload confine(confines, &block)
+      #   Confine a fact to a block with the value of a specified fact yielded to
+      #   the block.
+      #   @param [String,Symbol] confines the fact name whose value should be
+      #     yielded to the block
+      #   @param [Proc] block determines the suitability of the fact.  If the block
+      #     evaluates to `false` or `nil` then the confined fact will not be
+      #     evaluated.
+      #   @yield [value] the value of the fact identified by {confines}
+      #   @example Confine the fact to a host with an ipaddress in a specific
+      #     subnet
+      #       confine :ipaddress do |addr|
+      #         require 'ipaddr'
+      #         IPAddr.new('192.168.0.0/16').include? addr
+      #       end
+      #
+      # @overload confine(&block)
+      #   Confine a fact to a block.  The fact will be evaluated only if the block
+      #   evaluates to something other than `false` or `nil`.
+      #   @param [Proc] block determines the suitability of the fact.  If the block
+      #     evaluates to `false` or `nil` then the confined fact will not be
+      #     evaluated.
+      #   @example Confine the fact to systems with a specific file.
+      #       confine { File.readable? '/bin/foo' }
+      def confine(confines = nil, &block)
+        case confines
+        when Hash
+          confines.each do |fact, values|
+            @confines.push LegacyFacter::Util::Confine.new(fact, *values)
+          end
+        else
+          if block
+            if confines
+              @confines.push LegacyFacter::Util::Confine.new(confines, &block)
+            else
+              @confines.push LegacyFacter::Util::Confine.new(&block)
+            end
+          end
+        end
+      end
+
+      # Returns the importance of this resolution. If the weight was not
+      # given, the number of confines is used instead (so that a more
+      # specific resolution wins over a less specific one).
+      #
+      # @return [Integer] the weight of this resolution
+      #
+      # @api private
+      def weight
+        @weight || @confines.length
+      end
+
+      # Is this resolution mechanism suitable on the system in question?
+      #
+      # @api private
+      def suitable?
+        @confines.all?(&:true?)
+      end
+    end
+  end
+end