facter 4.0.23

data/lib/custom_facts/util/normalization.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Util
+    module Normalization
+      class NormalizationError < StandardError; end
+
+      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, Symbol, String, Array, Hash].freeze
+
+      module_function
+
+      # Recursively normalize the given data structure
+      #
+      # @api public
+      # @raise [NormalizationError] If the data structure contained an invalid element.
+      # @return [void]
+      def normalize(value)
+        case value
+        when Integer, Float, TrueClass, FalseClass, NilClass, Symbol, Date
+          value
+        when String
+          normalize_string(value)
+        when Array
+          normalize_array(value)
+        when Hash
+          normalize_hash(value)
+        else
+          raise NormalizationError, "Expected #{value} to be one of #{VALID_TYPES.inspect}, but was #{value.class}"
+        end
+      end
+
+      # @!method normalize_string(value)
+      #
+      # Attempt to normalize and validate the given string.
+      #
+      # On Ruby 1.8 the string is checked by stripping out all non UTF-8
+      # characters and comparing the converted string to the original. If they
+      # do not match then the string is considered invalid.
+      #
+      # On Ruby 1.9+, the string is validate by checking that the string encoding
+      # is UTF-8 and that the string content matches the encoding. If the string
+      # is not an expected encoding then it is converted to UTF-8.
+      #
+      # @api public
+      # @raise [NormalizationError] If the string used an unsupported encoding or did not match its encoding
+      # @param value [String]
+      # @return [void]
+
+      if RUBY_VERSION =~ /^1\.8/
+        require 'iconv'
+
+        def normalize_string(value)
+          converted = Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
+          raise NormalizationError, "String #{value.inspect} is not valid UTF-8" if converted != value
+
+          value
+        end
+      else
+        def normalize_string(value)
+          value = value.encode(Encoding::UTF_8)
+
+          unless value.valid_encoding?
+            raise NormalizationError, "String #{value.inspect} doesn't match the reported encoding #{value.encoding}"
+          end
+
+          value
+        rescue EncodingError
+          raise NormalizationError, "String encoding #{value.encoding} is not UTF-8 and could not be converted to UTF-8"
+        end
+      end
+
+      # Validate all elements of the array.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the elements failed validation
+      # @param value [Array]
+      # @return [void]
+      def normalize_array(value)
+        value.collect do |elem|
+          normalize(elem)
+        end
+      end
+
+      # Validate all keys and values of the hash.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the keys or values failed normalization
+      # @param value [Hash]
+      # @return [void]
+      def normalize_hash(value)
+        Hash[value.collect { |k, v| [normalize(k), normalize(v)] }]
+      end
+    end
+  end
+end

data/lib/custom_facts/util/nothing_loader.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Util
+    # An external fact loader that doesn't load anything
+    # This makes it possible to disable loading
+    # of external facts
+    class NothingLoader
+      def load(collection); end
+    end
+  end
+end

data/lib/custom_facts/util/parser.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+# This class acts as the factory and parent class for parsed
+# facts such as scripts, text, json and yaml files.
+#
+# Parsers must subclass this class and provide their own #results method.
+
+module LegacyFacter
+  module Util
+    module Parser
+      @parsers = []
+
+      # For support mutliple extensions you can pass an array of extensions as
+      # +ext+.
+      def self.extension_matches?(filename, ext)
+        extension = case ext
+                    when String
+                      ext.downcase
+                    when Enumerable
+                      ext.collect(&:downcase)
+                    end
+        [extension].flatten.to_a.include?(file_extension(filename).downcase)
+      end
+
+      def self.file_extension(filename)
+        File.extname(filename).sub('.', '')
+      end
+
+      def self.register(klass, &suitable)
+        @parsers << [klass, suitable]
+      end
+
+      def self.parser_for(filename)
+        registration = @parsers.detect { |k| k[1].call(filename) }
+
+        if registration.nil?
+          NothingParser.new
+        else
+          registration[0].new(filename)
+        end
+      end
+
+      class Base
+        attr_reader :filename
+
+        def initialize(filename, content = nil)
+          @filename = filename
+          @content  = content
+        end
+
+        def content
+          @content ||= Facter::Util::FileHelper.safe_read(filename, nil)
+        end
+
+        # results on the base class is really meant to be just an exception handler
+        # wrapper.
+        def results
+          parse_results
+        rescue Exception => e
+          Facter.log_exception(e, "Failed to handle #{filename} as #{self.class} facts: #{e.message}")
+          nil
+        end
+
+        def parse_results
+          raise ArgumentError, 'Subclasses must respond to parse_results'
+        end
+
+        def parse_executable_output(output)
+          res = nil
+          begin
+            res = YAML.safe_load output
+          rescue Exception => e
+            Facter.debug("Could not parse executable fact output as YAML or JSON (#{e.message})")
+          end
+          res = KeyValuePairOutputFormat.parse output unless res.is_a?(Hash)
+          res
+        end
+      end
+
+      module KeyValuePairOutputFormat
+        def self.parse(output)
+          return {} if output.nil?
+
+          result = {}
+          re = /^(.+?)=(.+)$/
+          output.each_line do |line|
+            if (match_data = re.match(line.chomp))
+              result[match_data[1]] = match_data[2]
+            end
+          end
+          result
+        end
+      end
+
+      # This regex was taken from Psych and adapted
+      # https://github.com/ruby/psych/blob/d2deaa9adfc88fc0b870df022a434d6431277d08/lib/psych/scalar_scanner.rb#L9
+      # It is used to detect Time in YAML, but we use it to wrap time objects in quotes to be treated as strings.
+      TIME =
+        /(\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d\d:\d\d(?:\.\d*)?(?:\s*(?:Z|[-+]\d{1,2}:?(?:\d\d)?))?\s*$)/.freeze
+
+      class YamlParser < Base
+        def parse_results
+          # Add quotes to Yaml time
+          cont = content.gsub(TIME, '"\1"')
+
+          YAML.safe_load(cont, [Date])
+        end
+      end
+
+      register(YamlParser) do |filename|
+        extension_matches?(filename, 'yaml')
+      end
+
+      class TextParser < Base
+        def parse_results
+          KeyValuePairOutputFormat.parse content
+        end
+      end
+
+      register(TextParser) do |filename|
+        extension_matches?(filename, 'txt')
+      end
+
+      class JsonParser < Base
+        def parse_results
+          if LegacyFacter.json?
+            JSON.parse(content)
+          else
+            LegacyFacter.warnonce "Cannot parse JSON data file #{filename} without the json library."
+            LegacyFacter.warnonce 'Suggested next step is `gem install json` to install the json library.'
+            nil
+          end
+        end
+      end
+
+      register(JsonParser) do |filename|
+        extension_matches?(filename, 'json')
+      end
+
+      class ScriptParser < Base
+        def parse_results
+          parse_executable_output(Facter::Core::Execution.exec(quote(filename)))
+        end
+
+        private
+
+        def quote(filename)
+          filename.index(' ') ? "\"#{filename}\"" : filename
+        end
+      end
+
+      register(ScriptParser) do |filename|
+        if LegacyFacter::Util::Config.windows?
+          extension_matches?(filename, %w[bat cmd com exe]) && FileTest.file?(filename)
+        else
+          File.executable?(filename) && FileTest.file?(filename) && !extension_matches?(filename, %w[bat cmd com exe])
+        end
+      end
+
+      # Executes and parses the key value output of Powershell scripts
+      class PowershellParser < Base
+        # Returns a hash of facts from powershell output
+        def parse_results
+          powershell =
+            if File.readable?("#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe")
+              "#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe"
+            elsif File.readable?("#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe")
+              "#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe"
+            else
+              'powershell.exe'
+            end
+
+          shell_command =
+            "\"#{powershell}\" -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File \"#{filename}\""
+          output = Facter::Core::Execution.exec(shell_command)
+          parse_executable_output(output)
+        end
+      end
+
+      register(PowershellParser) do |filename|
+        LegacyFacter::Util::Config.windows? && extension_matches?(filename, 'ps1') && FileTest.file?(filename)
+      end
+
+      # A parser that is used when there is no other parser that can handle the file
+      # The return from results indicates to the caller the file was not parsed correctly.
+      class NothingParser
+        def results
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/custom_facts/util/resolution.rb

@@ -0,0 +1,166 @@
+# This represents a fact resolution. A resolution is a concrete
+# implementation of a fact. A single fact can have many resolutions and
+# the correct resolution will be chosen at runtime. Each time
+# {Facter.add} is called, a new resolution is created and added to the
+# set of resolutions for the fact named in the call.  Each resolution
+# has a {#has_weight weight}, which defines its priority over other
+# resolutions, and a set of {#confine _confinements_}, which defines the
+# conditions under which it will be chosen. All confinements must be
+# satisfied for a fact to be considered _suitable_.
+#
+# @api public
+module Facter
+  module Util
+    class Resolution
+      # @api private
+      attr_accessor :code, :fact_type
+      attr_writer :value
+
+      extend Facter::Core::Execution
+
+      class << self
+        # Expose command execution methods that were extracted into
+        # Facter::Core::Execution from Facter::Util::Resolution in Facter 2.0.0 for
+        # compatibility.
+        #
+        # @deprecated
+        public :search_paths, :which, :absolute_path?, :expand_command, :with_env, :exec
+      end
+
+      include LegacyFacter::Core::Resolvable
+      include LegacyFacter::Core::Suitable
+
+      # @!attribute [rw] name
+      # The name of this resolution. The resolution name should be unique with
+      # respect to the given fact.
+      # @return [String]
+      # @api public
+      attr_accessor :name
+
+      # @!attribute [r] fact
+      # @return [Facter::Util::Fact]
+      # @api private
+      attr_reader :fact
+
+      # Create a new resolution mechanism.
+      #
+      # @param name [String] The name of the resolution.
+      # @return [void]
+      #
+      # @api private
+      def initialize(name, fact)
+        @name = name
+        @fact = fact
+        @confines = []
+        @value = nil
+        @timeout = 0
+        @weight = nil
+      end
+
+      def resolution_type
+        :simple
+      end
+
+      # Evaluate the given block in the context of this resolution. If a block has
+      # already been evaluated emit a warning to that effect.
+      #
+      # @return [void]
+      def evaluate(&block)
+        if @last_evaluated
+          msg = "Already evaluated #{@name}"
+          msg << " at #{@last_evaluated}" if msg.is_a? String
+          msg << ', reevaluating anyways'
+          LegacyFacter.warn msg
+        end
+
+        instance_eval(&block)
+
+        # Ruby 1.9+ provides the source location of procs which can provide useful
+        # debugging information if a resolution is being evaluated twice. Since 1.8
+        # doesn't support this we opportunistically provide this information.
+        @last_evaluated = if block.respond_to? :source_location
+                            block.source_location.join(':')
+                          else
+                            true
+                          end
+      end
+
+      def options(options)
+        accepted_options = %i[name value 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 resolution options #{options.keys.inspect}" unless options.keys.empty?
+      end
+
+      # Sets the code block or external program that will be evaluated to
+      # get the value of the fact.
+      #
+      # @return [void]
+      #
+      # @overload setcode(string)
+      #   Sets an external program to call to get the value of the resolution
+      #   @param [String] string the external program to run to get the
+      #     value
+      #
+      # @overload setcode(&block)
+      #   Sets the resolution's value by evaluating a block at runtime
+      #   @param [Proc] block The block to determine the resolution's value.
+      #     This block is run when the fact is evaluated. Errors raised from
+      #     inside the block are rescued and printed to stderr.
+      #
+      # @api public
+      def setcode(string = nil, &block)
+        if string
+          @code = proc do
+            output = Facter::Core::Execution.execute(string, on_fail: nil)
+            if output.nil? || output.empty?
+              nil
+            else
+              output
+            end
+          end
+        elsif block_given?
+          @code = block
+        else
+          raise ArgumentError, 'You must pass either code or a block'
+        end
+      end
+
+      # Comparation is done based on weight and fact type.
+      # The greatter the weight, the higher the priority.
+      # If weights are equal, we consider external facts greater than custom facts
+      def <=>(other)
+        return compare_equal_weights(other) if weight == other.weight
+        return 1 if weight > other.weight
+        return -1 if weight < other.weight
+      end
+
+      private
+
+      # If the weights are equal, we consider external facts greater tan custom facts
+      def compare_equal_weights(other)
+        # Other is considered greater because self is custom fact and other is external
+        return -1 if fact_type == :custom && other.fact_type == :external
+
+        # Self is considered greater, because it is external fact and other is custom
+        return 1 if fact_type == :external && other.fact_type == :custom
+
+        # They are considered equal
+        0
+      end
+
+      def resolve_value
+        if @value
+          @value
+        elsif @code.nil?
+          nil
+        elsif @code
+          @code.call
+        end
+      end
+    end
+  end
+end