facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/lib/custom_facts/util/loader.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Load facts on demand.
+module LegacyFacter
+  module Util
+    class Loader
+      def initialize(environment_vars = ENV)
+        @loaded = []
+        @environment_vars = environment_vars
+      end
+
+      # Load all resolutions for a single fact.
+      #
+      # @api public
+      # @param name [Symbol]
+      def load(fact)
+        # Now load from the search path
+        shortname = fact.to_s.downcase
+        load_env(shortname)
+
+        filename = shortname + '.rb'
+
+        paths = search_path
+        paths&.each do |dir|
+          # Load individual files
+          file = File.join(dir, filename)
+
+          load_file(file) if File.file?(file)
+        end
+      end
+
+      # Load all facts from all directories.
+      #
+      # @api public
+      def load_all
+        return if defined?(@loaded_all)
+
+        load_env
+
+        paths = search_path
+        paths&.each do |dir|
+          # dir is already an absolute path
+          Dir.glob(File.join(dir, '*.rb')).each do |path|
+            # exclude dirs that end with .rb
+            load_file(path) if File.file?(path)
+          end
+        end
+
+        @loaded_all = true
+      end
+
+      # List directories to search for fact files.
+      #
+      # Search paths are gathered from the following sources:
+      #
+      # 1. $LOAD_PATH entries are expanded to absolute paths
+      # 2. ENV['FACTERLIB'] is split and used verbatim
+      # 3. Entries from Facter.search_path are used verbatim
+      #
+      # A warning will be generated for paths in Facter.search_path that are not
+      # absolute directories.
+      #
+      # @api public
+      # @return [Array<String>]
+      def search_path
+        search_paths = []
+        search_paths += $LOAD_PATH.map { |path| File.expand_path('facter', path) }
+
+        if @environment_vars.include?('FACTERLIB')
+          search_paths += @environment_vars['FACTERLIB'].split(File::PATH_SEPARATOR)
+        end
+
+        search_paths.delete_if { |path| !valid_search_path?(path) }
+
+        LegacyFacter.search_path.each do |path|
+          if valid_search_path?(path)
+            search_paths << path
+          else
+            LegacyFacter.warn "Excluding #{path} from search path. Fact file paths must be an absolute directory"
+          end
+        end
+
+        search_paths.delete_if { |path| !File.directory?(path) }
+
+        search_paths.uniq
+      end
+
+      private
+
+      # Validate that the given path is valid, ie it is an absolute path.
+      #
+      # @api private
+      # @param path [String]
+      # @return [Boolean]
+      def valid_search_path?(path)
+        Pathname.new(path).absolute?
+      end
+
+      # Load a file and record is paths to prevent duplicate loads.
+      #
+      # @api private
+      # @params file [String] The *absolute path* to the file to load
+      def load_file(file)
+        return if @loaded.include? file
+
+        # We have to specify Kernel.load, because we have a load method.
+        begin
+          # Store the file path so we don't try to reload it
+          @loaded << file
+          kernel_load(file)
+        rescue ScriptError => e
+          # Don't store the path if the file can't be loaded
+          # in case it's loadable later on.
+          @loaded.delete(file)
+          LegacyFacter.log_exception(e, "Error loading fact #{file}: #{e.message}")
+        end
+      end
+
+      # Load and execute the Ruby program specified in the file. This exists
+      # for testing purposes.
+      #
+      # @api private
+      # @return [Boolean]
+      def kernel_load(file)
+        Kernel.load(file)
+      end
+
+      # Load facts from the environment.  If no name is provided,
+      # all will be loaded.
+      def load_env(fact = nil)
+        # Load from the environment, if possible
+        @environment_vars.each do |name, value|
+          # Skip anything that doesn't match our regex.
+          next unless name =~ /^facter_?(\w+)$/i
+
+          env_name = Regexp.last_match(1)
+
+          # If a fact name was specified, skip anything that doesn't
+          # match it.
+          next if fact && (env_name != fact)
+
+          LegacyFacter.add(Regexp.last_match(1)) do
+            has_weight 1_000_000
+            setcode { value }
+          end
+
+          # Short-cut, if we are only looking for one value.
+          break if fact
+        end
+      end
+    end
+  end
+end

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
+          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,174 @@
+# 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.
+require 'yaml'
+
+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 ||= File.read(filename)
+        end
+
+        # results on the base class is really meant to be just an exception handler
+        # wrapper.
+        def results
+          parse_results
+        rescue Exception => e
+          LegacyFacter.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
+      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
+
+      class YamlParser < Base
+        def parse_results
+          YAML.safe_load(content)
+        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
+          KeyValuePairOutputFormat.parse LegacyFacter::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]) && File.file?(filename)
+        else
+          File.executable?(filename) && File.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.exist?("#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe")
+              "#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe"
+            elsif File.exist?("#{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 = LegacyFacter::Core::Execution.exec(shell_command)
+          KeyValuePairOutputFormat.parse(output)
+        end
+      end
+
+      register(PowershellParser) do |filename|
+        LegacyFacter::Util::Config.windows? && extension_matches?(filename, 'ps1') && File.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,147 @@
+# 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 LegacyFacter
+  module Util
+    class Resolution
+      # @api private
+      attr_accessor :code
+      attr_writer :value
+
+      attr_reader :weight
+
+      extend LegacyFacter::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 [LegacyFacter::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_option = %i[name value timeout weight fact_type]
+
+        accepted_option.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 = LegacyFacter::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
+
+      private
+
+      def resolve_value
+        if @value
+          @value
+        elsif @code.nil?
+          nil
+        elsif @code
+          @code.call
+        end
+      end
+    end
+  end
+end