facter 4.0.34 → 4.0.35

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class CurrentZone
+      FACT_NAME = 'solaris_zones.current'
+      ALIASES = 'zonename'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Solaris::ZoneName.resolve(:current_zone_name)
+
+        [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+      end
+    end
+  end
+end

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

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

data/lib/facter/facts/solaris/dmi/bios/release_date.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Bios
+        class ReleaseDate
+          FACT_NAME = 'dmi.bios.release_date'
+          ALIASES = 'bios_release_date'
+
+          def call_the_resolver
+            fact_value = nil
+            fact_value = Facter::Resolvers::Solaris::Dmi.resolve(:bios_release_date) if isa == 'i386'
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/bios/vendor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Bios
+        class Vendor
+          FACT_NAME = 'dmi.bios.vendor'
+          ALIASES = 'bios_vendor'
+
+          def call_the_resolver
+            fact_value = nil
+            fact_value = Facter::Resolvers::Solaris::Dmi.resolve(:bios_vendor) if isa == 'i386'
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/bios/version.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Bios
+        class Version
+          FACT_NAME = 'dmi.bios.version'
+          ALIASES = 'bios_version'
+
+          def call_the_resolver
+            fact_value = nil
+            fact_value = Facter::Resolvers::Solaris::Dmi.resolve(:bios_version) if isa == 'i386'
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/chassis/asset_tag.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Chassis
+        class AssetTag
+          FACT_NAME = 'dmi.chassis.asset_tag'
+          ALIASES = 'chassisassettag'
+
+          def call_the_resolver
+            fact_value = nil
+            fact_value = Facter::Resolvers::Solaris::Dmi.resolve(:chassis_asset_tag) if isa == 'i386'
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/chassis/type.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Chassis
+        class Type
+          FACT_NAME = 'dmi.chassis.type'
+          ALIASES = 'chassistype'
+
+          def call_the_resolver
+            fact_value = nil
+            fact_value = Facter::Resolvers::Solaris::Dmi.resolve(:chassis_type) if isa == 'i386'
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/manufacturer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      class Manufacturer
+        FACT_NAME = 'dmi.manufacturer'
+        ALIASES = 'manufacturer'
+
+        def call_the_resolver
+          fact_value = if isa == 'i386'
+                         Facter::Resolvers::Solaris::Dmi.resolve(:manufacturer)
+                       elsif isa == 'sparc'
+                         Facter::Resolvers::Solaris::DmiSparc.resolve(:manufacturer)
+                       end
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+
+        def isa
+          Facter::Resolvers::Uname.resolve(:processor)
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/product/name.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Product
+        class Name
+          FACT_NAME = 'dmi.product.name'
+          ALIASES = 'productname'
+
+          def call_the_resolver
+            fact_value = if isa == 'i386'
+                           Facter::Resolvers::Solaris::Dmi.resolve(:product_name)
+                         elsif isa == 'sparc'
+                           Facter::Resolvers::Solaris::DmiSparc.resolve(:product_name)
+                         end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/product/serial_number.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Product
+        class SerialNumber
+          FACT_NAME = 'dmi.product.serial_number'
+          ALIASES = 'serialnumber'
+
+          def call_the_resolver
+            fact_value = if isa == 'i386'
+                           Facter::Resolvers::Solaris::Dmi.resolve(:serial_number)
+                         elsif isa == 'sparc'
+                           Facter::Resolvers::Solaris::DmiSparc.resolve(:serial_number)
+                         end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/product/uuid.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Product
+        class Uuid
+          FACT_NAME = 'dmi.product.uuid'
+          ALIASES = 'uuid'
+
+          def call_the_resolver
+            fact_value = nil
+            fact_value = Facter::Resolvers::Solaris::Dmi.resolve(:product_uuid) if isa == 'i386'
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/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/solaris/os/release.rb

@@ -8,9 +8,9 @@ module Facts
         ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
 
         def call_the_resolver
-          full_value = Facter::Resolvers::SolarisRelease.resolve(:full)
-          major_value = Facter::Resolvers::SolarisRelease.resolve(:major)
-          minor_value = Facter::Resolvers::SolarisRelease.resolve(:minor)
+          full_value = Facter::Resolvers::Solaris::OsRelease.resolve(:full)
+          major_value = Facter::Resolvers::Solaris::OsRelease.resolve(:major)
+          minor_value = Facter::Resolvers::Solaris::OsRelease.resolve(:minor)
 
           [Facter::ResolvedFact.new(FACT_NAME, full: full_value, major: major_value, minor: minor_value),
            Facter::ResolvedFact.new(ALIASES.first, major_value, :legacy),

data/lib/facter/facts/solaris/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/solaris/zfs_featurenumbers.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zfs_featurenumbers'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZFS.resolve(:zfs_featurenumbers)
+        fact_value = Facter::Resolvers::ZFS.resolve(:zfs_featurenumbers)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

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

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zfs_version'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZFS.resolve(:zfs_version)
+        fact_value = Facter::Resolvers::ZFS.resolve(:zfs_version)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class Zones
+      FACT_NAME = 'solaris_zones.zones'
+      ALIASES = %w[
+        zone_.*_brand
+        zone_.*_iptype
+        zone_.*_name
+        zone_.*_uuid
+        zone_.*_id
+        zone_.*_path
+        zone_.*_status
+        zones
+      ].freeze
+
+      def call_the_resolver
+        resolved_facts = []
+        zones = {}
+
+        results = Facter::Resolvers::Solaris::Zone.resolve(:zone)
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless results
+
+        results&.each do |result|
+          zones.merge!(parse_result(result))
+          resolved_facts << create_legacy_zone_facts(result)
+        end
+
+        resolved_facts << Facter::ResolvedFact.new('solaris_zones.zones', zones)
+        resolved_facts << Facter::ResolvedFact.new('zones', results.count, :legacy)
+
+        resolved_facts.flatten
+      end
+
+      private
+
+      def parse_result(result)
+        {
+          result[:name].to_sym => {
+            brand: result[:brand],
+            id: result[:id],
+            ip_type: result[:iptype],
+            path: result[:path],
+            status: result[:status]
+          }
+        }
+      end
+
+      def create_legacy_zone_facts(zone)
+        legacy_facts = []
+        %w[brand iptype name uuid id path status].each do |key|
+          legacy_facts << Facter::ResolvedFact.new("zone_#{zone[:name]}_#{key}", zone[key.to_sym], :legacy)
+        end
+
+        legacy_facts
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zpool_featureflags'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZPool.resolve(:zpool_featureflags)
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_featureflags)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

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

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zpool_featurenumbers'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZPool.resolve(:zpool_featurenumbers)
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_featurenumbers)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

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

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zpool_version'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZPool.resolve(:zpool_version)
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_version)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

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

@@ -14,10 +14,10 @@ module Facts
       private
 
       def construct_addresses_hash
-        interfaces = Facter::Resolvers::Networking.resolve(:interfaces)
+        interfaces = Facter::Resolvers::Windows::Networking.resolve(:interfaces)
         return unless interfaces
 
-        servers = { system: Facter::Resolvers::Networking.resolve(:dhcp) }
+        servers = { system: Facter::Resolvers::Windows::Networking.resolve(:dhcp) }
         interfaces&.each { |interface_name, info| servers[interface_name] = info[:dhcp] if info[:dhcp] }
         servers
       end