facter 4.0.46 → 4.0.47

data/lib/facter/facts/solaris/puppet_version.rb

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

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

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

data/lib/facter/facts_utils/facts_utils.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module FactsUtils
-    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
-  end
-end

data/lib/facter/facts_utils/unit_converter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module FactsUtils
-    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

data/lib/facter/facts_utils/uptime_parser.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Facter
-  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

data/lib/facter/facts_utils/virtual_detector.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  class VirtualDetector
-    def initialize
-      @log = Facter::Log.new(self)
-    end
-
-    def platform # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      fact_value = check_docker_lxc || check_dmi || check_gce || retrieve_from_virt_what || check_vmware
-      fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || 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_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::FactsUtils::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

data/lib/facter/facts_utils/windows_release_finder.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  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

data/lib/facter/resolvers/aix/utils/info_extractor.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module InfoExtractor
-    MEGABYTES_EXPONENT = 1024**2
-    GIGABYTES_EXPONENT = 1024**3
-
-    def self.extract(content, regex)
-      content = content.each_line.map do |line|
-        next unless regex =~ line
-
-        line.split(/:\s*|\s{2,}/)
-      end
-
-      content.flatten!.reject!(&:nil?)
-
-      Hash[*content]
-    end
-  end
-end

data/lib/facter/resolvers/aix/utils/odm_query.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-# CuAt (Customized Attributes) non-default attribute values
-# CuDv (Customized Devices) the devices present on this machine
-# PdAt (Predefined Attributes) default values for all device attributes
-# PdDv (Predefined Devices) the list of all devices supported by this release of AIX
-
-module Facter
-  class ODMQuery
-    REPOS = %w[CuAt CuDv PdAt PdDv].freeze
-
-    def initialize
-      @query = ''
-      @conditions = []
-      @log = Facter::Log.new(self)
-    end
-
-    def equals(field, value)
-      @conditions << "#{field}='#{value}'"
-      self
-    end
-
-    def like(field, value)
-      @conditions << "#{field} like '#{value}'"
-      self
-    end
-
-    def execute
-      result = nil
-      REPOS.each do |repo|
-        break if result && !result.empty?
-
-        result = Facter::Core::Execution.execute("#{query} #{repo}", logger: @log)
-      end
-      result
-    end
-
-    def query
-      'odmget -q "' + @conditions.join(' AND ') + '"'
-    end
-  end
-end

data/lib/facter/resolvers/puppet_version_resolver.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class PuppetVersionResolver < BaseResolver
-      # :puppetversion
-
-      init_resolver
-
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { puppet_version(fact_name) }
-        end
-
-        def puppet_version(fact_name)
-          require 'puppet/version'
-          @fact_list[:puppetversion] = Puppet.version
-
-          @fact_list[fact_name]
-        end
-      end
-    end
-  end
-end