facter 4.2.3 → 4.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 353d24b45ac4083ff9a2f7de05702a93e8701487cc6020de93ed974d527e7f53
-  data.tar.gz: c02329462e40922777fac34fab775ea1d68b884b7d4d8f8e99544bdb737f57e8
+  metadata.gz: 5648b99a92b05c556d728186e4df5fed506b8edf3ca2ac1e77708a2ebe9b8359
+  data.tar.gz: 9e58e46ab92d8d4aeffcf54a4b13b8d25ca751e08669f73c067a245cb96bdd93
 SHA512:
-  metadata.gz: 1ccd6eb8e93836cf558c7ed12c943d8c30d14bad521f2de821b014ceb30b3d1f4fc92cc3c54690ff853b5d62dd4c3521293127f87d08fe6525d5ff2f317e3637
-  data.tar.gz: d4a75033160dac87a2244855c7a2ff8d34fb733b527cc8ffd45279c3e2821b0860f3b1982ab1e0e4182c9c75cf45129ebe0c68738eeb605b9e435b5d460da309
+  metadata.gz: 467e8ef226865d0ae6d88fca05bc8c44e4dbbc10dec1e8117947e68dac09b5046878eaf3e2a45d1dd572b9b3b76f44ff14a7c62653df83854ee38172a0e576cf
+  data.tar.gz: 71405bf059cbba0572136a4d67db8700542f62f668a4f50f7fe99a818f82bc5f114bb8f12baa3a86be5bd59e50337e23e34f485dd5bae522c0d0a8ee8206a928

data/lib/facter/config.rb

@@ -167,6 +167,7 @@ module Facter
           macosx_productversion_major
           macosx_productversion_minor
           macosx_productversion_patch
+          windows_display_version
           windows_edition_id
           windows_installation_type
           windows_product_name

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

@@ -7,6 +7,7 @@ module Facter
     module Execution
       class Base
         STDERR_MESSAGE = 'Command %s completed with the following stderr message: %s'
+        VALID_OPTIONS = %i[on_fail expand logger timeout].freeze
 
         def initialize
           @log = Log.new(self)
@@ -42,7 +43,7 @@ module Facter
         end
 
         def execute(command, options = {})
-          on_fail, expand, logger, time_limit = extract_options(options)
+          on_fail, expand, logger, timeout = extract_options(options)
 
           expanded_command = if !expand && builtin_command?(command) || logger
                                command
@@ -59,12 +60,12 @@ module Facter
             return on_fail
           end
 
-          out, = execute_command(expanded_command, on_fail, logger, time_limit)
+          out, = execute_command(expanded_command, on_fail, logger, timeout)
           out
         end
 
-        def execute_command(command, on_fail = nil, logger = nil, time_limit = nil)
-          time_limit ||= 300
+        def execute_command(command, on_fail = nil, logger = nil, timeout = nil)
+          timeout ||= 300
           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
@@ -78,12 +79,12 @@ module Facter
               out_reader = Thread.new { stdout.read }
               err_reader = Thread.new { stderr.read }
               begin
-                Timeout.timeout(time_limit) do
+                Timeout.timeout(timeout) do
                   stdout_messages << out_reader.value
                   stderr_messages << err_reader.value
                 end
               rescue Timeout::Error
-                message = "Timeout encounter after #{time_limit}s, killing process with pid: #{pid}"
+                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
@@ -114,10 +115,16 @@ module Facter
           on_fail = options.fetch(:on_fail, :raise)
           expand = options.fetch(:expand, true)
           logger = options[:logger]
-          time_limit = options[:limit].to_i
-          time_limit = time_limit.positive? ? time_limit : nil
+          timeout = (options[:timeout] || options[:time_limit] || options[:limit]).to_i
+          timeout = timeout.positive? ? timeout : nil
 
-          [on_fail, expand, logger, time_limit]
+          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)

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

@@ -15,9 +15,9 @@ module Facter
 
       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
+      # 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
       #
@@ -27,8 +27,9 @@ module Facter
       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.
+      # 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
@@ -40,7 +41,8 @@ module Facter
       end
 
       # Determine in a platform-specific way whether a path is absolute. This
-      #   defaults to the local platform if none is specified.
+      # 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
@@ -58,8 +60,9 @@ module Facter
       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.
+      # 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
@@ -71,8 +74,9 @@ module Facter
       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.
+      # 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
       #
@@ -84,6 +88,7 @@ module Facter
       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
@@ -96,16 +101,18 @@ module Facter
       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
       #
-      # Options accepted values :on_fail How to behave when the command could
+      # @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.
-      #   :logger Optional logger used to log the command's stderr.
-      #   :time_limit Optional time out for the specified command. If no time_limit is passed,
-      #   a default of 300 seconds is used.
+      # @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
@@ -119,13 +126,14 @@ module Facter
       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 :raise.
       # @param logger Optional logger used to log the command's stderr.
-      # @param time_limit Optional time out for the specified command. If no time_limit is passed,
+      # @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
@@ -135,8 +143,8 @@ module Facter
       #   :on_fail if command execution failed and :on_fail was specified.
       #
       # @api private
-      def execute_command(command, on_fail = nil, logger = nil, time_limit = nil)
-        @@impl.execute_command(command, on_fail, logger, time_limit)
+      def execute_command(command, on_fail = nil, logger = nil, timeout = nil)
+        @@impl.execute_command(command, on_fail, logger, timeout)
       end
 
       class ExecutionFailure < StandardError; end

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

@@ -117,7 +117,7 @@ module Facter
       #
       # @api public
       def value
-        return @value if @value
+        return @value unless @value.nil?
 
         if @resolves.empty?
           log.debug format('No resolves for %<name>s', name: @name)

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

@@ -141,13 +141,13 @@ module LegacyFacter
           # Skip anything that doesn't match our regex.
           next unless name =~ /^facter_?(\w+)$/i
 
-          env_name = Regexp.last_match(1)
+          env_name = Regexp.last_match(1).downcase
 
           # 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), fact_type: :external, is_env: true) do
+          LegacyFacter.add(env_name, fact_type: :external, is_env: true) do
             has_weight 1_000_000
             setcode { value }
           end

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

@@ -188,7 +188,7 @@ module Facter
       end
 
       def resolve_value
-        if @value
+        if !@value.nil?
           @value
         elsif @code.nil?
           nil

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

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        disks = Facter::Resolvers::Linux::Disk.resolve(:disks)
+        disks = Facter::Resolvers::Linux::Disks.resolve(:disks)
 
         return Facter::ResolvedFact.new(FACT_NAME, nil) if disks.nil? || disks.empty?
 

data/lib/facter/facts/linux/hypervisors/kvm.rb

@@ -35,13 +35,15 @@ module Facts
         end
 
         def kvm?
+          product_name = discover_hypervisor
           bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
           @log.debug("Detected bios vendor: #{bios_vendor}")
 
           Facter::Resolvers::VirtWhat.resolve(:vm) == 'kvm' ||
             Facter::Resolvers::Lspci.resolve(:vm) == 'kvm' ||
             bios_vendor&.include?('Amazon EC2') ||
-            bios_vendor&.include?('Google')
+            bios_vendor&.include?('Google') ||
+            product_name&.include?('OpenStack')
         end
 
         def discover_provider

data/lib/facter/facts/windows/os/windows/display_version.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module Os
+      module Windows
+        class DisplayVersion
+          FACT_NAME = 'os.windows.display_version'
+          ALIASES = 'windows_display_version'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::ProductRelease.resolve(:display_version)
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/timezone.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'timezone'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Timezone.resolve(:timezone)
+        fact_value = Facter::Resolvers::Windows::Timezone.resolve(:timezone)
 
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end

data/lib/facter/framework/cli/cli.rb

@@ -97,6 +97,10 @@ module Facter
                  type: :boolean,
                  desc: 'Resolve facts sequentially'
 
+    class_option :http_debug,
+                 type: :boolean,
+                 desc: 'Whether to write HTTP request and responses to stderr. This should never be used in production.'
+
     class_option :puppet,
                  type: :boolean,
                  aliases: '-p',

data/lib/facter/framework/core/cache_manager.rb

@@ -167,7 +167,8 @@ cache_format_version is incorrect!")
         next unless check_ttls?(group_name, @fact_groups.get_group_ttls(group_name))
 
         cache_file_name = File.join(@cache_dir, group_name)
-        next if File.readable?(cache_file_name)
+
+        next if facts_already_cached?(cache_file_name, data)
 
         @log.debug("caching values for #{group_name} facts")
 
@@ -176,6 +177,21 @@ cache_format_version is incorrect!")
       end
     end
 
+    def facts_already_cached?(cache_file_name, data)
+      if File.readable?(cache_file_name)
+        file = Facter::Util::FileHelper.safe_read(cache_file_name)
+        begin
+          cached_data = JSON.parse(file) unless file.nil?
+          return true if (data.keys - cached_data.keys).empty?
+        rescue JSON::ParserError => e
+          @log.debug("Failed to read cache file #{cache_file_name}. Detail: #{e.message}")
+        rescue NoMethodError => e
+          @log.debug("No keys found in #{cache_file_name}. Detail: #{e.message}")
+        end
+      end
+      false
+    end
+
     def read_group_json(group_name)
       return @groups[group_name] if @groups.key?(group_name)
 

data/lib/facter/framework/core/fact_manager.rb

@@ -51,7 +51,9 @@ module Facter
       core_and_external_facts = core_or_external_fact(user_query) || []
       resolved_facts = core_and_external_facts + custom_facts
 
-      resolved_facts = all_custom_facts(user_query) if resolved_facts.empty?
+      if resolved_facts.empty? || resolved_facts.none? { |rf| rf.resolves?(user_query) }
+        resolved_facts.concat(all_custom_facts(user_query))
+      end
 
       @cache_manager.cache_facts(resolved_facts)
 

data/lib/facter/framework/core/options/option_store.rb

@@ -36,6 +36,7 @@ module Facter
     @hocon = false
     @allow_external_loggers = true
     @force_dot_resolution = false
+    @http_debug = false
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy,
@@ -44,7 +45,7 @@ module Facter
       attr_accessor :config, :strict, :json,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
                     :config_file_external_dir, :default_external_dir, :fact_groups, :force_dot_resolution,
-                    :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers
+                    :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers, :http_debug
 
       attr_writer :external_dir
 
@@ -179,6 +180,7 @@ module Facter
         @ttls = []
         @block = true
         @cli = nil
+        @http_debug = false
         reset_config
       end
 

data/lib/facter/framework/core/options.rb

@@ -55,10 +55,25 @@ module Facter
 
       def store(options)
         options.each do |key, value|
-          value = '' if key == 'log_level' && value == 'log_level'
+          value = munge_option(key, value)
           OptionStore.set(key, value)
         end
       end
+
+      private
+
+      def munge_option(key, value)
+        return value unless key.to_sym == :log_level
+
+        case value.to_sym
+        when :log_level
+          ''
+        when :none
+          'unknown'
+        else
+          value
+        end
+      end
     end
   end
 end

data/lib/facter/framework/detector/os_detector.rb

@@ -5,7 +5,7 @@ require 'rbconfig'
 class OsDetector
   include Singleton
 
-  attr_reader :identifier, :version, :hierarchy
+  attr_reader :identifier, :hierarchy
 
   def initialize(*_args)
     @log = Facter::Log.new(self)
@@ -75,8 +75,7 @@ class OsDetector
     [Facter::Resolvers::OsRelease,
      Facter::Resolvers::RedHatRelease,
      Facter::Resolvers::SuseRelease].each do |resolver|
-      @identifier = resolver.resolve(:identifier)
-      @version = resolver.resolve(:version)
+      @identifier = resolver.resolve(:id)
       break if @identifier
     end
 

data/lib/facter/models/resolved_fact.rb

@@ -23,5 +23,9 @@ module Facter
     def to_s
       @value.to_s
     end
+
+    def resolves?(user_query)
+      @name == user_query
+    end
   end
 end

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

@@ -34,7 +34,7 @@ module Facter
 
             return if stdout.empty?
 
-            info_size = Facter::Util::Aix::InfoExtractor.extract(stdout, /PP SIZE:|TOTAL PPs:|FREE PPs:|PV STATE:/)
+            info_size = Facter::Util::Aix::InfoExtractor.extract(stdout, :lspv)
 
             return unless info_size['PV STATE']
 

data/lib/facter/resolvers/aix/mountpoints.rb

@@ -18,23 +18,29 @@ module Facter
           def read_mount(fact_name)
             @fact_list[:mountpoints] = {}
             output = Facter::Core::Execution.execute('mount', logger: log)
-            output.split("\n").map do |line|
-              next if line =~ /node|---|procfs|ahafs/
+            output.split("\n").drop(2).map do |line|
+              next if line =~ /procfs|ahafs/
 
-              elem = line.split("\s")
-
-              @fact_list[:mountpoints][elem[1]] = { device: elem[0], filesystem: elem[2],
-                                                    options: elem.last.split(',') }
+              add_mount_points_fact(line)
             end
 
             retrieve_sizes_for_mounts
             @fact_list[fact_name]
           end
 
+          def add_mount_points_fact(line)
+            elem = line.split("\s")
+
+            elem.shift unless line[0] == ' '
+
+            @fact_list[:mountpoints][elem[1]] = { device: elem[0], filesystem: elem[2],
+                                                  options: elem.last.include?(':') ? [] : elem.last.split(',') }
+          end
+
           def retrieve_sizes_for_mounts
             output = Facter::Core::Execution.execute('df -P', logger: log)
-            output.split("\n").map do |line|
-              next if line =~ /Filesystem|-\s+-\s+-/
+            output.split("\n").drop(1).map do |line|
+              next if line =~ /-\s+-\s+-/
 
               mount_info = line.split("\s")
               mount_info[3] = translate_to_bytes(mount_info[3])

data/lib/facter/resolvers/aix/partitions.rb

@@ -40,7 +40,7 @@ module Facter
 
             return if stdout.empty?
 
-            info_hash =  Facter::Util::Aix::InfoExtractor.extract(stdout, /PPs:|PP SIZE|TYPE:|LABEL:|MOUNT/)
+            info_hash =  Facter::Util::Aix::InfoExtractor.extract(stdout, :lslv)
             size_bytes = compute_size(info_hash)
 
             part_info = {

data/lib/facter/resolvers/aix/processors.rb

@@ -42,8 +42,9 @@ module Facter
             return unless result
 
             names = retrieve_from_array(result.scan(/name\s=\s.*/), 1)
+            status = retrieve_from_array(result.scan(/\s+status\s=\s.*/), 1)
 
-            names.each { |elem| query_cuat(elem) }
+            names.each_with_index { |elem, idx| query_cuat(elem) if status[idx] == '1' }
           end
 
           def query_cuat(name)

data/lib/facter/resolvers/disks.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Disks < BaseResolver
+        @log = Facter::Log.new(self)
+
+        init_resolver
+
+        DIR = '/sys/block'
+        FILE_PATHS = { model: 'device/model',
+                       size: 'size',
+                       vendor: 'device/vendor',
+                       type: 'queue/rotational',
+                       serial: 'false',
+                       wwn: 'false' }.freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) do
+              return unless @fact_list.empty?
+
+              build_disks_hash
+
+              read_facts
+
+              @fact_list[:disks] = nil if @fact_list[:disks].empty?
+              @fact_list[fact_name]
+            end
+          end
+
+          def lsblk(option, disk)
+            result = Facter::Core::Execution.execute(
+              "/usr/bin/lsblk -dn -o #{option} /dev/#{disk}", on_fail: '', timeout: 1
+            ).strip
+            result.empty? ? nil : result
+          end
+
+          def read_facts
+            FILE_PATHS.each do |key, file|
+              @fact_list[:disks].each do |disk, value|
+                file_path = File.join(DIR, disk, file)
+
+                result = if file == 'false'
+                           lsblk(key, disk)
+                         else
+                           Facter::Util::FileHelper.safe_read(file_path, nil)&.strip
+                         end
+
+                next unless result
+
+                value[key] = case key
+                             when :size
+                               # Linux always considers sectors to be 512 bytes long
+                               # independently of the devices real block size.
+                               construct_size(value, result)
+                             when :type
+                               result == '0' ? 'ssd' : 'hdd'
+                             else
+                               result
+                             end
+              end
+            end
+          end
+
+          def build_disks_hash
+            valid_disks = Facter::Util::FileHelper.dir_children(DIR)
+                                                  .select { |disk| File.readable?(File.join(DIR, disk, 'device')) }
+
+            @fact_list[:disks] = {}
+            valid_disks.each { |disk| @fact_list[:disks][disk] = {} }
+          end
+
+          def construct_size(facts, value)
+            value = value.to_i * 512
+            facts[:size_bytes] = value
+            facts[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/dmi.rb

@@ -36,6 +36,7 @@ module Facter
             return unless File.directory?('/sys/class/dmi')
 
             file_content = Facter::Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
+                                                   .encode('UTF-8', invalid: :replace)
             if files.include?(fact_name.to_s) && file_content
               file_content = file_content.strip
               @fact_list[fact_name] = file_content unless file_content.empty?

data/lib/facter/resolvers/ec2.rb

@@ -20,7 +20,7 @@ module Facter
         def read_facts(fact_name)
           @fact_list[:metadata] = {}
           query_for_metadata(EC2_METADATA_ROOT_URL, @fact_list[:metadata])
-          @fact_list[:userdata] = get_data_from(EC2_USERDATA_ROOT_URL).strip
+          @fact_list[:userdata] = get_data_from(EC2_USERDATA_ROOT_URL).strip.force_encoding('UTF-8')
           @fact_list[fact_name]
         end
 

data/lib/facter/resolvers/lsb_release.rb

@@ -38,8 +38,6 @@ module Facter
 
           result = Hash[*release_info.flatten]
           result.each { |k, v| @fact_list[k.downcase.gsub(/\s/, '_').to_sym] = v }
-
-          @fact_list[:identifier] = @fact_list[:distributor_id]
         end
       end
     end

data/lib/facter/resolvers/macosx/{processor.rb → processors.rb}

@@ -29,42 +29,42 @@ module Facter
 
           def read_processor_data(fact_name)
             output = Facter::Core::Execution.execute("sysctl #{ITEMS.values.join(' ')}", logger: log)
-            build_fact_list(output.split("\n"))
+            processors_hash = Hash[*output.split("\n").collect { |v| [v.split(': ')[0], v.split(': ')[1]] }.flatten]
+            build_fact_list(processors_hash)
             @fact_list[fact_name]
           end
 
-          def build_fact_list(processors_data)
-            build_logical_count(processors_data[0])
-            build_physical_count(processors_data[1])
-            build_models(processors_data[2])
-            build_speed(processors_data[3])
-            build_cores_per_socket(processors_data[4])
-            build_threads_per_core(processors_data[5], processors_data[4])
+          def build_fact_list(hash)
+            build_logical_count(hash)
+            build_physical_count(hash)
+            build_models(hash)
+            build_speed(hash)
+            build_cores_per_socket(hash)
+            build_threads_per_core(hash)
           end
 
-          def build_logical_count(count)
-            @fact_list[:logicalcount] = count.split(': ')[1].to_i
+          def build_logical_count(hash)
+            @fact_list[:logicalcount] = hash[ITEMS[:logical_count]].to_i
           end
 
-          def build_physical_count(count)
-            @fact_list[:physicalcount] = count.split(': ')[1].to_i
+          def build_physical_count(hash)
+            @fact_list[:physicalcount] = hash[ITEMS[:physical_count]].to_i
           end
 
-          def build_models(model)
-            brand = model.split(': ').fetch(1)
-            @fact_list[:models] = Array.new(@fact_list[:logicalcount].to_i, brand)
+          def build_models(hash)
+            @fact_list[:models] = Array.new(@fact_list[:logicalcount].to_i, hash[ITEMS[:brand]])
           end
 
-          def build_speed(value)
-            @fact_list[:speed] = value.split(': ')[1].to_i
+          def build_speed(hash)
+            @fact_list[:speed] = hash[ITEMS[:speed]].to_i
           end
 
-          def build_cores_per_socket(count)
-            @fact_list[:cores_per_socket] = count.split(': ')[1].to_i
+          def build_cores_per_socket(hash)
+            @fact_list[:cores_per_socket] = hash[ITEMS[:cores_per_socket]].to_i
           end
 
-          def build_threads_per_core(number_of_threads, number_of_cores)
-            @fact_list[:threads_per_core] = number_of_threads.split(': ')[1].to_i / number_of_cores.split(': ')[1].to_i
+          def build_threads_per_core(hash)
+            @fact_list[:threads_per_core] = hash[ITEMS[:threads_per_core]].to_i / hash[ITEMS[:cores_per_socket]].to_i
           end
         end
       end

data/lib/facter/resolvers/os_release.rb

@@ -20,53 +20,84 @@ module Facter
         private
 
         def post_resolve(fact_name, _options)
-          @fact_list.fetch(fact_name) { read_os_release_file(fact_name) }
+          @fact_list.fetch(fact_name) do
+            # If we get here multiple times per run it's probably because
+            # someone's asking for a os-release value not present in the file
+            # (e.g. VERSION is not a thing on rolling distributions, so this
+            # code will always run if the resolver is being asked for :version,
+            # because it'll never get cached).
+            #
+            # Just return early to avoid reparsing the file.
+            return unless @fact_list.empty?
+
+            pairs = read_and_parse_os_release_file
+            return unless pairs
+
+            fill_fact_list(pairs)
+
+            process_name
+            process_version_id
+            process_id
+
+            @fact_list[fact_name]
+          end
         end
 
-        def read_os_release_file(fact_name)
-          output = Facter::Util::FileHelper.safe_readlines('/etc/os-release')
-          return @fact_list[:name] = nil if output.empty?
+        def read_and_parse_os_release_file
+          content = Facter::Util::FileHelper.safe_readlines('/etc/os-release')
+          return nil if content.empty?
 
           pairs = []
-
-          output.each do |line|
+          content.each do |line|
             pairs << line.strip.delete('"').split('=', 2)
           end
 
-          fill_fact_list(pairs)
-          process_name
-          pad_version_id
-          normalize_opensuse_identifier
-
-          @fact_list[fact_name]
+          pairs
         end
 
         def fill_fact_list(pairs)
           result = Hash[*pairs.flatten]
           result.each { |k, v| @fact_list[k.downcase.to_sym] = v }
-
-          @fact_list[:identifier] = @fact_list[:id]
         end
 
-        def pad_version_id
+        def process_version_id
+          return unless @fact_list[:version_id]
+
           @fact_list[:version_id] = "#{@fact_list[:version_id]}.0" unless @fact_list[:version_id] =~ /\./
         end
 
+        def process_id
+          return unless @fact_list[:id]
+
+          @fact_list[:id] = 'opensuse' if @fact_list[:id] =~ /opensuse/i
+        end
+
         def process_name
-          os_name = @fact_list[:name]
-          return unless os_name
+          return unless @fact_list[:name]
+
+          join_os_name
+          capitalize_os_name
+          append_linux_to_os_name
+        end
 
+        def join_os_name
+          os_name = @fact_list[:name]
           @fact_list[:name] = if os_name.downcase.start_with?('red', 'oracle', 'arch', 'manjaro')
                                 os_name = os_name.split(' ')[0..1].join
-                                os_name = os_name.capitalize if os_name.downcase.start_with?('arch', 'manjaro')
                                 os_name
                               else
                                 os_name.split(' ')[0].strip
                               end
         end
 
-        def normalize_opensuse_identifier
-          @fact_list[:identifier] = 'opensuse' if @fact_list[:identifier] =~ /opensuse/i
+        def capitalize_os_name
+          os_name = @fact_list[:name]
+          @fact_list[:name] = os_name.capitalize if os_name.downcase.start_with?('arch', 'manjaro')
+        end
+
+        def append_linux_to_os_name
+          os_name = @fact_list[:name]
+          @fact_list[:name] = os_name + 'Linux' if os_name.downcase.start_with?('virtuozzo')
         end
       end
     end

data/lib/facter/resolvers/redhat_release.rb

@@ -36,18 +36,18 @@ module Facter
           @fact_list[:distributor_id] = distributor_id(output_strings[0])
           @fact_list[:name] = release_name(output_strings[0])
           @fact_list[:version] = version(output_strings)
-          @fact_list[:identifier] = identifier(@fact_list[:name])
+          @fact_list[:id] = id(@fact_list[:name])
         end
 
         def release_name(value)
           value.split.reject { |el| el.casecmp('linux').zero? }[0..1].join
         end
 
-        def identifier(value)
-          identifier = value.downcase
-          identifier = 'rhel' if @fact_list[:name].casecmp('Red Hat Enterprise Linux')
+        def id(value)
+          id = value.downcase
+          id = 'rhel' if @fact_list[:name].casecmp('Red Hat Enterprise Linux')
 
-          identifier
+          id
         end
 
         def codename(value)

data/lib/facter/resolvers/suse_release.rb

@@ -24,7 +24,7 @@ module Facter
 
           @fact_list[:name] = output_strings[0]
           @fact_list[:version] = output_strings[1]
-          @fact_list[:identifier] = @fact_list[:name].downcase
+          @fact_list[:id] = @fact_list[:name].downcase
 
           @fact_list[fact_name]
         end

data/lib/facter/resolvers/windows/ffi/winnls_ffi.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'facter/resolvers/windows/ffi/ffi'
+
+module WinnlsFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :GetACP, [], :uint
+end

data/lib/facter/resolvers/windows/product_release.rb

@@ -24,10 +24,19 @@ module Facter
 
         def build_fact_list(reg)
           reg.each do |name, _value|
-            @fact_list[:edition_id] = reg[name] if name == 'EditionID'
-            @fact_list[:installation_type] = reg[name] if name == 'InstallationType'
-            @fact_list[:product_name] = reg[name] if name == 'ProductName'
-            @fact_list[:release_id] = reg[name] if name == 'ReleaseId'
+            case name
+            when 'EditionID'
+              @fact_list[:edition_id] = reg[name]
+            when 'InstallationType'
+              @fact_list[:installation_type] = reg[name]
+            when 'ProductName'
+              @fact_list[:product_name] = reg[name]
+            when 'DisplayVersion'
+              @fact_list[:release_id] = reg[name]
+              @fact_list[:display_version] = reg[name]
+            when 'ReleaseId'
+              @fact_list[:release_id] = reg[name] unless @fact_list[:release_id]
+            end
           end
         end
       end

data/lib/facter/resolvers/windows/timezone.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class Timezone < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { determine_timezone }
+          end
+
+          def determine_timezone
+            timezone = Time.now.zone
+            @fact_list[:timezone] = timezone.force_encoding("CP#{codepage}").encode('UTF-8', invalid: :replace)
+          rescue ArgumentError
+            @fact_list[:timezone] = timezone
+          end
+
+          def codepage
+            result = codepage_from_api
+            result.empty? ? codepage_from_registry : result
+          end
+
+          def codepage_from_registry
+            require 'win32/registry'
+            ::Win32::Registry::HKEY_LOCAL_MACHINE.open('SYSTEM\CurrentControlSet\Control\Nls\CodePage')['ACP']
+          end
+
+          def codepage_from_api
+            require 'facter/resolvers/windows/ffi/winnls_ffi'
+            WinnlsFFI.GetACP.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/aix/info_extractor.rb

@@ -6,17 +6,68 @@ module Facter
       module InfoExtractor
         MEGABYTES_EXPONENT = 1024**2
         GIGABYTES_EXPONENT = 1024**3
+        PROPERTIES = {
+          lslv: [
+            'LOGICAL VOLUME:',
+            'VOLUME GROUP:',
+            'LV IDENTIFIER:',
+            'PERMISSION:',
+            'VG STATE:',
+            'LV STATE:',
+            'TYPE:',
+            'WRITE VERIFY:',
+            'MAX LPs:',
+            'PP SIZE:',
+            'COPIES:',
+            'SCHED POLICY:',
+            'LPs:',
+            'PPs:',
+            'STALE PPs:',
+            'BB POLICY:',
+            'INTER-POLICY:',
+            'RELOCATABLE:',
+            'INTRA-POLICY:',
+            'UPPER BOUND:',
+            'MOUNT POINT:',
+            'LABEL:',
+            'MIRROR WRITE CONSISTENCY:',
+            'EACH LP COPY ON A SEPARATE PV ?:',
+            'Serialize IO ?:'
+          ],
+          lspv: [
+            'PHYSICAL VOLUME:',
+            'VOLUME GROUP:',
+            'PV IDENTIFIER:',
+            'VG IDENTIFIER',
+            'PV STATE:',
+            'STALE PARTITIONS:',
+            'ALLOCATABLE:',
+            'PP SIZE:',
+            'LOGICAL VOLUMES:',
+            'TOTAL PPs:',
+            'VG DESCRIPTORS:',
+            'FREE PPs:',
+            'HOT SPARE:',
+            'USED PPs:',
+            'MAX REQUEST:',
+            'FREE DISTRIBUTION:',
+            'USED DISTRIBUTION:',
+            'MIRROR POOL:'
+          ]
+        }.freeze
 
-        def self.extract(content, regex)
-          content = content.each_line.map do |line|
-            next unless regex =~ line
-
-            line.split(/:\s*|\s{2,}/)
+        def self.extract(content, cmd)
+          property_hash = {}
+          properties = PROPERTIES[cmd]
+          properties.each do |property|
+            str = (properties - [property]).join('|')
+            matcher = content.match(/#{Regexp.escape(property)}([^\n]*?)(#{str}|\n|$)/s)
+            if matcher
+              value = matcher[1].strip
+              property_hash[property.split(':').first] = value
+            end
           end
-
-          content.flatten!.reject!(&:nil?)
-
-          Hash[*content]
+          property_hash
         end
       end
     end

data/lib/facter/util/facts/windows_release_finder.rb

@@ -23,9 +23,11 @@ module Facter
           private
 
           def check_version_10(consumerrel, kernel_version)
+            return '10' if consumerrel
+
             build_number = kernel_version[/([^.]*)$/].to_i
-            if consumerrel
-              '10'
+            if build_number >= 20_348
+              '2022'
             elsif build_number >= 17_623
               '2019'
             else

data/lib/facter/util/file_helper.rb

@@ -22,6 +22,16 @@ module Facter
           default_return
         end
 
+        def dir_children(path)
+          children = if RUBY_VERSION.to_f < 2.5
+                       Dir.entries(path).reject { |dir| ['.', '..'].include?(dir) }
+                     else
+                       Dir.children(path)
+                     end
+
+          children
+        end
+
         private
 
         def log_failed_to_read(path)

data/lib/facter/util/resolvers/http.rb

@@ -60,6 +60,9 @@ module Facter
             http = Net::HTTP.new(parsed_url.host)
             http.read_timeout = timeouts[:session] || SESSION_TIMEOUT
             http.open_timeout = timeouts[:connection] || CONNECTION_TIMEOUT
+
+            http.set_debug_output($stderr) if Options[:http_debug]
+
             http
           end
 

data/lib/facter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Facter
-  VERSION = '4.2.3' unless defined?(VERSION)
+  VERSION = '4.2.7' unless defined?(VERSION)
 end

data/lib/facter.rb

@@ -205,6 +205,25 @@ module Facter
       Facter::Options[:debug] = debug_bool
     end
 
+    # Check whether http debugging is enabled
+    #
+    # @return [bool]
+    #
+    # @api public
+    def http_debug?
+      Options[:http_debug]
+    end
+
+    # Enable or disable http debugging
+    # @param debug_bool [bool] State which http debugging should have
+    #
+    # @return [type] [description]
+    #
+    # @api public
+    def http_debug(http_debug_bool)
+      Facter::Options[:http_debug] = http_debug_bool
+    end
+
     # Enable sequential resolving of facts
     #
     # @return [bool]
@@ -390,7 +409,7 @@ module Facter
     #
     # @api public
     def value(user_query)
-      user_query = user_query.to_s
+      user_query = user_query.to_s.downcase
       resolve_fact(user_query)
 
       @already_searched[user_query]&.value
@@ -407,7 +426,7 @@ module Facter
     #
     # @api public
     def fact(user_query)
-      user_query = user_query.to_s
+      user_query = user_query.to_s.downcase
       resolve_fact(user_query)
 
       @already_searched[user_query]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: facter
 version: !ruby/object:Gem::Version
-  version: 4.2.3
+  version: 4.2.7
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-16 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -846,6 +846,7 @@ files:
 - lib/facter/facts/windows/os/hardware.rb
 - lib/facter/facts/windows/os/name.rb
 - lib/facter/facts/windows/os/release.rb
+- lib/facter/facts/windows/os/windows/display_version.rb
 - lib/facter/facts/windows/os/windows/edition_id.rb
 - lib/facter/facts/windows/os/windows/installation_type.rb
 - lib/facter/facts/windows/os/windows/product_name.rb
@@ -933,7 +934,7 @@ files:
 - lib/facter/resolvers/bsd/processors.rb
 - lib/facter/resolvers/containers.rb
 - lib/facter/resolvers/debian_version.rb
-- lib/facter/resolvers/disk.rb
+- lib/facter/resolvers/disks.rb
 - lib/facter/resolvers/dmi.rb
 - lib/facter/resolvers/dmi_decode.rb
 - lib/facter/resolvers/ec2.rb
@@ -964,7 +965,7 @@ files:
 - lib/facter/resolvers/macosx/filesystems.rb
 - lib/facter/resolvers/macosx/load_averages.rb
 - lib/facter/resolvers/macosx/mountpoints.rb
-- lib/facter/resolvers/macosx/processor.rb
+- lib/facter/resolvers/macosx/processors.rb
 - lib/facter/resolvers/macosx/swap_memory.rb
 - lib/facter/resolvers/macosx/system_memory.rb
 - lib/facter/resolvers/macosx/system_profiler.rb
@@ -1021,6 +1022,7 @@ files:
 - lib/facter/resolvers/windows/ffi/performance_information.rb
 - lib/facter/resolvers/windows/ffi/system32_ffi.rb
 - lib/facter/resolvers/windows/ffi/system_info.rb
+- lib/facter/resolvers/windows/ffi/winnls_ffi.rb
 - lib/facter/resolvers/windows/fips.rb
 - lib/facter/resolvers/windows/hardware_architecture.rb
 - lib/facter/resolvers/windows/identity.rb
@@ -1032,6 +1034,7 @@ files:
 - lib/facter/resolvers/windows/product_release.rb
 - lib/facter/resolvers/windows/ssh.rb
 - lib/facter/resolvers/windows/system32.rb
+- lib/facter/resolvers/windows/timezone.rb
 - lib/facter/resolvers/windows/uptime.rb
 - lib/facter/resolvers/windows/virtualization.rb
 - lib/facter/resolvers/windows/win_os_description.rb

data/lib/facter/resolvers/disk.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    module Linux
-      class Disk < BaseResolver
-        @log = Facter::Log.new(self)
-
-        init_resolver
-
-        DIR = '/sys/block'
-        FILE_PATHS = { model: 'device/model', size: 'size', vendor: 'device/vendor', type: 'queue/rotational' }.freeze
-
-        class << self
-          private
-
-          def post_resolve(fact_name, _options)
-            @fact_list.fetch(fact_name) { read_facts(fact_name) }
-          end
-
-          def read_facts(fact_name)
-            build_disks_hash
-
-            FILE_PATHS.each do |key, file|
-              @fact_list[:disks].each do |disk, value|
-                file_path = File.join(DIR, disk, file)
-
-                result = Facter::Util::FileHelper.safe_read(file_path).strip
-                next if result.empty?
-
-                value[key] = case key
-                             when :size
-                               # Linux always considers sectors to be 512 bytes long
-                               # independently of the devices real block size.
-                               construct_size(value, result)
-                             when :type
-                               result == '0' ? 'ssd' : 'hdd'
-                             else
-                               result
-                             end
-              end
-            end
-
-            @fact_list[:disks] = nil if @fact_list[:disks].empty?
-            @fact_list[fact_name]
-          end
-
-          def build_disks_hash
-            @fact_list[:disks] = {}
-            directories = Dir.entries(DIR).reject { |dir| dir =~ /\.+/ }
-            directories.each { |disk| @fact_list[:disks].merge!(disk => {}) }
-            @fact_list[:disks].select! { |disk, _fact| File.readable?(File.join(DIR, disk, 'device')) }
-          end
-
-          def construct_size(facts, value)
-            value = value.to_i * 512
-            facts[:size_bytes] = value
-            facts[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(value)
-          end
-        end
-      end
-    end
-  end
-end