facter 4.0.46 → 4.0.51

data/lib/facter/util/facts/virtual_detector.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class VirtualDetector
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def platform
+          fact_value = check_docker_lxc || check_dmi || check_freebsd || check_gce || retrieve_from_virt_what
+          fact_value ||= check_vmware || check_open_vz || check_vserver || check_xen || check_other_facts
+          fact_value ||= check_lspci || 'physical'
+
+          fact_value
+        end
+
+        def check_docker_lxc
+          @log.debug('Checking Docker and LXC')
+          Facter::Resolvers::Containers.resolve(:vm)
+        end
+
+        def check_dmi
+          @log.debug('Checking DMI')
+          vendor = Facter::Resolvers::DmiDecode.resolve(:vendor)
+          @log.debug("dmi detected vendor: #{vendor}")
+          return 'kvm' if vendor =~ /Amazon/
+
+          'xen' if vendor =~ /Xen/
+        end
+
+        def check_gce
+          @log.debug('Checking GCE')
+          bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+          'gce' if bios_vendor&.include?('Google')
+        end
+
+        def check_vmware
+          @log.debug('Checking VMware')
+          Facter::Resolvers::Vmware.resolve(:vm)
+        end
+
+        def retrieve_from_virt_what
+          @log.debug('Checking virtual_what')
+          Facter::Resolvers::VirtWhat.resolve(:vm)
+        end
+
+        def check_open_vz
+          @log.debug('Checking OpenVZ')
+          Facter::Resolvers::OpenVz.resolve(:vm)
+        end
+
+        def check_vserver
+          @log.debug('Checking VServer')
+          Facter::Resolvers::VirtWhat.resolve(:vserver)
+        end
+
+        def check_xen
+          @log.debug('Checking XEN')
+          Facter::Resolvers::Xen.resolve(:vm)
+        end
+
+        def check_freebsd
+          return unless Object.const_defined?('Facter::Resolvers::Freebsd::Virtual')
+
+          @log.debug('Checking if jailed')
+          Facter::Resolvers::Freebsd::Virtual.resolve(:vm)
+        end
+
+        def check_other_facts
+          @log.debug('Checking others')
+          product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+          bios_vendor =  Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+          return 'kvm' if bios_vendor&.include?('Amazon EC2')
+          return unless product_name
+
+          Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+          nil
+        end
+
+        def check_lspci
+          @log.debug('Checking lspci')
+          Facter::Resolvers::Lspci.resolve(:vm)
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/windows_release_finder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class WindowsReleaseFinder
+        class << self
+          def find_release(input)
+            version = input[:version]
+            return unless version
+
+            consumerrel = input[:consumerrel]
+            description = input[:description]
+            kernel_version = input[:kernel_version]
+
+            if version =~ /10.0/
+              check_version_10(consumerrel, kernel_version)
+            else
+              check_version_6(version, consumerrel) || check_version_5(version, consumerrel, description) || version
+            end
+          end
+
+          private
+
+          def check_version_10(consumerrel, kernel_version)
+            build_number = kernel_version[/([^.]*)$/].to_i
+            if consumerrel
+              '10'
+            elsif build_number >= 17_623
+              '2019'
+            else
+              '2016'
+            end
+          end
+
+          def check_version_6(version, consumerrel)
+            hash = {}
+            hash['6.3'] = consumerrel ? '8.1' : '2012 R2'
+            hash['6.2'] = consumerrel ? '8' : '2012'
+            hash['6.1'] = consumerrel ? '7' : '2008 R2'
+            hash['6.0'] = consumerrel ? 'Vista' : '2008'
+            hash[version]
+          end
+
+          def check_version_5(version, consumerrel, description)
+            return unless version =~ /5.2/
+            return 'XP' if consumerrel
+
+            description == 'R2' ? '2003 R2' : '2003'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/{resolvers/macosx/utils → util/macosx}/system_profile_executor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Facter
-  module Resolvers
+  module Util
     module Macosx
       class SystemProfileExecutor
         @log = Log.new(self)

data/lib/facter/util/resolvers/aws_token.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module AwsToken
+        attr_reader :token
+
+        @log = Facter::Log.new(self)
+
+        class << self
+          AWS_API_TOKEN_URL = 'http://169.254.169.254/latest/api/token'
+
+          def get(lifetime = 100)
+            @expiry ||= Time.now
+
+            return @token if @token && @expiry > Time.now
+
+            @token = nil
+            @expiry = Time.now + lifetime
+
+            headers = {
+              'X-aws-ec2-metadata-token-ttl-seconds' => lifetime.to_s
+            }
+
+            @token = Facter::Util::Resolvers::Http.put_request(AWS_API_TOKEN_URL, headers)
+          end
+
+          def reset
+            @expiry = nil
+            @token = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/{resolvers/utils → util/resolvers}/ffi/load_averages.rb

@@ -3,8 +3,8 @@
 require 'ffi'
 
 module Facter
-  module Resolvers
-    module Utils
+  module Util
+    module Resolvers
       module Ffi
         module LoadAverages
           extend ::FFI::Library

data/lib/facter/util/resolvers/filesystem_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      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
+            # TODO: this require must be replaced with "require 'sys/filesystem'" when a new release of
+            # djberg96/sys-filesystem gem is available
+            require_relative '../../patches/sysfilesystem/sys/statvfs.rb'
+            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
+  end
+end

data/lib/facter/util/resolvers/fingerprint.rb

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

data/lib/facter/{resolvers/utils → util/resolvers}/http.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Facter
-  module Resolvers
-    module Utils
+  module Util
+    module Resolvers
       module Http
         @log = Facter::Log.new(self)
 
@@ -27,6 +27,10 @@ module Facter
             make_request(url, headers, timeouts, 'GET')
           end
 
+          def put_request(url, headers = {}, timeouts = {})
+            make_request(url, headers, timeouts, 'PUT')
+          end
+
           private
 
           def make_request(url, headers, timeouts, request_type)
@@ -37,8 +41,10 @@ module Facter
             request = request_obj(headers, uri, request_type)
 
             # Make the request
-            resp = http.request(request)
-            response_code_valid?(resp.code.to_i) ? resp.body : ''
+            response = http.request(request)
+            response.uri = url
+
+            successful_response?(response) ? response.body : ''
           rescue StandardError => e
             @log.debug("Trying to connect to #{url} but got: #{e.message}")
             ''
@@ -52,14 +58,15 @@ module Facter
           end
 
           def request_obj(headers, parsed_url, request_type)
-            return Net::HTTP::Get.new(parsed_url.request_uri, headers) if request_type == 'GET'
-
-            raise StandardError("Unknown http request type: #{request_type}")
+            Module.const_get("Net::HTTP::#{request_type.capitalize}").new(parsed_url.request_uri, headers)
           end
 
-          def response_code_valid?(http_code)
-            @log.debug("Request failed with error code #{http_code}") unless http_code.equal?(200)
-            http_code.equal?(200)
+          def successful_response?(response)
+            success = response.code.to_i.equal?(200)
+
+            @log.debug("Request to #{response.uri} failed with error code #{response.code}") unless success
+
+            success
           end
         end
       end

data/lib/facter/util/resolvers/networking/dhcp.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module Networking
+        module Dhcp
+          class << self
+            def get(interface_name, log = nil)
+              dhcpinfo_command = Facter::Core::Execution.which('dhcpinfo') || '/sbin/dhcpinfo'
+              result = Facter::Core::Execution.execute("#{dhcpinfo_command} -i #{interface_name} ServerID", logger: log)
+              result.chomp!
+
+              result.empty? ? nil : result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/resolvers/networking/networking.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Facter
+  module Util
+    module Resolvers
+      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)
+            return if !addr || !mask_length
+
+            ip = IPAddr.new(addr)
+            mask_helper = nil
+            scope = nil
+            if ip.ipv6?
+              scope = get_scope(addr)
+              mask_helper = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+            else
+              mask_helper = '255.255.255.255'
+            end
+            mask = IPAddr.new(mask_helper).mask(mask_length)
+
+            result = { address: addr, netmask: mask.to_s, network: ip.mask(mask_length).to_s }
+            result[:scope6] = scope if scope
+            result
+          end
+
+          def expand_main_bindings(networking_facts)
+            primary = networking_facts[:primary_interface]
+            interfaces = networking_facts[:interfaces]
+
+            expand_interfaces(interfaces) unless interfaces.nil?
+            expand_primary_interface(networking_facts, primary) unless primary.nil? || interfaces.nil?
+          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
+
+          def calculate_mask_length(netmask)
+            ipaddr = IPAddr.new(netmask)
+
+            ipaddr.to_i.to_s(2).count('1')
+          end
+
+          def format_mac_address(address)
+            address.split('.').map { |e| format('%<mac_address>02s', mac_address: e) }.join(':').tr(' ', '0')
+          end
+
+          private
+
+          def expand_interfaces(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 expand_primary_interface(networking_facts, primary)
+            networking_facts[:interfaces][primary].each do |key, value|
+              networking_facts[key] = value unless %i[bindings bindings6].include?(key)
+            end
+          end
+
+          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
+end