facter 4.0.33 → 4.0.38

data/lib/facter/facts/freebsd/system_uptime/seconds.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    module SystemUptime
+      class Seconds
+        FACT_NAME = 'system_uptime.seconds'
+        ALIASES = 'uptime_seconds'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Uptime.resolve(:seconds)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/freebsd/system_uptime/uptime.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    module SystemUptime
+      class Uptime
+        FACT_NAME = 'system_uptime.uptime'
+        ALIASES = 'uptime'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Uptime.resolve(:uptime)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/freebsd/timezone.rb

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

data/lib/facter/facts/freebsd/zfs_featurenumbers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class ZfsFeaturenumbers
+      FACT_NAME = 'zfs_featurenumbers'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::ZFS.resolve(:zfs_featurenumbers)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/freebsd/zfs_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class ZfsVersion
+      FACT_NAME = 'zfs_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::ZFS.resolve(:zfs_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/freebsd/zpool_featureflags.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class ZpoolFeatureflags
+      FACT_NAME = 'zpool_featureflags'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_featureflags)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/freebsd/zpool_featurenumbers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class ZpoolFeaturenumbers
+      FACT_NAME = 'zpool_featurenumbers'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_featurenumbers)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/freebsd/zpool_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class ZpoolVersion
+      FACT_NAME = 'zpool_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

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

@@ -4,11 +4,30 @@ module Facts
   module Linux
     class Disks
       FACT_NAME = 'disks'
+      ALIASES = %w[blockdevices blockdevice_.*_model blockdevice_.*_size blockdevice_.*_vendor'].freeze
 
       def call_the_resolver
+        facts = []
         disks = Facter::Resolvers::Linux::Disk.resolve(:disks)
 
-        Facter::ResolvedFact.new(FACT_NAME, disks)
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if disks.nil? || disks.empty?
+
+        blockdevices = disks.keys.join(',')
+        facts.push(Facter::ResolvedFact.new(FACT_NAME, disks))
+        facts.push(Facter::ResolvedFact.new('blockdevices', blockdevices, :legacy))
+        add_legacy_facts(disks, facts)
+
+        facts
+      end
+
+      private
+
+      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}_vendor", disk_info[:vendor], :legacy))
+        end
       end
     end
   end

data/lib/facter/facts/linux/dmi/board/asset_tag.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Dmi
+      module Board
+        class AssetTag
+          FACT_NAME = 'dmi.board.asset_tag'
+          ALIASES = 'boardassettag'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Linux::DmiBios.resolve(:board_asset_tag)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,14 +6,16 @@ module Facts
       FACT_NAME = 'ec2_metadata'
 
       def call_the_resolver
-        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
         fact_value = Facter::Resolvers::Ec2.resolve(:metadata)
 
-        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
       end
 
-      def aws?
+      private
+
+      def aws_hypervisors?
         virtual = check_virt_what || check_xen || check_product_name || check_bios_vendor || check_lspci
 
         virtual == 'kvm' || virtual =~ /xen/

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

@@ -6,14 +6,16 @@ module Facts
       FACT_NAME = 'ec2_userdata'
 
       def call_the_resolver
-        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
         fact_value = Facter::Resolvers::Ec2.resolve(:userdata)
 
-        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
       end
 
-      def aws?
+      private
+
+      def aws_hypervisors?
         virtual = check_virt_what || check_xen || check_product_name || check_bios_vendor || check_lspci
 
         virtual == 'kvm' || virtual =~ /xen/

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class Gce
+      FACT_NAME = 'gce'
+
+      def call_the_resolver
+        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+
+        fact_value = bios_vendor&.include?('Google') ? Facter::Resolvers::Gce.resolve(:metadata) : nil
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

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

@@ -5,8 +5,6 @@ module Facts
     class IsVirtual
       FACT_NAME = 'is_virtual'
 
-      PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
-
       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'
@@ -59,7 +57,7 @@ module Facts
       end
 
       def check_if_virtual(found_vm)
-        PHYSICAL_HYPERVISORS.count(found_vm).zero?
+        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'mountpoints'
 
       def call_the_resolver
-        mountpoints = Facter::Resolvers::Linux::Mountpoints.resolve(FACT_NAME.to_sym)
+        mountpoints = Facter::Resolvers::Mountpoints.resolve(FACT_NAME.to_sym)
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless mountpoints
 
         fact = {}

data/lib/facter/facts/linux/networking/scope6.rb

@@ -5,11 +5,13 @@ module Facts
     module Networking
       class Scope6
         FACT_NAME = 'networking.scope6'
+        ALIASES = 'scope6'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::NetworkingLinux.resolve(:scope6)
 
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+           Facter::ResolvedFact.new('scope6', fact_value, :legacy)]
         end
       end
     end

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

@@ -11,10 +11,10 @@ module Facts
 
       def partitions
         parts = Facter::Resolvers::Partitions.resolve(:partitions)
-        mountpoints = Facter::Resolvers::Linux::Mountpoints.resolve(:mountpoints)
+        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/processors/speed.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Processors
+      class Speed
+        FACT_NAME = 'processors.speed'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Linux::Processors.resolve(:speed)
+          speed = Facter::FactsUtils::UnitConverter.hertz_to_human_readable(fact_value)
+          Facter::ResolvedFact.new(FACT_NAME, speed)
+        end
+      end
+    end
+  end
+end

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

@@ -9,14 +9,13 @@ module Facts
       def call_the_resolver
         resolved_facts = []
         interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces)
-        primary_scope6 = Facter::Resolvers::NetworkingLinux.resolve(:scope6)
 
         interfaces&.each do |interface_name, info|
           if info[:scope6]
             resolved_facts << Facter::ResolvedFact.new("scope6_#{interface_name}", info[:scope6], :legacy)
           end
         end
-        resolved_facts << Facter::ResolvedFact.new('scope6', primary_scope6, :legacy) if primary_scope6
+
         resolved_facts
       end
     end

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

@@ -6,20 +6,30 @@ module Facts
       FACT_NAME = 'ssh'
 
       def call_the_resolver
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
-        ssh_facts = {}
-        result.each { |ssh| ssh_facts.merge!(create_ssh_fact(ssh)) }
-        Facter::ResolvedFact.new(FACT_NAME, ssh_facts)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       private
 
+      def fact_value
+        resolver_data.map { |el| create_ssh_fact(el) }.inject(:merge)
+      end
+
+      def resolver_data
+        Facter::Resolvers::SshResolver.resolve(:ssh)
+      end
+
       def create_ssh_fact(ssh)
-        { ssh.name.to_sym =>
-              { fingerprints: { sha1: ssh.fingerprint.sha1,
-                                sha256: ssh.fingerprint.sha256 },
-                key: ssh.key,
-                type: ssh.type } }
+        return {} unless ssh
+
+        { ssh.name.to_sym => {
+          fingerprints: {
+            sha1: ssh.fingerprint.sha1,
+            sha256: ssh.fingerprint.sha256
+          },
+          key: ssh.key,
+          type: ssh.type
+        } }
       end
     end
   end

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

@@ -11,7 +11,7 @@ module Facts
         result = Facter::Resolvers::SshResolver.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
-                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end

data/lib/facter/facts/linux/system_uptime/days.rb

@@ -8,7 +8,13 @@ module Facts
         ALIASES = 'uptime_days'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::Uptime.resolve(:days)
+          hypervisors = Facter::Resolvers::Containers.resolve(:hypervisor)
+
+          fact_value = if hypervisors && hypervisors[:docker]
+                         Facter::Resolvers::Linux::DockerUptime.resolve(:days)
+                       else
+                         Facter::Resolvers::Uptime.resolve(:days)
+                       end
 
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end

data/lib/facter/facts/linux/system_uptime/hours.rb

@@ -8,7 +8,13 @@ module Facts
         ALIASES = 'uptime_hours'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::Uptime.resolve(:hours)
+          hypervisors = Facter::Resolvers::Containers.resolve(:hypervisor)
+
+          fact_value = if hypervisors && hypervisors[:docker]
+                         Facter::Resolvers::Linux::DockerUptime.resolve(:hours)
+                       else
+                         Facter::Resolvers::Uptime.resolve(:hours)
+                       end
 
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end

data/lib/facter/facts/linux/system_uptime/seconds.rb

@@ -8,7 +8,13 @@ module Facts
         ALIASES = 'uptime_seconds'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::Uptime.resolve(:seconds)
+          hypervisors = Facter::Resolvers::Containers.resolve(:hypervisor)
+
+          fact_value = if hypervisors && hypervisors[:docker]
+                         Facter::Resolvers::Linux::DockerUptime.resolve(:seconds)
+                       else
+                         Facter::Resolvers::Uptime.resolve(:seconds)
+                       end
 
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end

data/lib/facter/facts/linux/system_uptime/uptime.rb

@@ -8,7 +8,13 @@ module Facts
         ALIASES = 'uptime'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::Uptime.resolve(:uptime)
+          hypervisors = Facter::Resolvers::Containers.resolve(:hypervisor)
+
+          fact_value = if hypervisors && hypervisors[:docker]
+                         Facter::Resolvers::Linux::DockerUptime.resolve(:uptime)
+                       else
+                         Facter::Resolvers::Uptime.resolve(:uptime)
+                       end
 
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end