facter 4.0.36 → 4.0.41

data/lib/facter/facts/aix/kernelrelease.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'kernelrelease'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::OsLevel.resolve(:build).strip
+        fact_value = Facter::Resolvers::Aix::OsLevel.resolve(:build).strip
 
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end

data/lib/facter/facts/aix/kernelversion.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'kernelversion'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::OsLevel.resolve(:build)
+        fact_value = Facter::Resolvers::Aix::OsLevel.resolve(:build)
         kernelversion = fact_value.split('-')[0]
 
         Facter::ResolvedFact.new(FACT_NAME, kernelversion)

data/lib/facter/facts/aix/os/release.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::OsLevel.resolve(:build)
+          fact_value = Facter::Resolvers::Aix::OsLevel.resolve(:build)
           major = fact_value.split('-')[0]
 
           [Facter::ResolvedFact.new(FACT_NAME, full: fact_value.strip, major: major),

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class Cloud
+      FACT_NAME = 'cloud'
+
+      def call_the_resolver
+        cloud_provider = Facter::Resolvers::Cloud.resolve(:cloud_provider)
+
+        Facter::ResolvedFact.new(FACT_NAME, cloud_provider)
+      end
+    end
+  end
+end

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

@@ -25,7 +25,7 @@ module Facts
       def add_legacy_facts(disks, facts)
         disks.each do |disk_name, disk_info|
           facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_model", disk_info[:model], :legacy))
-          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes], :legacy))
           facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_vendor", disk_info[:vendor], :legacy))
         end
       end

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

@@ -5,6 +5,10 @@ module Facts
     class Ec2Metadata
       FACT_NAME = 'ec2_metadata'
 
+      def initialize
+        @virtual = Facter::VirtualDetector.new
+      end
+
       def call_the_resolver
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
@@ -16,33 +20,7 @@ module Facts
       private
 
       def aws_hypervisors?
-        virtual = check_virt_what || check_xen || check_product_name || check_bios_vendor || check_lspci
-
-        virtual == 'kvm' || virtual =~ /xen/
-      end
-
-      def check_virt_what
-        Facter::Resolvers::VirtWhat.resolve(:vm)
-      end
-
-      def check_xen
-        Facter::Resolvers::Xen.resolve(:vm)
-      end
-
-      def check_product_name
-        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
-        return unless product_name
-
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
-      end
-
-      def check_bios_vendor
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        return 'kvm' if bios_vendor&.include?('Amazon EC2')
-      end
-
-      def check_lspci
-        Facter::Resolvers::Lspci.resolve(:vm)
+        @virtual.platform =~ /kvm|xen|aws/
       end
     end
   end

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

@@ -5,6 +5,10 @@ module Facts
     class Ec2Userdata
       FACT_NAME = 'ec2_userdata'
 
+      def initialize
+        @virtual = Facter::VirtualDetector.new
+      end
+
       def call_the_resolver
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
@@ -16,33 +20,7 @@ module Facts
       private
 
       def aws_hypervisors?
-        virtual = check_virt_what || check_xen || check_product_name || check_bios_vendor || check_lspci
-
-        virtual == 'kvm' || virtual =~ /xen/
-      end
-
-      def check_virt_what
-        Facter::Resolvers::VirtWhat.resolve(:vm)
-      end
-
-      def check_xen
-        Facter::Resolvers::Xen.resolve(:vm)
-      end
-
-      def check_product_name
-        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
-        return unless product_name
-
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
-      end
-
-      def check_bios_vendor
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        return 'kvm' if bios_vendor&.include?('Amazon EC2')
-      end
-
-      def check_lspci
-        Facter::Resolvers::Lspci.resolve(:vm)
+        @virtual.platform =~ /kvm|xen|aws/
       end
     end
   end

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

@@ -5,59 +5,20 @@ module Facts
     class IsVirtual
       FACT_NAME = 'is_virtual'
 
-      def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        fact_value = check_docker_lxc || check_gce || retrieve_from_virt_what || check_vmware
-        fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
-
-        Facter::ResolvedFact.new(FACT_NAME, check_if_virtual(fact_value))
-      end
-
-      def check_gce
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        'gce' if bios_vendor&.include?('Google')
-      end
-
-      def check_docker_lxc
-        Facter::Resolvers::Containers.resolve(:vm)
+      def initialize
+        @virtual = Facter::VirtualDetector.new
       end
 
-      def check_vmware
-        Facter::Resolvers::Vmware.resolve(:vm)
-      end
+      def call_the_resolver
+        fact_value = @virtual.platform
 
-      def retrieve_from_virt_what
-        Facter::Resolvers::VirtWhat.resolve(:vm)
-      end
-
-      def check_open_vz
-        Facter::Resolvers::OpenVz.resolve(:vm)
-      end
-
-      def check_vserver
-        Facter::Resolvers::VirtWhat.resolve(:vserver)
-      end
-
-      def check_xen
-        Facter::Resolvers::Xen.resolve(:vm)
-      end
-
-      def check_other_facts
-        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
+        Facter::ResolvedFact.new(FACT_NAME, check_if_virtual(fact_value))
       end
 
-      def check_lspci
-        Facter::Resolvers::Lspci.resolve(:vm)
-      end
+      private
 
       def check_if_virtual(found_vm)
-        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?
+        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?.to_s
       end
     end
   end

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

@@ -14,7 +14,7 @@ module Facts
         mountpoints = Facter::Resolvers::Mountpoints.resolve(:mountpoints)
         return parts unless mountpoints
 
-        mountpoints.each do |mnt|
+        mountpoints.reverse_each do |mnt|
           next unless parts[mnt[:device]]
 
           parts[mnt[:device]].merge!(mount: mnt[:path])

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

@@ -7,71 +7,16 @@ module Facts
 
       def initialize
         @log = Facter::Log.new(self)
+        @virtual = Facter::VirtualDetector.new
       end
 
-      def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def call_the_resolver
         @log.debug('Linux Virtual Resolver')
-
-        fact_value = check_docker_lxc || 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 = @virtual.platform
         @log.debug("Fact value is: #{fact_value}")
 
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       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_docker_lxc
-        @log.debug('Checking Docker and LXC')
-        Facter::Resolvers::Containers.resolve(:vm)
-      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
 end

data/lib/facter/facts/rhel/os/release.rb

@@ -18,8 +18,8 @@ module Facts
         end
 
         def determine_release_version
-          version = Facter::Resolvers::OsRelease.resolve(:version_id)
-          version ||= Facter::Resolvers::RedHatRelease.resolve(:version)
+          version = Facter::Resolvers::RedHatRelease.resolve(:version)
+          version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
 
           return unless version
 

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

@@ -24,7 +24,7 @@ module Facts
 
       def add_legacy_facts(disks, facts)
         disks.each do |disk_name, disk_info|
-          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes], :legacy))
           facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_vendor", disk_info[:vendor], :legacy))
         end
       end

data/lib/facter/facts/ubuntu/lsbdistrelease.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Facts
+  module Ubuntu
+    class Lsbdistrelease
+      FACT_NAME = 'lsbdistrelease'
+      ALIASES = %w[lsbmajdistrelease lsbminordistrelease].freeze
+      TYPE = :legacy
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::LsbRelease.resolve(:release)
+
+        return Facter::ResolvedFact.new(FACT_NAME, nil, :legacy) unless fact_value
+
+        version = fact_value.split('.')
+
+        [Facter::ResolvedFact.new(FACT_NAME, fact_value, :legacy),
+         Facter::ResolvedFact.new(ALIASES[0], version[0], :legacy),
+         Facter::ResolvedFact.new(ALIASES[1], version[1], :legacy)]
+      end
+    end
+  end
+end

data/lib/facter/facts_utils/virtual_detector.rb

@@ -0,0 +1,78 @@
+# 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 'aws' 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/framework/benchmarking/timer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+module Facter
+  module Framework
+    module Benchmarking
+      class Timer
+        class << self
+          def measure(fact_name)
+            if Options[:timing]
+              time = Benchmark.measure { yield }
+
+              puts "fact `#{fact_name}`, took: #{time.format('%r')} seconds"
+            else
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end