openfact 5.0.0.rc0

data/lib/facter/custom_facts/util/parser.rb

@@ -0,0 +1,221 @@
+# 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
+      STDERR_MESSAGE = 'Command %s completed with the following stderr message: %s'
+
+      @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 StandardError => 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 = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0') # Ruby 2.6+
+                    YAML.safe_load(output, permitted_classes: [Symbol, Time])
+                  else
+                    YAML.safe_load(output, [Symbol, Time])
+                  end
+          rescue StandardError => 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
+
+        def log_stderr(msg, command, file)
+          return if !msg || msg.empty?
+
+          file_name = file.split('/').last
+          logger = Facter::Log.new(file_name)
+
+          logger.warn(format(STDERR_MESSAGE, command, msg.strip))
+        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"')
+
+          if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0') # Ruby 2.6+
+            YAML.safe_load(cont, permitted_classes: [Date], aliases: true)
+          else
+            YAML.safe_load(cont, [Date], [], [], true)
+          end
+        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
+            log.warnonce "Cannot parse JSON data file #{filename} without the json library."
+            log.warnonce 'Suggested next step is `gem install json` to install the json library.'
+            nil
+          end
+        end
+
+        private
+
+        def log
+          @log ||= Facter::Log.new(self)
+        end
+      end
+
+      register(JsonParser) do |filename|
+        extension_matches?(filename, 'json')
+      end
+
+      class ScriptParser < Base
+        def parse_results
+          stdout, stderr = Facter::Core::Execution.execute_command(quote(filename))
+          log_stderr(stderr, filename, filename)
+          parse_executable_output(stdout)
+        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}\""
+          stdout, stderr = Facter::Core::Execution.execute_command(shell_command)
+          log_stderr(stderr, shell_command, filename)
+          parse_executable_output(stdout)
+        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/facter/custom_facts/util/resolution.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+# 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
+
+      # @api private
+      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
+        #
+        # @api public
+        public :which, :exec
+
+        # @api private
+        public :with_env
+      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] Associated fact with this resolution.
+      #
+      # @api private
+      attr_reader :fact, :last_evaluated, :file
+
+      # Create a new 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 public
+      def initialize(name, fact)
+        @name = name
+        @fact = fact
+        @confines = []
+        @value = nil
+        @timeout = 0
+        @weight = nil
+      end
+
+      # Returns the fact's resolution type
+      #
+      # @return [Symbol] The fact's type
+      #
+      # @api private
+      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 [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
+
+      # Sets options for the aggregate fact
+      #
+      # @return [nil]
+      #
+      # @api private
+      def options(options)
+        accepted_options = %i[name value timeout weight fact_type file is_env]
+
+        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.
+      #
+      # @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.
+      #
+      # @return [Facter::Util::Resolution] Returns itself
+      #
+      # @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
+        self
+      end
+
+      # Comparison is done based on weight and fact type.
+      #   The greater the weight, the higher the priority.
+      #   If weights are equal, we consider external facts greater than custom facts.
+      #
+      # @return [bool] Weight comparison result
+      #
+      # @api private
+      def <=>(other)
+        if weight == other.weight
+          compare_equal_weights(other)
+        else
+          weight <=> other.weight
+        end
+      end
+
+      private
+
+      def log
+        @log ||= Facter::Log.new(self)
+      end
+
+      # 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.nil?
+          @value
+        elsif @code.nil?
+          nil
+        elsif @code
+          @code.call
+        end
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/util/unix_root.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Util
+    module Root
+      def self.root?
+        Process.uid.zero?
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/util/values.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Util
+    # A util module for custom_facts containing helper methods
+    module Values
+      module_function
+
+      class DeepFreezeError < StandardError; end
+
+      # Duplicate and deeply freeze a given data structure
+      #
+      # @param value [Object] The structure to freeze
+      # @return [void]
+      def deep_freeze(value)
+        case value
+        when Numeric, Symbol, TrueClass, FalseClass, NilClass
+          # These are immutable values, we can safely ignore them
+          value
+        when String
+          value.dup.freeze
+        when Array
+          value.map do |entry|
+            deep_freeze(entry)
+          end.freeze
+        when Hash
+          value.each_with_object({}) do |(key, val), hash|
+            hash[deep_freeze(key)] = deep_freeze(val)
+          end.freeze
+        else
+          raise DeepFreezeError, "Cannot deep freeze #{value}:#{value.class}"
+        end
+      end
+
+      class DeepMergeError < StandardError; end
+
+      # Perform a deep merge of two nested data structures.
+      #
+      # @param left [Object]
+      # @param right [Object]
+      # @param path [Array<String>] The traversal path followed when merging nested hashes
+      #
+      # @return [Object] The merged data structure.
+      def deep_merge(left, right, path = [])
+        ret = nil
+
+        if left.is_a?(Hash) && right.is_a?(Hash)
+          ret = left.merge(right) do |key, left_val, right_val|
+            path.push(key)
+            merged = deep_merge(left_val, right_val, path)
+            path.pop
+            merged
+          end
+        elsif left.is_a?(Array) && right.is_a?(Array)
+          ret = left.dup.concat(right)
+        elsif right.nil?
+          ret = left
+        elsif left.nil?
+          ret = right
+        elsif left.nil? && right.nil?
+          ret = nil
+        else
+          msg = "Cannot merge #{left.inspect}:#{left.class} and #{right.inspect}:#{right.class}"
+          unless path.empty?
+            msg << ' at root'
+            msg << path.map { |part| "[#{part.inspect}]" }.join
+          end
+          raise DeepMergeError, msg
+        end
+
+        ret
+      end
+
+      def convert(value)
+        value = value.to_s if value.is_a?(Symbol)
+        value = value.downcase if value.is_a?(String)
+        value
+      end
+
+      # Flatten the given data structure to something that's suitable to return
+      # as flat facts.
+      #
+      # @param path [String] The fact path to be prefixed to the given value.
+      # @param structure [Object] The data structure to flatten. Nested hashes
+      #   will be recursively flattened, everything else will be returned as-is.
+      #
+      # @return [Hash] The given data structure prefixed with the given path
+      def flatten_structure(path, structure)
+        results = {}
+
+        if structure.is_a? Hash
+          structure.each_pair do |name, value|
+            new_path = "#{path}_#{name}".gsub(%r{-|/}, '_')
+            results.merge! flatten_structure(new_path, value)
+          end
+        elsif structure.is_a? Array
+          structure.each_with_index do |value, index|
+            new_path = "#{path}_#{index}"
+            results.merge! flatten_structure(new_path, value)
+          end
+        else
+          results[path] = structure
+        end
+
+        results
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/util/windows_root.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Util
+    module Root
+      def self.root?
+        require_relative '../../../facter/resolvers/windows/ffi/identity_ffi'
+        IdentityFFI.privileged?
+      rescue LoadError => e
+        log = Facter::Log.new(self)
+        log.debug("The ffi gem has not been installed: #{e}")
+      end
+    end
+  end
+end

data/lib/facter/facts/aix/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/aix/augeas/version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Augeas
+      class Version
+        FACT_NAME = 'augeas.version'
+        ALIASES = 'augeasversion'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Augeas.resolve(:augeas_version)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+           Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/aix/disks.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class Disks
+      FACT_NAME = 'disks'
+      ALIASES = %w[blockdevices blockdevice_.*_size].freeze
+
+      def call_the_resolver
+        facts = []
+        disks = Facter::Resolvers::Aix::Disks.resolve(:disks)
+
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if disks.nil? || disks.empty?
+
+        blockdevices = disks.keys.join(',')
+        facts.push(Facter::ResolvedFact.new(FACT_NAME, disks))
+        facts.push(Facter::ResolvedFact.new('blockdevices', blockdevices, :legacy))
+        add_legacy_facts(disks, facts)
+
+        facts
+      end
+
+      private
+
+      def add_legacy_facts(disks, facts)
+        disks.each do |disk_name, disk_info|
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes], :legacy))
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/aix/facterversion.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class Facterversion
+      FACT_NAME = 'facterversion'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Facterversion.resolve(:facterversion)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/aix/filesystems.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class Filesystems
+      FACT_NAME = 'filesystems'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Aix::Filesystems.resolve(:file_systems)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/aix/hypervisors/lpar.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Hypervisors
+      class Lpar
+        FACT_NAME = 'hypervisors.lpar'
+
+        def call_the_resolver
+          lpar_partition_number = Facter::Resolvers::Lpar.resolve(:lpar_partition_number)
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless lpar_partition_number&.positive?
+
+          Facter::ResolvedFact.new(FACT_NAME,
+                                   partition_number: lpar_partition_number,
+                                   partition_name: Facter::Resolvers::Lpar.resolve(:lpar_partition_name))
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/aix/hypervisors/wpar.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Hypervisors
+      class Wpar
+        FACT_NAME = 'hypervisors.wpar'
+
+        def call_the_resolver
+          wpar_key = Facter::Resolvers::Wpar.resolve(:wpar_key)
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless wpar_key&.positive?
+
+          Facter::ResolvedFact.new(FACT_NAME, key: wpar_key,
+                                              configured_id: Facter::Resolvers::Wpar.resolve(:wpar_configured_id))
+        end
+      end
+    end
+  end
+end