facter 4.2.5 → 4.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fa80567c0c01b5ceed0181b78f9e9e813d4eea3c70905733ba1aa5e9298ad15
-  data.tar.gz: 1541ade4a87eacbbaa569c0ace340312dfde0c8299b12cd1973d8861449a798f
+  metadata.gz: a0c594d7e1c0b1242696bfff37bb65cfa378f08a80b79d68cc03ec277a3622c9
+  data.tar.gz: ba4ed34667a934a131241583e0c520460e6e94b6ff31e78c0d02851c9064e752
 SHA512:
-  metadata.gz: ea3608714cc012b4f64de7f4b472c904152e82387b980d7b3740a318b3b500228dc2e57a41bab27c113d7d6cb9ce8985394d69db2c6ef49d0fd1483b0608b220
-  data.tar.gz: 33f8a676b5a70c964f90f2576e4b1a65d5e2b27c9b2b09edd12145f77da20f303ab295ee3de1998aed74eff967e4765ac0ad48a885a9ffbe175bbda2f6ce3b20
+  metadata.gz: 066123daac0a1b601f3c480bfef30aee5d481b1f810b0d99f4c5542493a1aba83f8a600d462b935347aa65f967417dc4522669ffdba54e36cf1ebaf6879cdaa1
+  data.tar.gz: 48133fe43104a4e0bb1fd47d230ecd6debed1bf8b0eeae1096aab5e0324272e8162efde1fc6804a0c1afd5840b08d863c5ee9c953f731f564f7f69976ec976e8

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)
@@ -117,9 +118,10 @@ module Facter
           timeout = (options[:timeout] || options[:time_limit] || options[:limit]).to_i
           timeout = timeout.positive? ? timeout : nil
 
-          extra_keys = options.keys - %i[on_fail expand logger timeout]
+          extra_keys = options.keys - VALID_OPTIONS
           unless extra_keys.empty?
-            @log.warn("Unexpected key passed to Facter::Core::Execution.execute option: #{options.keys.join(',')}")
+            @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]

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/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/windows/os/windows/display_version.rb

@@ -6,11 +6,12 @@ module Facts
       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(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           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/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/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/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 =~ /\s+node\s+|---|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/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/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/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/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/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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: facter
 version: !ruby/object:Gem::Version
-  version: 4.2.5
+  version: 4.2.6
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-29 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -934,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
@@ -1022,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
@@ -1033,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