facter 4.0.42 → 4.0.48

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      HYPERVISORS_HASH = { 'VMware' => 'vmware', 'VirtualBox' => 'virtualbox', 'Parallels' => 'parallels',
+                           'KVM' => 'kvm', 'Virtual Machine' => 'hyperv', 'RHEV Hypervisor' => 'rhev',
+                           'oVirt Node' => 'ovirt', 'HVM domU' => 'xenhvm', 'Bochs' => 'bochs', 'OpenBSD' => 'vmm',
+                           'BHYVE' => 'bhyve' }.freeze
+
+      PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
+      REDHAT_FAMILY = %w[redhat rhel fedora centos scientific ascendos cloudlinux psbm
+                         oraclelinux ovs oel amazon xenserver xcp-ng virtuozzo photon].freeze
+      DEBIAN_FAMILY = %w[debian ubuntu huaweios linuxmint devuan kde].freeze
+      SUSE_FAMILY = %w[sles sled suse].freeze
+      GENTOO_FAMILY = ['gentoo'].freeze
+      ARCH_FAMILY = %w[arch manjaro].freeze
+      MANDRAKE_FAMILY = %w[mandrake mandriva mageia].freeze
+      FAMILY_HASH = { 'RedHat' => REDHAT_FAMILY, 'Debian' => DEBIAN_FAMILY, 'Suse' => SUSE_FAMILY,
+                      'Gentoo' => GENTOO_FAMILY, 'Archlinux' => ARCH_FAMILY, 'Mandrake' => MANDRAKE_FAMILY }.freeze
+
+      class << self
+        def discover_family(os)
+          FAMILY_HASH.each { |key, array_value| return key if array_value.any? { |os_flavour| os =~ /#{os_flavour}/i } }
+          os
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class UnitConverter
+        class << self
+          def bytes_to_mb(value_in_bytes)
+            return unless value_in_bytes
+
+            value_in_bytes = value_in_bytes.to_i
+
+            (value_in_bytes / (1024.0 * 1024.0)).round(2)
+          end
+
+          def hertz_to_human_readable(speed)
+            speed = speed.to_i
+            return if !speed || speed.zero?
+
+            prefix = { 3 => 'k', 6 => 'M', 9 => 'G', 12 => 'T' }
+            power = Math.log10(speed).floor
+            validated_speed = power.zero? ? speed.to_f : speed.fdiv(10**power)
+            format('%<displayed_speed>.2f', displayed_speed: validated_speed).to_s + ' ' + prefix[power] + 'Hz'
+          end
+
+          def bytes_to_human_readable(bytes)
+            return unless bytes
+            return bytes.to_s + ' bytes' if bytes < 1024
+
+            number, multiple = determine_exponent(bytes)
+
+            "#{pad_number(number)} #{multiple}"
+          end
+
+          private
+
+          def pad_number(number)
+            number = number.to_s
+            number << '0' if number.split('.').last.length == 1
+            number
+          end
+
+          def determine_exponent(bytes)
+            prefix = %w[KiB MiB GiB TiB PiB EiB]
+            exp = (Math.log2(bytes) / 10.0).floor
+            converted_number = (100.0 * (bytes / 1024.0**exp)).round / 100.0
+
+            if (converted_number - 1024.0).abs < Float::EPSILON
+              exp += 1
+              converted_number = 1.00
+            end
+            multiple = prefix[exp - 1] || 'bytes'
+
+            converted_number = bytes if multiple == 'bytes'
+            [converted_number, multiple]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Facter
+  module Util
+    module Facts
+      class UptimeParser
+        SECS_IN_A_DAY = 86_400
+        SECS_IN_AN_HOUR = 3_600
+        SECS_IN_A_MINUTE = 60
+
+        @log = Facter::Log.new(self)
+
+        class << self
+          def uptime_seconds_unix
+            uptime_proc_uptime || uptime_sysctl || uptime_executable
+          end
+
+          private
+
+          def uptime_proc_uptime
+            output = Facter::Core::Execution.execute("/bin/cat #{uptime_file}", logger: @log)
+
+            output.chomp.split(' ').first.to_i unless output.empty?
+          end
+
+          def uptime_sysctl
+            output = Facter::Core::Execution.execute("sysctl -n #{uptime_sysctl_variable}", logger: @log)
+
+            compute_uptime(Time.at(output.match(/\d+/)[0].to_i)) unless output.empty?
+          end
+
+          def uptime_executable
+            output = Facter::Core::Execution.execute(uptime_executable_cmd, logger: @log)
+
+            return unless output
+
+            up = 0
+            output_calculator_methods.find { |method| up = send(method, output) }
+            up || 0
+          end
+
+          def uptime_file
+            '/proc/uptime'
+          end
+
+          def uptime_sysctl_variable
+            'kern.boottime'
+          end
+
+          def uptime_executable_cmd
+            'uptime'
+          end
+
+          def output_calculator_methods
+            %i[
+              calculate_days_hours_minutes
+              calculate_days_hours
+              calculate_days_minutes
+              calculate_days
+              calculate_hours_minutes
+              calculate_hours
+              calculate_minutes
+            ]
+          end
+
+          def compute_uptime(time)
+            (Time.now - time).to_i
+          end
+
+          # Regexp handles Solaris, AIX, HP-UX, and Tru64.
+          # 'day(?:s|\(s\))?' says maybe 'day', 'days',
+          #   or 'day(s)', and don't set $2.
+          def calculate_days_hours_minutes(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,?\s+(\d+):-?(\d+)/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_AN_HOUR * Regexp.last_match(2).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(3).to_i
+          end
+
+          def calculate_days_hours(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) hr(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_AN_HOUR * Regexp.last_match(2).to_i
+          end
+
+          def calculate_days_minutes(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) min(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+          end
+
+          def calculate_days(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i
+          end
+
+          # must anchor to 'up' to avoid matching time of day
+          # at beginning of line. Certain versions of uptime on
+          # Solaris may insert a '-' into the minutes field.
+          def calculate_hours_minutes(output)
+            return unless output =~ /up\s+(\d+):-?(\d+),/
+
+            SECS_IN_AN_HOUR * Regexp.last_match(1).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+          end
+
+          def calculate_hours(output)
+            return unless output =~ /(\d+) hr(?:s|\(s\))?,/
+
+            SECS_IN_AN_HOUR * Regexp.last_match(1).to_i
+          end
+
+          def calculate_minutes(output)
+            return unless output =~ /(\d+) min(?:s|\(s\))?,/
+
+            SECS_IN_A_MINUTE * Regexp.last_match(1).to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class VirtualDetector
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def platform
+          fact_value = check_docker_lxc || check_dmi || check_freebsd || check_gce || retrieve_from_virt_what
+          fact_value ||= check_vmware || check_open_vz || check_vserver || check_xen || check_other_facts
+          fact_value ||= check_lspci || 'physical'
+
+          fact_value
+        end
+
+        def check_docker_lxc
+          @log.debug('Checking Docker and LXC')
+          Facter::Resolvers::Containers.resolve(:vm)
+        end
+
+        def check_dmi
+          @log.debug('Checking DMI')
+          vendor = Facter::Resolvers::DmiDecode.resolve(:vendor)
+          @log.debug("dmi detected vendor: #{vendor}")
+          return 'kvm' if vendor =~ /Amazon/
+
+          'xen' if vendor =~ /Xen/
+        end
+
+        def check_gce
+          @log.debug('Checking GCE')
+          bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+          'gce' if bios_vendor&.include?('Google')
+        end
+
+        def check_vmware
+          @log.debug('Checking VMware')
+          Facter::Resolvers::Vmware.resolve(:vm)
+        end
+
+        def retrieve_from_virt_what
+          @log.debug('Checking virtual_what')
+          Facter::Resolvers::VirtWhat.resolve(:vm)
+        end
+
+        def check_open_vz
+          @log.debug('Checking OpenVZ')
+          Facter::Resolvers::OpenVz.resolve(:vm)
+        end
+
+        def check_vserver
+          @log.debug('Checking VServer')
+          Facter::Resolvers::VirtWhat.resolve(:vserver)
+        end
+
+        def check_xen
+          @log.debug('Checking XEN')
+          Facter::Resolvers::Xen.resolve(:vm)
+        end
+
+        def check_freebsd
+          return unless Object.const_defined?('Facter::Resolvers::Freebsd::Virtual')
+
+          @log.debug('Checking if jailed')
+          Facter::Resolvers::Freebsd::Virtual.resolve(:vm)
+        end
+
+        def check_other_facts
+          @log.debug('Checking others')
+          product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+          bios_vendor =  Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+          return 'kvm' if bios_vendor&.include?('Amazon EC2')
+          return unless product_name
+
+          Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+          nil
+        end
+
+        def check_lspci
+          @log.debug('Checking lspci')
+          Facter::Resolvers::Lspci.resolve(:vm)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class WindowsReleaseFinder
+        class << self
+          def find_release(input)
+            version = input[:version]
+            return unless version
+
+            consumerrel = input[:consumerrel]
+            description = input[:description]
+            kernel_version = input[:kernel_version]
+
+            if version =~ /10.0/
+              check_version_10(consumerrel, kernel_version)
+            else
+              check_version_6(version, consumerrel) || check_version_5(version, consumerrel, description) || version
+            end
+          end
+
+          private
+
+          def check_version_10(consumerrel, kernel_version)
+            build_number = kernel_version[/([^.]*)$/].to_i
+            if consumerrel
+              '10'
+            elsif build_number >= 17_623
+              '2019'
+            else
+              '2016'
+            end
+          end
+
+          def check_version_6(version, consumerrel)
+            hash = {}
+            hash['6.3'] = consumerrel ? '8.1' : '2012 R2'
+            hash['6.2'] = consumerrel ? '8' : '2012'
+            hash['6.1'] = consumerrel ? '7' : '2008 R2'
+            hash['6.0'] = consumerrel ? 'Vista' : '2008'
+            hash[version]
+          end
+
+          def check_version_5(version, consumerrel, description)
+            return unless version =~ /5.2/
+            return 'XP' if consumerrel
+
+            description == 'R2' ? '2003 R2' : '2003'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/{resolvers/macosx/utils → util/macosx}/system_profile_executor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Facter
-  module Resolvers
+  module Util
     module Macosx
       class SystemProfileExecutor
         @log = Log.new(self)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module AwsToken
+        attr_reader :token
+
+        @log = Facter::Log.new(self)
+
+        class << self
+          AWS_API_TOKEN_URL = 'http://169.254.169.254/latest/api/token'
+
+          def get(lifetime = 100)
+            @expiry ||= Time.now
+
+            return @token if @token && @expiry > Time.now
+
+            @token = nil
+            @expiry = Time.now + lifetime
+
+            headers = {
+              'X-aws-ec2-metadata-token-ttl-seconds' => lifetime.to_s
+            }
+
+            @token = Facter::Util::Resolvers::Http.put_request(AWS_API_TOKEN_URL, headers)
+          end
+
+          def reset
+            @expiry = nil
+            @token = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/{resolvers/utils → util/resolvers}/ffi/load_averages.rb

@@ -3,8 +3,8 @@
 require 'ffi'
 
 module Facter
-  module Resolvers
-    module Utils
+  module Util
+    module Resolvers
       module Ffi
         module LoadAverages
           extend ::FFI::Library

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module FilesystemHelper
+        MOUNT_KEYS = %i[device filesystem path options
+                        available available_bytes size
+                        size_bytes used used_bytes capacity].freeze
+        class << self
+          def read_mountpoints
+            # TODO: this require must be replaced with "require 'sys/filesystem'" when a new release of
+            # djberg96/sys-filesystem gem is available
+            require_relative '../../patches/sysfilesystem/sys/statvfs.rb'
+            force_utf(Sys::Filesystem.mounts)
+          end
+
+          def read_mountpoint_stats(path)
+            require 'sys/filesystem'
+            Sys::Filesystem.stat(path)
+          end
+
+          def compute_capacity(used, total)
+            if used == total
+              '100%'
+            elsif used.positive?
+              "#{format('%<value>.2f', value: (used / total.to_f * 100))}%"
+            else
+              '0%'
+            end
+          end
+
+          private
+
+          def force_utf(mounts)
+            mounts.each do |mount|
+              mount.name.force_encoding('UTF-8')
+              mount.mount_type.force_encoding('UTF-8')
+              mount.mount_point.force_encoding('UTF-8')
+              mount.options.force_encoding('UTF-8')
+            end
+          end
+        end
+      end
+    end
+  end
+end