facter 4.0.30 → 4.0.35

data/lib/facter/resolvers/linux/docker_uptime.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class DockerUptime < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { detect_uptime(fact_name) }
+          end
+
+          def detect_uptime(fact_name)
+            days, hours, minutes, seconds = extract_uptime_from_docker
+            total_seconds = convert_to_seconds(days, hours, minutes, seconds)
+            @fact_list = Utils::UptimeHelper.create_uptime_hash(total_seconds)
+
+            @fact_list[fact_name]
+          end
+
+          def extract_uptime_from_docker
+            # time format [dd-][hh:]mm:ss
+            time = Facter::Core::Execution.execute('ps -o etime= -p "1"', logger: log)
+            extracted_time = time.split(/[-:]/)
+
+            reversed_time = extracted_time.reverse
+            seconds = reversed_time[0].to_i
+            minutes = reversed_time[1].to_i
+            hours = reversed_time[2].to_i
+            days = reversed_time[3].to_i
+
+            [days, hours, minutes, seconds]
+          end
+
+          def convert_to_seconds(days, hours, minutes, seconds)
+            days * 24 * 3600 + hours * 3600 + minutes * 60 + seconds
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/{load_averages_resolver.rb → linux/load_averages.rb}

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Linux
       class LoadAverages < BaseResolver
-        @log = Facter::Log.new(self)
         @semaphore = Mutex.new
         @fact_list ||= {}
         class << self

data/lib/facter/resolvers/load_averages.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class LoadAverages < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
+        end
+
+        def read_load_averages(fact_name)
+          require_relative 'utils/ffi/load_averages'
+
+          log.debug('loading cpu load averages')
+          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Utils::Ffi::LoadAverages.read_load_averages).to_h
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/lspci.rb

@@ -28,6 +28,8 @@ module Facter
 
         def retrieve_vm(output)
           output.each_line { |line| REGEX_VALUES.each { |key, value| return value if line =~ /#{key}/ } }
+
+          nil
         end
       end
     end

data/lib/facter/resolvers/mountpoints_resolver.rb

@@ -2,59 +2,57 @@
 
 module Facter
   module Resolvers
-    module Linux
-      class Mountpoints < BaseResolver
-        include Facter::FilesystemHelper
-        @semaphore = Mutex.new
-        @fact_list ||= {}
-        @log = Facter::Log.new(self)
-        class << self
-          private
-
-          def post_resolve(fact_name)
-            @fact_list.fetch(fact_name) { read_mounts }
-          end
+    class Mountpoints < BaseResolver
+      include Facter::FilesystemHelper
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      @log = Facter::Log.new(self)
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_mounts }
+        end
 
-          def root_device
-            cmdline = Util::FileHelper.safe_read('/proc/cmdline')
-            match = cmdline.match(/root=([^\s]+)/)
-            match&.captures&.first
-          end
+        def root_device
+          cmdline = Util::FileHelper.safe_read('/proc/cmdline')
+          match = cmdline.match(/root=([^\s]+)/)
+          match&.captures&.first
+        end
 
-          def compute_device(device)
-            # If the "root" device, lookup the actual device from the kernel options
-            # This is done because not all systems symlink /dev/root
-            device = root_device if device == '/dev/root'
-            device
-          end
+        def compute_device(device)
+          # If the "root" device, lookup the actual device from the kernel options
+          # This is done because not all systems symlink /dev/root
+          device = root_device if device == '/dev/root'
+          device
+        end
 
-          def read_mounts # rubocop:disable Metrics/AbcSize
-            mounts = []
-            FilesystemHelper.read_mountpoints.each do |fs|
-              device = compute_device(fs.name)
-              filesystem = fs.mount_type
-              path = fs.mount_point
-              options = fs.options.split(',').map(&:strip)
+        def read_mounts # rubocop:disable Metrics/AbcSize
+          mounts = []
+          FilesystemHelper.read_mountpoints.each do |fs|
+            device = compute_device(fs.name)
+            filesystem = fs.mount_type
+            path = fs.mount_point
+            options = fs.options.split(',').map(&:strip)
 
-              next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
+            next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
 
-              stats = FilesystemHelper.read_mountpoint_stats(path)
-              size_bytes = stats.bytes_total.abs
-              available_bytes = stats.bytes_available.abs
+            stats = FilesystemHelper.read_mountpoint_stats(path)
+            size_bytes = stats.bytes_total.abs
+            available_bytes = stats.bytes_available.abs
 
-              used_bytes = stats.bytes_used.abs
-              total_bytes = used_bytes + available_bytes
-              capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
+            used_bytes = stats.bytes_used.abs
+            total_bytes = used_bytes + available_bytes
+            capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
 
-              size = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
-              available = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes)
-              used = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes)
+            size = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+            available = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes)
+            used = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes)
 
-              mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
-                .map { |v| binding.local_variable_get(v) })]
-            end
-            @fact_list[:mountpoints] = mounts
+            mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
+              .map { |v| binding.local_variable_get(v) })]
           end
+          @fact_list[:mountpoints] = mounts
         end
       end
     end

data/lib/facter/resolvers/networking_linux_resolver.rb

@@ -11,6 +11,7 @@ module Facter
         private
 
         def post_resolve(fact_name)
+          log.debug('in networking_linux_resolver')
           @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
 
           @fact_list[fact_name]
@@ -36,12 +37,17 @@ module Facter
         end
 
         def retrieve_interface_info
+          log.debug('retrieve_interface_info')
           output = Facter::Core::Execution.execute('ip -o address', logger: log)
+          log.debug("ip -o address result is:\n#{output}")
+
           interfaces = {}
 
           output.each_line do |ip_line|
             ip_tokens = ip_line.split(' ')
 
+            log.debug("ip_tokens = #{ip_tokens}")
+            log.debug("interfaces = #{interfaces}")
             fill_ip_v4_info!(ip_tokens, interfaces)
             fill_io_v6_info!(ip_tokens, interfaces)
             find_dhcp!(ip_tokens, interfaces)
@@ -85,14 +91,23 @@ module Facter
           return unless lease_file
 
           dhcp = Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
-          dhcp ? dhcp.match(/SERVER_ADDRESS=(.*)/)[1] : nil
+
+          return unless dhcp
+
+          dhcp = dhcp.match(/SERVER_ADDRESS=(.*)/)
+          dhcp[1] if dhcp
         end
 
         def fill_ip_v4_info!(ip_tokens, network_info)
+          log.debug('fill_ip_v4_info!')
           return unless ip_tokens[2].casecmp('inet').zero?
 
           interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens)
 
+          log.debug("interface_name = #{interface_name}\n" \
+                      "ip4_address = #{ip4_address}\n" \
+                      "ip4_mask_length = #{ip4_mask_length}")
+
           binding = ::Resolvers::Utils::Networking.build_binding(ip4_address, ip4_mask_length)
           build_network_info_structure!(network_info, interface_name, :bindings)
 

data/lib/facter/resolvers/networking_resolver.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Networking < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          primary_interface
+          interfaces_data
+          ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+          @fact_list[fact_name]
+        end
+
+        def primary_interface
+          result = Facter::Core::Execution.execute('route -n get default', logger: log)
+
+          @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
+        end
+
+        def interfaces_data
+          command_response = Facter::Core::Execution.execute('ifconfig -a', logger: log)
+
+          clean_up_interfaces_response(command_response)
+          parse_interfaces_response(command_response)
+        end
+
+        def clean_up_interfaces_response(response)
+          # convert ip ranges into single ip. eg. 10.16.132.213 -->  10.16.132.213 is converted to 10.16.132.213
+          response.gsub!(/(\d+(\.\d+)*)\s+-->\s+\d+(\.\d+)*/, '\\1')
+        end
+
+        def parse_interfaces_response(response)
+          parsed_interfaces_data = {}
+          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+
+          interfaces_data.each do |interface_name, raw_data|
+            parsed_interface_data = {}
+
+            extract_mtu(raw_data, parsed_interface_data)
+            extract_mac(raw_data, parsed_interface_data)
+            extract_dhcp(interface_name, raw_data, parsed_interface_data)
+            extract_ip_data(raw_data, parsed_interface_data)
+
+            parsed_interfaces_data[interface_name] = parsed_interface_data
+          end
+          @fact_list[:interfaces] = parsed_interfaces_data unless parsed_interfaces_data.empty?
+        end
+
+        def extract_mtu(raw_data, parsed_interface_data)
+          mtu = raw_data.match(/mtu\s+(\d+)/)&.captures&.first&.to_i
+          parsed_interface_data[:mtu] = mtu unless mtu.nil?
+        end
+
+        def extract_mac(raw_data, parsed_interface_data)
+          mac = raw_data.match(/(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/)&.captures&.first
+          parsed_interface_data[:mac] = mac unless mac.nil?
+        end
+
+        def extract_dhcp(interface_name, raw_data, parsed_interface_data)
+          return unless raw_data =~ /status:\s+active/
+
+          result = Facter::Core::Execution.execute("ipconfig getoption #{interface_name} " \
+                                                     'server_identifier', logger: log)
+
+          parsed_interface_data[:dhcp] = result.match(/^[\d.a-f:\s]+$/)&.to_s&.strip unless result.empty?
+        end
+
+        def extract_ip_data(raw_data, parsed_interface_data)
+          ip = extract_values(raw_data, /inet (\S+)/)
+          mask = extract_values(raw_data, /netmask (\S+)/).map { |val| val.hex.to_s(2).count('1') }
+
+          ip6 = extract_values(raw_data, /inet6 (\S+)/).map { |val| val.gsub(/%.+/, '') }
+          mask6 = extract_values(raw_data, /prefixlen (\S+)/)
+
+          parsed_interface_data[:bindings] = create_bindings(ip, mask) unless ip.empty?
+          parsed_interface_data[:bindings6] = create_bindings(ip6, mask6) unless ip6.empty?
+        end
+
+        def extract_values(data, regex)
+          results = []
+          data.scan(regex).flatten.each do |val|
+            results << val
+          end
+          results
+        end
+
+        def create_bindings(ips, masks)
+          bindings = []
+          ips.zip(masks).each do |ip, mask|
+            bindings << ::Resolvers::Utils::Networking.build_binding(ip, mask)
+          end
+          bindings
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/os_release_resolver.rb

@@ -56,7 +56,7 @@ module Facter
         def process_name
           return unless @fact_list[:name]
 
-          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red')
+          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red', 'oracle')
                                 @fact_list[:name].split(' ')[0..1].join
                               else
                                 @fact_list[:name].split(' ')[0].strip

data/lib/facter/resolvers/redhat_release_resolver.rb

@@ -32,9 +32,10 @@ module Facter
           version_codename = output_strings[1].split(' ')
 
           @fact_list[:name] = name(output_strings[0])
-          @fact_list[:version] = version_codename[0].strip
-          codename = version_codename[1].strip
-          @fact_list[:codename] = codename.gsub(/[()]/, '')
+          @fact_list[:version] = version_codename[0]&.strip
+
+          codename = version_codename[1]&.strip
+          @fact_list[:codename] = codename ? codename.gsub(/[()]/, '') : nil
 
           @fact_list[:identifier] = identifier(@fact_list[:name])
         end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Disks < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_disks_info(fact_name) }
+          end
+
+          def read_disks_info(fact_name)
+            return unless File.executable?('/usr/bin/kstat')
+
+            log.debug('loading disks info')
+
+            kstat_output = Facter::Core::Execution.execute('/usr/bin/kstat sderr', logger: log)
+            return if kstat_output.empty?
+
+            @fact_list[fact_name] = parse(kstat_output)
+          end
+
+          def parse(kstat_output)
+            disks = {}
+
+            names = kstat_output.scan(/name:\s+(\w+)/).flatten
+            products = kstat_output.scan(/Product\s+(.+)/).flatten
+            vendors = kstat_output.scan(/Vendor\s+(\w+)/).flatten
+            sizes = kstat_output.scan(/Size\s+(\w+)/).flatten
+
+            names.each_with_index do |name, index|
+              disk_size = sizes[index].to_i
+              disks[name] = {
+                product: products[index],
+                size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(disk_size),
+                size_bytes: disk_size,
+                vendor: vendors[index]
+              }
+            end
+            disks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/dmi.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Dmi < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          SMBIOS_PARAMS = {
+            'SMB_TYPE_BIOS' => {
+              bios_version: 'Version String: (.+)',
+              bios_vendor: 'Vendor: (.+)',
+              bios_release_date: 'Release Date: (.+)'
+            },
+            'SMB_TYPE_SYSTEM' => {
+              manufacturer: 'Manufacturer: (.+)',
+              product_name: 'Product: (.+)',
+              serial_number: 'Serial Number: (.+)',
+              product_uuid: 'UUID: (.+)'
+            },
+            'SMB_TYPE_CHASSIS' => {
+              chassis_asset_tag: 'Asset Tag: (.+)',
+              chassis_type: '(?:Chassis )?Type: (.+)'
+            }
+          }.freeze
+
+          def read_facts(fact_name)
+            param = SMBIOS_PARAMS.find { |_key, hash| hash[fact_name] }
+            return nil unless param
+
+            output = exec_smbios(param[0])
+            facts = param[1]
+            facts.each do |name, regx|
+              @fact_list[name] = output.match(/#{regx}/)&.captures&.first
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def exec_smbios(args)
+            return unless File.executable?('/usr/sbin/smbios')
+
+            Facter::Core::Execution.execute("/usr/sbin/smbios -t #{args}", logger: log)
+          end
+        end
+      end
+    end
+  end
+end