facter 4.0.43 → 4.0.49

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/os_hierarchy.json

@@ -1,36 +0,0 @@
-[
-  {
-    "Linux": [
-      {
-        "Debian": [
-          "Elementary",
-          "Ubuntu",
-          "Raspbian"
-        ]
-      },
-      {
-        "Rhel": [
-          "Fedora",
-          "Amzn",
-          "Centos",
-          "Ol",
-          "Scientific"
-        ]
-      },
-      {
-        "Sles": [
-          "Opensuse"
-        ]
-      }
-    ]
-  },
-  {
-    "Bsd": [
-      "Freebsd"
-    ]
-  },
-  "Solaris",
-  "Macosx",
-  "Windows",
-  "Aix"
-]

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/hostname_resolver.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class Hostname < BaseResolver
-      @fact_list ||= {}
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { retrieve_hostname(fact_name) }
-        end
-
-        def retrieve_hostname(fact_name)
-          output = Facter::Core::Execution.execute('hostname', logger: log)
-
-          # get domain
-          domain = read_domain(output)
-
-          # get hostname
-          hostname = output =~ /(.*?)\./ ? Regexp.last_match(1) : output
-          @fact_list[:hostname] ||= hostname&.strip
-          @fact_list[:domain] ||= domain&.strip
-          @fact_list[:fqdn] ||= "#{@fact_list[:hostname]}.#{@fact_list[:domain]}"
-          @fact_list[fact_name]
-        end
-
-        def read_domain(output)
-          if output =~ /.*?\.(.+$)/
-            domain = Regexp.last_match(1)
-          else
-            file_content = Util::FileHelper.safe_read('/etc/resolv.conf')
-            if file_content =~ /^search\s+(\S+)/
-              domain = Regexp.last_match(1)
-            elsif file_content =~ /^domain\s+(\S+)/
-              domain = Regexp.last_match(1)
-            end
-          end
-          domain
-        end
-      end
-    end
-  end
-end

data/lib/facter/resolvers/mountpoints_resolver.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class Mountpoints < BaseResolver
-      include Facter::FilesystemHelper
-      @fact_list ||= {}
-      @log = Facter::Log.new(self)
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { read_mounts(fact_name) }
-        end
-
-        def root_device
-          cmdline = Util::FileHelper.safe_read('/proc/cmdline')
-          match = cmdline.match(/root=([^\s]+)/)
-          match&.captures&.first
-        end
-
-        def compute_device(device)
-          # If the "root" device, lookup the actual device from the kernel options
-          # This is done because not all systems symlink /dev/root
-          device = root_device if device == '/dev/root'
-          device
-        end
-
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        def read_mounts(fact_name)
-          mounts = []
-          FilesystemHelper.read_mountpoints.each do |fs|
-            device = compute_device(fs.name)
-            filesystem = fs.mount_type
-            path = fs.mount_point
-            options = fs.options.split(',').map(&:strip)
-
-            next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
-
-            stats = FilesystemHelper.read_mountpoint_stats(path)
-            size_bytes = stats.bytes_total.abs
-            available_bytes = stats.bytes_available.abs
-
-            used_bytes = stats.bytes_used.abs
-            total_bytes = used_bytes + available_bytes
-            capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
-
-            size = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
-            available = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes)
-            used = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes)
-
-            mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
-              .map { |v| binding.local_variable_get(v) })]
-          end
-          @fact_list[:mountpoints] = mounts
-          @fact_list[fact_name]
-        end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-      end
-    end
-  end
-end