facter 4.0.44 → 4.0.50

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facts
+  module Openwrt
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = from_specific_file || from_os_release
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def from_specific_file
+          version = Facter::Resolvers::SpecificReleaseFile.resolve(:release,
+                                                                   { release_file: '/etc/openwrt_version',
+                                                                     regex: /^(\d+.\d+.*)/ })
+          Facter::Util::Facts.release_hash_from_matchdata(version)
+        end
+
+        def from_os_release
+          version = Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facts
+  module Ovs
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = determine_release_version
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def determine_release_version
+          version = Facter::Resolvers::ReleaseFromFirstLine.resolve(:release, release_file: '/etc/ovs-release')
+          version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facts
+  module Photon
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = from_specific_file || from_os_release
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def from_specific_file
+          version = Facter::Resolvers::SpecificReleaseFile.resolve(:release,
+                                                                   { release_file: '/etc/lsb-release',
+                                                                     regex: /DISTRIB_RELEASE="(\d+)\.(\d+)/ })
+          return if version.nil? || version[1].nil? || version[2].nil?
+
+          major = version[1].to_s
+          minor = version[2].to_s
+          version_data = major + '.' + minor
+
+          {
+            'full' => version_data,
+            'major' => major,
+            'minor' => minor
+          }
+        end
+
+        def from_os_release
+          version = Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

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

@@ -21,14 +21,7 @@ module Facts
           version = Facter::Resolvers::RedHatRelease.resolve(:version)
           version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
 
-          return unless version
-
-          versions = version.split('.')
-          fact_value = {}
-          fact_value['full'] = version
-          fact_value['major'] = versions[0]
-          fact_value['minor'] = versions[1] if versions[1]
-          fact_value
+          Facter::Util::Facts.release_hash_from_string(version)
         end
       end
     end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facts
+  module Slackware
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = from_specific_file || from_os_release
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def from_specific_file
+          version = Facter::Resolvers::SpecificReleaseFile.resolve(:release,
+                                                                   { release_file: '/etc/slackware-version',
+                                                                     regex: /Slackware ([0-9.]+)/ })
+          Facter::Util::Facts.release_hash_from_matchdata(version)
+        end
+
+        def from_os_release
+          version = Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,7 @@ module Facts
   module Solaris
     class DhcpServers
       FACT_NAME = 'dhcp_servers'
+      TYPE = :legacy
 
       def call_the_resolver
         fact_value = construct_addresses_hash

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

@@ -4,7 +4,7 @@ module Facts
   module Solaris
     class Disks
       FACT_NAME = 'disks'
-      ALIASES = %w[blockdevices blockdevice_.*_size blockdevice_.*_vendor'].freeze
+      ALIASES = %w[blockdevices blockdevice_.*_size blockdevice_.*_vendor].freeze
 
       def call_the_resolver
         facts = []

data/lib/facter/facts/solaris/hypervisors/ldom.rb

@@ -11,6 +11,9 @@ module Facts
         end
 
         def call_the_resolver
+          chassis_serial = Facter::Resolvers::Solaris::Ldom.resolve(:chassis_serial)
+          return Facter::ResolvedFact.new(FACT_NAME, nil) if !chassis_serial || chassis_serial.empty?
+
           fact_value = %i[
             chassis_serial control_domain domain_name
             domain_uuid role_control role_io role_root role_service

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

@@ -4,6 +4,7 @@ module Facts
   module Solaris
     class Interfaces
       FACT_NAME = 'interfaces'
+      TYPE = :legacy
 
       def call_the_resolver
         fact_value = Facter::Resolvers::Solaris::Networking.resolve(:interfaces)

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

@@ -51,13 +51,13 @@ module Facts
 
         return unless product_name
 
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+        Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
 
         nil
       end
 
       def check_if_virtual(found_vm)
-        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?
+        Facter::Util::Facts::PHYSICAL_HYPERVISORS.count(found_vm).zero?
       end
     end
   end

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

@@ -4,14 +4,36 @@ module Facts
   module Solaris
     class Ldom
       FACT_NAME = 'ldom'
+      ALIASES = %w[
+        ldom_domainchassis
+        ldom_domaincontrol
+        ldom_domainname
+        ldom_domainrole_control
+        ldom_domainrole_impl
+        ldom_domainrole_io
+        ldom_domainrole_root
+        ldom_domainrole_service
+        ldom_domainuuid
+      ].freeze
 
       def initialize
         @log = Facter::Log.new(self)
       end
 
       def call_the_resolver
-        fact_value = {
-          domainchassis: resolve(:chassis_serial),
+        @log.debug('Solving the ldom fact.')
+        fact_value = resolve_fact
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if fact_value.nil?
+
+        create_resolved_facts_list(fact_value)
+      end
+
+      def resolve_fact
+        chassis_serial = resolve(:chassis_serial)
+        return nil if !chassis_serial || chassis_serial.empty?
+
+        {
+          domainchassis: chassis_serial,
           domaincontrol: resolve(:control_domain),
           domainname: resolve(:domain_name),
           domainrole: {
@@ -23,13 +45,21 @@ module Facts
           },
           domainuuid: resolve(:domain_uuid)
         }
-
-        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       def resolve(key)
         Facter::Resolvers::Solaris::Ldom.resolve(key)
       end
+
+      def create_resolved_facts_list(fact_value)
+        resolved_facts = [Facter::ResolvedFact.new(FACT_NAME, fact_value)]
+        ALIASES.each do |fact_alias|
+          key = fact_alias.split('_')[1..-1].map!(&:to_sym)
+          resolved_facts << Facter::ResolvedFact.new(fact_alias, fact_value.dig(*key), :legacy)
+        end
+
+        resolved_facts
+      end
     end
   end
 end

data/lib/facter/facts/solaris/memory/swap/available.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/solaris/memory/swap/available_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:available_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/solaris/memory/swap/total.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/solaris/memory/swap/total_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:total_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/solaris/memory/swap/used.rb

@@ -10,7 +10,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
             end
             Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end

data/lib/facter/facts/solaris/memory/system/available.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/solaris/memory/system/available_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:available_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/solaris/memory/system/total.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/solaris/memory/system/total_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:total_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/solaris/memory/system/used.rb

@@ -10,7 +10,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
             end
             Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end

data/lib/facter/facts/solaris/processors/speed.rb

@@ -8,7 +8,7 @@ module Facts
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Solaris::Processors.resolve(:speed)
-          speed = Facter::FactsUtils::UnitConverter.hertz_to_human_readable(fact_value)
+          speed = Facter::Util::Facts::UnitConverter.hertz_to_human_readable(fact_value)
           Facter::ResolvedFact.new(FACT_NAME, speed)
         end
       end

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

@@ -16,7 +16,7 @@ module Facts
       end
 
       def resolver_data
-        Facter::Resolvers::SshResolver.resolve(:ssh)
+        Facter::Resolvers::Ssh.resolve(:ssh)
       end
 
       def create_ssh_fact(ssh)

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

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

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

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

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

@@ -51,7 +51,7 @@ module Facts
 
         return unless product_name
 
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+        Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
 
         nil
       end

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

@@ -4,6 +4,7 @@ module Facts
   module Windows
     class DhcpServers
       FACT_NAME = 'dhcp_servers'
+      TYPE = :legacy
 
       def call_the_resolver
         fact_value = construct_addresses_hash