facter 4.0.47 → 4.0.52

data/lib/facter/resolvers/windows/{processors_resolver.rb → processors.rb}

@@ -13,7 +13,7 @@ module Facter
 
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_fact_from_win32_processor(fact_name) }
         end
 

data/lib/facter/resolvers/windows/{product_release_resolver.rb → product_release.rb}

@@ -10,7 +10,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_fact_from_registry(fact_name) }
         end
 

data/lib/facter/resolvers/windows/ssh.rb

@@ -13,7 +13,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
           end
 

data/lib/facter/resolvers/windows/{system32_resolver.rb → system32.rb}

@@ -10,7 +10,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { retrieve_windows_binaries_path }
         end
 

data/lib/facter/resolvers/windows/{uptime_resolver.rb → uptime.rb}

@@ -13,7 +13,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { calculate_system_uptime(fact_name) }
           end
 

data/lib/facter/resolvers/windows/{virtualization_resolver.rb → virtualization.rb}

@@ -16,7 +16,7 @@ module Facter
 
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
         end
 

data/lib/facter/resolvers/windows/{win_os_description_resolver.rb → win_os_description.rb}

@@ -10,7 +10,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_from_ole(fact_name) }
         end
 

data/lib/facter/resolvers/{wpar_resolver.rb → wpar.rb}

@@ -8,7 +8,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_wpar(fact_name) }
         end
 

data/lib/facter/resolvers/xen.rb

@@ -12,7 +12,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { detect_xen(fact_name) }
         end
 

data/lib/facter/resolvers/zfs.rb

@@ -8,7 +8,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { zfs_fact(fact_name) }
         end
 

data/lib/facter/resolvers/zpool.rb

@@ -8,7 +8,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { zpool_fact(fact_name) }
         end
 

data/lib/facter/templates/man.erb

@@ -20,6 +20,14 @@ OPTIONS
 
 <% end -%>
 
+<% @Facter::Cli.commands.select { |_k, command_class| command_class.instance_of?(Thor::Command) }.each do |_, command| -%>
+  * `<%= command.usage %>`:
+
+    <%= command.description %>
+
+
+<% end -%>
+
 FILES
 -----
 <em>/etc/puppetlabs/facter/facter.conf</em>

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

@@ -9,6 +9,39 @@ module Facter
                            'BHYVE' => 'bhyve' }.freeze
 
       PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
+      REDHAT_FAMILY = %w[redhat rhel fedora centos scientific ascendos cloudlinux psbm
+                         oraclelinux ovs oel amazon xenserver xcp-ng virtuozzo photon].freeze
+      DEBIAN_FAMILY = %w[debian ubuntu huaweios linuxmint devuan kde].freeze
+      SUSE_FAMILY = %w[sles sled suse].freeze
+      GENTOO_FAMILY = ['gentoo'].freeze
+      ARCH_FAMILY = %w[arch manjaro].freeze
+      MANDRAKE_FAMILY = %w[mandrake mandriva mageia].freeze
+      FAMILY_HASH = { 'RedHat' => REDHAT_FAMILY, 'Debian' => DEBIAN_FAMILY, 'Suse' => SUSE_FAMILY,
+                      'Gentoo' => GENTOO_FAMILY, 'Archlinux' => ARCH_FAMILY, 'Mandrake' => MANDRAKE_FAMILY }.freeze
+
+      class << self
+        def discover_family(os)
+          FAMILY_HASH.each { |key, array_value| return key if array_value.any? { |os_flavour| os =~ /#{os_flavour}/i } }
+          os
+        end
+
+        def release_hash_from_string(output)
+          return unless output
+
+          versions = output.split('.')
+          {}.tap do |release|
+            release['full'] = output
+            release['major'] = versions[0]
+            release['minor'] = versions[1] if versions[1]
+          end
+        end
+
+        def release_hash_from_matchdata(data)
+          return if data.nil? || data[1].nil?
+
+          release_hash_from_string(data[1].to_s)
+        end
+      end
     end
   end
 end

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

@@ -17,10 +17,9 @@ module Facter
             speed = speed.to_i
             return if !speed || speed.zero?
 
-            prefix = { 3 => 'k', 6 => 'M', 9 => 'G', 12 => 'T' }
-            power = Math.log10(speed).floor
-            validated_speed = power.zero? ? speed.to_f : speed.fdiv(10**power)
-            format('%<displayed_speed>.2f', displayed_speed: validated_speed).to_s + ' ' + prefix[power] + 'Hz'
+            validated_speed, metric_prefix = determine_metric_prefix(speed)
+
+            format('%<displayed_speed>.2f', displayed_speed: validated_speed).to_s + ' ' + metric_prefix + 'Hz'
           end
 
           def bytes_to_human_readable(bytes)
@@ -54,6 +53,14 @@ module Facter
             converted_number = bytes if multiple == 'bytes'
             [converted_number, multiple]
           end
+
+          def determine_metric_prefix(num)
+            metric_prefix = { 0 => '', 3 => 'k', 6 => 'M', 9 => 'G', 12 => 'T' }
+            power = Math.log10(num).floor
+            display_exponent = power - power % 3
+            coefficient = power.zero? ? num.to_f : num.fdiv(10**display_exponent)
+            [coefficient, metric_prefix[display_exponent]]
+          end
         end
       end
     end

data/lib/facter/util/linux/dhcp.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class Dhcp
+        class << self
+          DIRS = %w[/var/lib/dhclient/
+                    /var/lib/dhcp/
+                    /var/lib/dhcp3/
+                    /var/lib/NetworkManager/
+                    /var/db/].freeze
+
+          def dhcp(interface_name, interface_index, logger)
+            @log = logger
+            @log.debug("Get DHCP for interface #{interface_name}")
+
+            dhcp = search_systemd_netif_leases(interface_index, interface_name)
+            dhcp ||= search_dhclient_leases(interface_name)
+            dhcp ||= search_internal_leases(interface_name)
+            dhcp ||= search_with_dhcpcd_command(interface_name)
+            dhcp
+          end
+
+          private
+
+          def search_systemd_netif_leases(index, interface_name)
+            return if index.nil?
+
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from systemd/netif/leases")
+
+            file_content = Facter::Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
+            dhcp = file_content.match(/SERVER_ADDRESS=(.*)/) if file_content
+            dhcp[1] if dhcp
+          end
+
+          def search_dhclient_leases(interface_name)
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from dhclient leases")
+
+            DIRS.each do |dir|
+              next unless File.readable?(dir)
+
+              lease_files = Dir.entries(dir).select { |file| file =~ /dhclient.*\.lease/ }
+              next if lease_files.empty?
+
+              lease_files.select do |file|
+                content = Facter::Util::FileHelper.safe_read("#{dir}#{file}", nil)
+                next unless content =~ /interface.*#{interface_name}/
+
+                dhcp = content.match(/dhcp-server-identifier ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)
+                return dhcp[1] if dhcp
+              end
+            end
+
+            nil
+          end
+
+          def search_internal_leases(interface_name)
+            return unless File.readable?('/var/lib/NetworkManager/')
+
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from NetworkManager leases")
+
+            files = Dir.entries('/var/lib/NetworkManager/').reject { |dir| dir =~ /^\.+$/ }
+            lease_file = files.find { |file| file =~ /internal.*#{interface_name}\.lease/ }
+            return unless lease_file
+
+            dhcp = Facter::Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
+
+            return unless dhcp
+
+            dhcp = dhcp.match(/SERVER_ADDRESS=(.*)/)
+            dhcp[1] if dhcp
+          end
+
+          def search_with_dhcpcd_command(interface_name)
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from dhcpcd command")
+
+            output = Facter::Core::Execution.execute("dhcpcd -U #{interface_name}", logger: @log)
+            dhcp = output.match(/dhcp_server_identifier='(.*)'/)
+            dhcp[1] if dhcp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/linux/routing_table.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class RoutingTable
+        class << self
+          ROUTE_TYPES = %w[anycast
+                           unicast
+                           broadcast
+                           local
+                           nat
+                           unreachable
+                           prohibit
+                           blackhole
+                           throw].freeze
+
+          def read_routing_table(logger)
+            ipv4_output = Facter::Core::Execution.execute('ip route show', logger: logger)
+            ipv6_output = Facter::Core::Execution.execute('ip -6 route show', logger: logger)
+            routes4 = parse_routes(ipv4_output, true)
+            routes6 = parse_routes(ipv6_output, false)
+            [routes4, routes6]
+          end
+
+          private
+
+          def parse_routes(output, ipv4_type)
+            routes = []
+            output.each_line do |line|
+              parts = line.split(' ').compact
+              next if parts.include?('linkdown')
+
+              delete_invalid_route_type(parts)
+              next if !ipv4_type && !parts[0].include?(':')
+
+              route = construct_route(parts)
+              routes << route unless route[:ip].nil?
+            end
+            routes.uniq
+          end
+
+          def delete_invalid_route_type(parts)
+            route_type = parts[0]
+            parts.delete_at(0) if ROUTE_TYPES.include?(route_type)
+          end
+
+          def construct_route(parts)
+            route = {}
+            dev_index = parts.find_index { |elem| elem == 'dev' }
+            src_index = parts.find_index { |elem| elem == 'src' }
+            route[:interface] = parts[dev_index + 1] if dev_index
+            route[:ip] = parts[src_index + 1] if src_index
+            route
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/linux/socket_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class SocketParser
+        class << self
+          def retrieve_interfaces(logger)
+            require 'socket'
+            @interfaces = {}
+            @log = logger
+            Socket.getifaddrs.each do |ifaddr|
+              populate_interface_info(ifaddr)
+            end
+
+            @interfaces
+          end
+
+          private
+
+          def populate_interface_info(ifaddr)
+            interface_name = ifaddr.name
+            @interfaces[interface_name] = {} if @interfaces[interface_name].nil?
+
+            mac(ifaddr)
+            ip_info_of(ifaddr)
+          end
+
+          def mac(ifaddr)
+            return unless @interfaces[ifaddr.name][:mac].nil?
+
+            mac = search_for_mac(ifaddr)
+            @interfaces[ifaddr.name][:mac] = mac if mac
+          end
+
+          def search_for_mac(ifaddr)
+            mac = mac_from_bonded_interface(ifaddr.name)
+            mac ||= mac_from(ifaddr)
+            mac if !mac.nil? && mac != '00:00:00:00:00:00' && mac =~ /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/
+          end
+
+          def mac_from_bonded_interface(interface_name)
+            master = bond_master_of(interface_name)
+            return unless master
+
+            output = Facter::Util::FileHelper.safe_read("/proc/net/bonding/#{master}", nil)
+            return unless output
+
+            found_match = false
+            output.each_line do |line|
+              if line.strip == "Slave Interface: #{interface_name}"
+                found_match = true
+              elsif line.include? 'Slave Interface'
+                # if we reached the data block of another interface belonging to the bonded interface
+                found_match = false
+              end
+              return Regexp.last_match(1) if found_match && line =~ /Permanent HW addr: (\S*)/
+            end
+          end
+
+          def bond_master_of(interface_name)
+            content = Facter::Core::Execution.execute("ip link show #{interface_name}", logger: @log)
+            content.match(/master (\S*) /)&.captures&.first
+          end
+
+          def mac_from(ifaddr)
+            if Socket.const_defined? :PF_LINK
+              ifaddr.addr&.getnameinfo&.first # sometimes it returns localhost or ip
+            elsif Socket.const_defined? :PF_PACKET
+              return if ifaddr.addr.nil?
+
+              mac_from_sockaddr_of(ifaddr)
+            end
+          rescue StandardError => e
+            @log.debug("Could not read mac for interface #{ifaddr.name}, got #{e}")
+          end
+
+          def mac_from_sockaddr_of(ifaddr)
+            result = ifaddr.addr.inspect_sockaddr
+            result&.match(/hwaddr=([\h:]+)/)&.captures&.first
+          end
+
+          def ip_info_of(ifaddr)
+            return if ifaddr.addr.nil? || ifaddr.netmask.nil?
+
+            add_binding(ifaddr.name, ifaddr)
+          rescue StandardError => e
+            @log.debug("Could not read binding data, got #{e}")
+          end
+
+          def add_binding(interface_name, ifaddr)
+            ip, netmask, binding_key = binding_data(ifaddr)
+            binding = Facter::Util::Resolvers::Networking.build_binding(ip, netmask)
+            return if binding.nil?
+
+            @interfaces[interface_name][binding_key] = [] if @interfaces[interface_name][binding_key].nil?
+            @interfaces[interface_name][binding_key] << binding
+
+            @log.debug("Adding to interface #{interface_name}, binding:\n#{binding}")
+          end
+
+          def binding_data(ifaddr)
+            # ipv6 ips are retrieved as <ip>%<interface_name>
+            ip = ifaddr.addr.ip_address.split('%').first
+            netmask = ifaddr.netmask.ip_address
+            binding_key = ifaddr.addr.ipv4? ? :bindings : :bindings6
+
+            [ip, netmask, binding_key]
+          end
+        end
+      end
+    end
+  end
+end