facter 4.0.28

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/networking.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Resolvers
+  module Utils
+    module Networking
+      class << self
+        # Creates a hash with IP, netmask and network. Works for IPV4 and IPV6
+        # @param [String] addr The IP address
+        # @param [Integer] mask_length Number of 1 bits the netmask has
+        #
+        # @return [Hash] Hash containing ip address, netmask and network
+        def build_binding(addr, mask_length)
+          ip = IPAddr.new(addr)
+          mask_helper = ip.ipv6? ? 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' : '255.255.255.255'
+          mask = IPAddr.new(mask_helper).mask(mask_length)
+
+          { address: addr, netmask: mask.to_s, network: ip.mask(mask_length).to_s }
+        end
+
+        def expand_main_bindings(interfaces)
+          interfaces.each_value do |values|
+            expand_binding(values, values[:bindings]) if values[:bindings]
+            expand_binding(values, values[:bindings6], false) if values[:bindings6]
+          end
+        end
+
+        def get_scope(ip)
+          require 'socket'
+
+          scope6 = []
+          addrinfo = Addrinfo.new(['AF_INET6', 0, nil, ip], :INET6)
+
+          scope6 << 'compat,' if IPAddr.new(ip).ipv4_compat?
+          scope6 << if addrinfo.ipv6_linklocal?
+                      'link'
+                    elsif addrinfo.ipv6_sitelocal?
+                      'site'
+                    elsif addrinfo.ipv6_loopback?
+                      'host'
+                    else 'global'
+                    end
+          scope6.join
+        end
+
+        def find_valid_binding(bindings)
+          bindings.each do |binding|
+            return binding unless ignored_ip_address(binding[:address])
+          end
+          bindings.empty? ? nil : bindings.first
+        end
+
+        def ignored_ip_address(addr)
+          addr.empty? || addr.start_with?('127.', '169.254.') || addr.start_with?('fe80') || addr.eql?('::1')
+        end
+
+        private
+
+        def expand_binding(values, bindings, ipv4_type = true)
+          binding = find_valid_binding(bindings)
+          ip_protocol_type = ipv4_type ? '' : '6'
+
+          values["ip#{ip_protocol_type}".to_sym] = binding[:address]
+          values["netmask#{ip_protocol_type}".to_sym] = binding[:netmask]
+          values["network#{ip_protocol_type}".to_sym] = binding[:network]
+          values[:scope6] = get_scope(binding[:address]) unless ipv4_type
+        end
+      end
+    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/virt_what.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class VirtWhat < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_from_virt_what(fact_name) }
+        end
+
+        def retrieve_from_virt_what(fact_name)
+          output = Facter::Core::Execution.execute('virt-what', logger: log)
+
+          @fact_list[:vm] = determine_xen(output)
+          @fact_list[:vm] ||= determine_other(output)
+          retrieve_vserver unless @fact_list[:vserver]
+
+          @fact_list[fact_name]
+        end
+
+        def determine_xen(output)
+          xen_info = /^xen\n.*/.match(output)
+
+          return unless xen_info
+
+          xen_info = xen_info.to_s
+          return 'xenu' if xen_info =~ /xen-domu/
+          return 'xenhvm' if xen_info =~ /xen-hvm/
+          return 'xen0' if xen_info =~ /xen-dom0/
+        end
+
+        def determine_other(output)
+          other_vm = output.split("\n").first
+          return unless other_vm
+
+          return 'zlinux' if other_vm =~ /ibm_systemz/
+          return retrieve_vserver if other_vm =~ /linux_vserver/
+
+          other_vm
+        end
+
+        def retrieve_vserver
+          proc_status_content = Facter::Util::FileHelper.safe_readlines('/proc/self/status', nil)
+          return unless proc_status_content
+
+          proc_status_content.each do |line|
+            parts = line.split("\s")
+            next unless parts.size.equal?(2)
+
+            next unless parts[0] =~ /^s_context:|^VxID:/
+            return @fact_list[:vserver] = 'vserver_host' if parts[1] == '0'
+
+            return @fact_list[:vserver] = 'vserver'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/vmware.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Vmware < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { vmware_command(fact_name) }
+        end
+
+        def vmware_command(fact_name)
+          output = Facter::Core::Execution.execute('vmware -v', logger: log)
+          return if output.empty?
+
+          parts = output.split("\s")
+          return unless parts.size.equal?(2)
+
+          @fact_list[:vm] = "#{parts[0].downcase}_#{parts[1].downcase}"
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/aio_agent_version.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class AioAgentVersion < BaseResolver
+        REGISTRY_PATH = 'SOFTWARE\\Puppet Labs\\Puppet'
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_version(fact_name) }
+          end
+
+          def read_version(fact_name)
+            ::Win32::Registry::HKEY_LOCAL_MACHINE.open(REGISTRY_PATH) do |reg|
+              build_fact_list(reg)
+            end
+
+            @fact_list[fact_name]
+          rescue Win32::Registry::Error
+            log.debug("The registry path #{REGISTRY_PATH} does not exist")
+          end
+
+          def build_fact_list(reg)
+            puppet_aio_path = read_for_64_bit(reg) || read_for_32_bit(reg)
+
+            return if puppet_aio_path.nil? || puppet_aio_path.empty?
+
+            puppet_aio_version_path = File.join(puppet_aio_path, 'VERSION')
+            aio_agent_version = Util::FileHelper.safe_read(puppet_aio_version_path, nil)&.chomp
+
+            @fact_list[:aio_agent_version] = aio_agent_version&.match(/^\d+\.\d+\.\d+(\.\d+){0,2}/)&.to_s
+          end
+
+          def read_for_64_bit(reg)
+            reg.read('RememberedInstallDir64')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 64 bit registry')
+            nil
+          end
+
+          def read_for_32_bit(reg)
+            reg.read('RememberedInstallDir')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 32 bit registry')
+            nil
+          end
+        end
+      end
+    end
+  end
+end