facter 4.0.28

data/lib/resolvers/macosx/processor_resolver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class Processors < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list = {}
+        ITEMS = { logical_count: 'hw.logicalcpu_max',
+                  physical_count: 'hw.physicalcpu_max',
+                  brand: 'machdep.cpu.brand_string',
+                  speed: 'hw.cpufrequency_max' }.freeze
+        class << self
+          # :logicalcount
+          # :models
+          # :physicalcount
+          # :speed
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_processor_data(fact_name) }
+          end
+
+          def read_processor_data(fact_name)
+            output = Facter::Core::Execution.execute("sysctl #{ITEMS.values.join(' ')}", logger: log)
+            build_fact_list(output.split("\n"))
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(processors_data)
+            build_logical_count(processors_data[0])
+            build_physical_count(processors_data[1])
+            build_models(processors_data[2])
+            build_speed(processors_data[3])
+          end
+
+          def build_logical_count(count)
+            @fact_list[:logicalcount] = count.split(': ')[1].to_i
+          end
+
+          def build_physical_count(count)
+            @fact_list[:physicalcount] = count.split(': ')[1].to_i
+          end
+
+          def build_models(model)
+            brand = model.split(': ').fetch(1)
+            @fact_list[:models] = Array.new(@fact_list[:logicalcount].to_i, brand)
+          end
+
+          def build_speed(value)
+            @fact_list[:speed] = value.split(': ')[1].to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/swap_memory_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class SwapMemory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_swap_memory(fact_name) }
+          end
+
+          def read_swap_memory(fact_name) # rubocop:disable Metrics/AbcSize
+            output = Facter::Core::Execution.execute('sysctl -n vm.swapusage', logger: log)
+            data = output.match(/^total = ([\d.]+)M  used = ([\d.]+)M  free = ([\d.]+)M  (\(encrypted\))$/)
+
+            if data[1].to_f.positive?
+              @fact_list[:total_bytes] = megabytes_to_bytes(data[1])
+              @fact_list[:used_bytes] = megabytes_to_bytes(data[2])
+              @fact_list[:available_bytes] = megabytes_to_bytes(data[3])
+              @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
+              @fact_list[:encrypted] = data[4] == '(encrypted)'
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def megabytes_to_bytes(quantity)
+            (quantity.to_f * 1_048_576).to_i
+          end
+
+          def compute_capacity(used, total)
+            "#{format('%<value>.2f', value: (used / total.to_f * 100))}%"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/system_memory_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class SystemMemory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { calculate_system_memory(fact_name) }
+          end
+
+          def calculate_system_memory(fact_name)
+            read_total_memory_in_bytes
+            read_available_memory_in_bytes
+
+            @fact_list[:used_bytes] = @fact_list[:total_bytes] - @fact_list[:available_bytes]
+            @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
+
+            @fact_list[fact_name]
+          end
+
+          def read_available_memory_in_bytes
+            output = Facter::Core::Execution.execute('vm_stat', logger: log)
+            page_size = output.match(/page size of (\d+) bytes/)[1].to_i
+            pages_free = output.match(/Pages free:\s+(\d+)/)[1].to_i
+
+            @fact_list[:available_bytes] = page_size * pages_free
+          end
+
+          def read_total_memory_in_bytes
+            @fact_list[:total_bytes] = Facter::Core::Execution.execute('sysctl -n hw.memsize', logger: log).to_i
+          end
+
+          def compute_capacity(used, total)
+            "#{format('%<value>.2f', value: (used / total.to_f * 100))}%"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/system_profiler_resolver.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SystemProfiler < BaseResolver
+      # model_name
+      # model_identifier
+      # processor_name
+      # processor_speed
+      # number_of_processors
+      # total_number_of_cores
+      # l2_cache_per_core
+      # l3_cache
+      # hyper-threading_technology
+      # memory
+      # boot_rom_version
+      # serial_number_system
+      # hardware_uuid
+      # activation_lock_status
+      # system_version
+      # kernel_version
+      # boot_volume
+      # boot_mode
+      # computer_name
+      # user_name
+      # secure_virtual_memory
+      # system_integrity_protection
+      # time_since_boot
+      # smc_version_system
+
+      @semaphore = Mutex.new
+      @fact_list = {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_system_profiler(fact_name) }
+        end
+
+        def retrieve_system_profiler(fact_name)
+          @fact_list ||= {}
+
+          log.debug 'Executing command: system_profiler SPSoftwareDataType SPHardwareDataType'
+          output = Facter::Core::Execution.execute(
+            'system_profiler SPHardwareDataType SPSoftwareDataType', logger: log
+          ).force_encoding('UTF-8')
+          @fact_list = output.scan(/.*:[ ].*$/).map { |e| e.strip.match(/(.*?): (.*)/).captures }.to_h
+          normalize_factlist
+
+          @fact_list[fact_name]
+        end
+
+        def normalize_factlist
+          @fact_list = @fact_list.map do |k, v|
+            [k.downcase.tr(' ', '_').delete("\(\)").to_sym, v]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/memory_resolver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Memory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        @log = Facter::Log.new(self)
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_meminfo_file(fact_name) }
+          end
+
+          def read_meminfo_file(fact_name)
+            meminfo_output = Util::FileHelper.safe_read('/proc/meminfo', nil)
+            return unless meminfo_output
+
+            read_system(meminfo_output)
+            read_swap(meminfo_output)
+
+            @fact_list[fact_name]
+          end
+
+          def read_system(output)
+            @fact_list[:total] = kilobytes_to_bytes(output.match(/MemTotal:\s+(\d+)\s/)[1])
+            @fact_list[:memfree] = kilobytes_to_bytes(output.match(/MemFree:\s+(\d+)\s/)[1])
+            @fact_list[:used_bytes] = compute_used(@fact_list[:total], @fact_list[:memfree])
+            @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total])
+          end
+
+          def read_swap(output)
+            total = output.match(/SwapTotal:\s+(\d+)\s/)[1]
+            return if total.to_i.zero?
+
+            @fact_list[:swap_total] = kilobytes_to_bytes(total)
+            @fact_list[:swap_free] = kilobytes_to_bytes(output.match(/SwapFree:\s+(\d+)\s/)[1])
+            @fact_list[:swap_used_bytes] = compute_used(@fact_list[:swap_total], @fact_list[:swap_free])
+            @fact_list[:swap_capacity] = compute_capacity(@fact_list[:swap_used_bytes], @fact_list[:swap_total])
+          end
+
+          def kilobytes_to_bytes(quantity)
+            quantity.to_i * 1024
+          end
+
+          def compute_capacity(used, total)
+            format('%<computed_capacity>.2f', computed_capacity: (used / total.to_f * 100)) + '%'
+          end
+
+          def compute_used(total, free)
+            total - free
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/mountpoints_resolver.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+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
+
+          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 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'
+
+              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)
+
+              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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/networking_linux_resolver.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class NetworkingLinux < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list = {}
+      DIRS = ['/var/lib/dhclient/', '/var/lib/dhcp/', '/var/lib/dhcp3/', '/var/lib/NetworkManager/', '/var/db/'].freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
+
+          @fact_list[fact_name]
+        end
+
+        def retrieve_network_info(fact_name)
+          @fact_list ||= {}
+
+          retrieve_interface_info
+          retrieve_interfaces_mac_and_mtu
+          retrieve_default_interface
+          @fact_list[fact_name]
+        end
+
+        def retrieve_interfaces_mac_and_mtu
+          @fact_list[:interfaces].map do |name, info|
+            macaddress = Util::FileHelper.safe_read("/sys/class/net/#{name}/address", nil)
+            info[:mac] = macaddress.strip if macaddress && !macaddress.include?('00:00:00:00:00:00')
+            mtu = Util::FileHelper.safe_read("/sys/class/net/#{name}/mtu", nil)
+            info[:mtu] = mtu.strip.to_i if mtu
+          end
+        end
+
+        def retrieve_interface_info
+          output = Facter::Core::Execution.execute('ip -o address', logger: log)
+          interfaces = {}
+
+          output.each_line do |ip_line|
+            ip_tokens = ip_line.split(' ')
+
+            fill_ip_v4_info!(ip_tokens, interfaces)
+            fill_io_v6_info!(ip_tokens, interfaces)
+            find_dhcp!(ip_tokens, interfaces)
+          end
+
+          ::Resolvers::Utils::Networking.expand_main_bindings(interfaces)
+
+          @fact_list[:interfaces] = interfaces
+        end
+
+        def find_dhcp!(tokens, network_info)
+          interface_name = tokens[1]
+          return if !network_info[interface_name] || network_info[interface_name][:dhcp]
+
+          index = tokens[0].delete(':')
+          dhcp = Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
+          network_info[interface_name][:dhcp] = dhcp.match(/SERVER_ADDRESS=(.*)/)[1] if dhcp
+          network_info[interface_name][:dhcp] ||= retrieve_from_other_directories(interface_name)
+        end
+
+        def retrieve_from_other_directories(interface_name)
+          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 = Util::FileHelper.safe_read("#{dir}#{file}", nil)
+              next unless content =~ /interface.*#{interface_name}/
+
+              return content.match(/dhcp-server-identifier ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)[1]
+            end
+          end
+          return unless File.readable?('/var/lib/NetworkManager/')
+
+          search_internal_leases(interface_name)
+        end
+
+        def search_internal_leases(interface_name)
+          files = Dir.entries('/var/lib/NetworkManager/').reject { |dir| dir =~ /^\.+$/ }
+          lease_file = files.find { |file| file =~ /internal.*#{interface_name}\.lease/ }
+          return unless lease_file
+
+          dhcp = Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
+          dhcp ? dhcp.match(/SERVER_ADDRESS=(.*)/)[1] : nil
+        end
+
+        def fill_ip_v4_info!(ip_tokens, network_info)
+          return unless ip_tokens[2].casecmp('inet').zero?
+
+          interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens)
+
+          binding = ::Resolvers::Utils::Networking.build_binding(ip4_address, ip4_mask_length)
+          build_network_info_structure!(network_info, interface_name, :bindings)
+
+          network_info[interface_name][:bindings] << binding
+        end
+
+        def retrieve_name_and_ip_info(tokens)
+          interface_name = tokens[1]
+          ip_info = tokens[3].split('/')
+          ip_address = ip_info[0]
+          ip_mask_length = ip_info[1]
+
+          [interface_name, ip_address, ip_mask_length]
+        end
+
+        def fill_io_v6_info!(ip_tokens, network_info)
+          return unless ip_tokens[2].casecmp('inet6').zero?
+
+          interface_name, ip6_address, ip6_mask_length = retrieve_name_and_ip_info(ip_tokens)
+
+          binding = ::Resolvers::Utils::Networking.build_binding(ip6_address, ip6_mask_length)
+
+          build_network_info_structure!(network_info, interface_name, :bindings6)
+
+          network_info[interface_name][:scope6] ||= ip_tokens[5]
+          network_info[interface_name][:bindings6] << binding
+        end
+
+        def retrieve_default_interface
+          output = Facter::Core::Execution.execute('ip route get 1', logger: log)
+
+          ip_route_tokens = output.each_line.first.strip.split(' ')
+          default_interface = ip_route_tokens[4]
+
+          @fact_list[:primary_interface] = default_interface
+        end
+
+        def build_network_info_structure!(network_info, interface_name, binding)
+          network_info[interface_name] = {} unless network_info.dig(interface_name)
+          network_info[interface_name][binding] = [] unless network_info.dig(interface_name, binding)
+        end
+      end
+    end
+  end
+end