facter 4.0.23

data/lib/resolvers/solaris/zone_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SolarisZone < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { build_zone_fact(fact_name) }
+        end
+
+        def build_zone_fact(fact_name)
+          command = '/usr/sbin/zoneadm list -cp'
+          zone_adm_output = Facter::Core::Execution.execute(command, logger: log)
+
+          if zone_adm_output.empty?
+            log.debug("Command #{command} returned an empty result")
+            return
+          end
+          @fact_list[:zone] = create_zone_facts(zone_adm_output)
+
+          @fact_list[fact_name]
+        end
+
+        def create_zone_facts(zones_result)
+          zones_fact = []
+          zones_result.each_line do |zone_line|
+            id, name, status, path, uuid, brand, ip_type = zone_line.split(':')
+            zones_fact << {
+              brand: brand,
+              id: id,
+              iptype: ip_type.chomp,
+              name: name,
+              uuid: uuid,
+              status: status,
+              path: path
+
+            }
+          end
+          zones_fact
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/solaris/zpool_resolver.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class ZPool < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { zpool_fact(fact_name) }
+          end
+
+          def zpool_fact(fact_name)
+            build_zpool_facts
+            @fact_list[fact_name]
+          end
+
+          def build_zpool_facts
+            output = Facter::Core::Execution.execute('zpool upgrade -v', logger: log)
+            features_list = output.scan(/^\s+(\d+)/).flatten
+            features_flags = output.scan(/^([a-z0-9_]+)[[:blank:]]*(\(read-only compatible\))?$/).map(&:first)
+
+            return if features_list.empty?
+
+            @fact_list[:zpool_featurenumbers] = features_list.join(',')
+            @fact_list[:zpool_featureflags] = features_flags.join(',')
+            @fact_list[:zpool_version] = features_flags.any? ? '5000' : features_list.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/ssh_resolver.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SshResolver < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      @file_names = %w[ssh_host_rsa_key.pub ssh_host_dsa_key.pub ssh_host_ecdsa_key.pub ssh_host_ed25519_key.pub]
+      @file_paths = %w[/etc/ssh /usr/local/etc/ssh /etc /usr/local/etc /etc/opt/ssh]
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+        end
+
+        def retrieve_info(fact_name)
+          ssh_list = []
+          @file_paths.each do |file_path|
+            next unless File.directory?(file_path)
+
+            @file_names.each do |file_name|
+              file_content = Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
+              next unless file_content
+
+              key_type, key = file_content.split(' ')
+              ssh_list << ::Resolvers::Utils::SshHelper.create_ssh(key_type, key)
+            end
+          end
+          @fact_list[:ssh] = ssh_list
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/suse_release_resolver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SuseRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_suse_release(fact_name) }
+        end
+
+        def read_suse_release(fact_name)
+          output = Util::FileHelper.safe_read('/etc/SuSE-release', nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          output_strings = output.split(' ')
+
+          @fact_list[:name] = output_strings[0]
+          @fact_list[:version] = output_strings[1]
+          @fact_list[:identifier] = @fact_list[:name].downcase
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/sw_vers_resolver.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SwVers < BaseResolver
+      # :productname
+      # :productversion
+      # :buildversion
+      #
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { software_version_system_call(fact_name) }
+        end
+
+        def software_version_system_call(fact_name)
+          output = Facter::Core::Execution.execute('sw_vers', logger: log)
+          release_info = output.delete("\t").split("\n").map { |e| e.split(':') }
+          result = Hash[*release_info.flatten]
+          result.each { |k, v| @fact_list[k.downcase.to_sym] = v }
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/timezone_resolver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Timezone < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { determine_timezone }
+        end
+
+        def determine_timezone
+          @fact_list[:timezone] = Time.now.localtime.strftime('%Z')
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/uname_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Uname < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { uname_system_call(fact_name) }
+        end
+
+        def uname_system_call(fact_name)
+          output = Facter::Core::Execution.execute('uname -m &&
+            uname -n &&
+            uname -p &&
+            uname -r &&
+            uname -s &&
+            uname -v', logger: log)
+
+          build_fact_list(output)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(output)
+          uname_results = output.split("\n")
+
+          @fact_list[:machine] = uname_results[0].strip
+          @fact_list[:nodename] = uname_results[1].strip
+          @fact_list[:processor] = uname_results[2].strip
+          @fact_list[:kernelrelease] = uname_results[3].strip
+          @fact_list[:kernelname] = uname_results[4].strip
+          @fact_list[:kernelversion] = uname_results[5].strip
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/uptime_resolver.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Uptime < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { uptime_system_call(fact_name) }
+        end
+
+        def uptime_system_call(fact_name)
+          seconds = Facter::UptimeParser.uptime_seconds_unix
+          build_fact_list(seconds)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(seconds)
+          return @fact_list[:uptime] = 'unknown' unless seconds
+
+          uptime_hash = create_uptime_hash(seconds)
+
+          @fact_list[:seconds] = uptime_hash[:seconds]
+          @fact_list[:hours]   = uptime_hash[:hours]
+          @fact_list[:days]    = uptime_hash[:days]
+          @fact_list[:uptime]  = uptime_hash[:uptime]
+        end
+
+        def create_uptime_hash(seconds)
+          results = {}
+          minutes = (seconds / 60) % 60
+
+          results[:seconds] = seconds
+          results[:hours]   = seconds / (60 * 60)
+          results[:days]    = results[:hours] / 24
+          results[:uptime]  = build_uptime_text(results[:days], results[:hours], minutes)
+
+          results
+        end
+
+        def build_uptime_text(days, hours, minutes)
+          case days
+          when 0 then "#{hours}:#{format('%<minutes>02d', minutes: minutes)} hours"
+          when 1 then '1 day'
+          else
+            "#{days} days"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/utils/filesystem_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module FilesystemHelper
+    MOUNT_KEYS = %i[device filesystem path options
+                    available available_bytes size
+                    size_bytes used used_bytes capacity].freeze
+    class << self
+      def read_mountpoints
+        require 'sys/filesystem'
+        force_utf(Sys::Filesystem.mounts)
+      end
+
+      def read_mountpoint_stats(path)
+        require 'sys/filesystem'
+        Sys::Filesystem.stat(path)
+      end
+
+      def compute_capacity(used, total)
+        if used == total
+          '100%'
+        elsif used.positive?
+          "#{format('%<value>.2f', value: (used / total.to_f * 100))}%"
+        else
+          '0%'
+        end
+      end
+
+      private
+
+      def force_utf(mounts)
+        mounts.each do |mount|
+          mount.name.force_encoding('UTF-8')
+          mount.mount_type.force_encoding('UTF-8')
+          mount.mount_point.force_encoding('UTF-8')
+          mount.options.force_encoding('UTF-8')
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/utils/fingerprint.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Facter
+  class FingerPrint
+    attr_accessor :sha1, :sha256
+    def initialize(sha1, sha256)
+      @sha1 = sha1
+      @sha256 = sha256
+    end
+  end
+end

data/lib/resolvers/utils/ssh.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Facter
+  class Ssh
+    attr_accessor :fingerprint, :type, :key, :name
+    def initialize(fingerprint, type, key, name)
+      @fingerprint = fingerprint
+      @type = type
+      @key = key
+      @name = name
+    end
+  end
+end

data/lib/resolvers/utils/ssh_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest/sha1'
+
+module Resolvers
+  module Utils
+    class SshHelper
+      class << self
+        SSH_NAME = { 'ssh-dss' => 'dsa', 'ecdsa-sha2-nistp256' => 'ecdsa',
+                     'ssh-ed25519' => 'ed25519', 'ssh-rsa' => 'rsa' }.freeze
+        SSH_FINGERPRINT = { 'rsa' => 1, 'dsa' => 2, 'ecdsa' => 3, 'ed25519' => 4 }.freeze
+
+        def create_ssh(key_type, key)
+          key_name = SSH_NAME[key_type]
+          decoded_key = Base64.decode64(key)
+          ssh_fp = SSH_FINGERPRINT[key_name]
+          sha1 = "SSHFP #{ssh_fp} 1 #{Digest::SHA1.new.update(decoded_key)}"
+          sha256 = "SSHFP #{ssh_fp} 2 #{Digest::SHA2.new.update(decoded_key)}"
+
+          fingerprint = Facter::FingerPrint.new(sha1, sha256)
+          Facter::Ssh.new(fingerprint, key_type, key, key_name)
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/dmi_bios_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DMIBios < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        # Manufacturer
+        # SerialNumber
+
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_bios(fact_name) }
+        end
+
+        def read_fact_from_bios(fact_name)
+          win = Win32Ole.new
+
+          bios = win.return_first('SELECT Manufacturer,SerialNumber from Win32_BIOS')
+          unless bios
+            @log.debug 'WMI query returned no results for Win32_BIOS with values Manufacturer and SerialNumber.'
+            return
+          end
+
+          build_fact_list(bios)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(bios)
+          @fact_list[:manufacturer] = bios.Manufacturer
+          @fact_list[:serial_number] = bios.SerialNumber
+        end
+      end
+    end
+  end
+end