openfact 5.0.0.rc0

data/lib/facter/resolvers/macosx/processors.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class Processors < BaseResolver
+        init_resolver
+
+        ITEMS = { logical_count: 'hw.logicalcpu_max',
+                  physical_count: 'hw.physicalcpu_max',
+                  brand: 'machdep.cpu.brand_string',
+                  speed: 'hw.cpufrequency_max',
+                  cores_per_socket: 'machdep.cpu.core_count',
+                  threads_per_core: 'machdep.cpu.thread_count' }.freeze
+
+        class << self
+          # :logicalcount
+          # :models
+          # :physicalcount
+          # :speed
+          # :cores_per_socket
+          # :threads_per_core
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @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)
+            processors_hash = Hash[*output.split("\n").collect { |v| [v.split(': ')[0], v.split(': ')[1]] }.flatten]
+            build_fact_list(processors_hash)
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(hash)
+            build_logical_count(hash)
+            build_physical_count(hash)
+            build_models(hash)
+            build_speed(hash)
+            build_cores_per_socket(hash)
+            build_threads_per_core(hash)
+          end
+
+          def build_logical_count(hash)
+            @fact_list[:logicalcount] = hash[ITEMS[:logical_count]].to_i
+          end
+
+          def build_physical_count(hash)
+            @fact_list[:physicalcount] = hash[ITEMS[:physical_count]].to_i
+          end
+
+          def build_models(hash)
+            @fact_list[:models] = Array.new(@fact_list[:logicalcount].to_i, hash[ITEMS[:brand]])
+          end
+
+          def build_speed(hash)
+            @fact_list[:speed] = hash[ITEMS[:speed]].to_i
+          end
+
+          def build_cores_per_socket(hash)
+            @fact_list[:cores_per_socket] = hash[ITEMS[:cores_per_socket]].to_i
+          end
+
+          def build_threads_per_core(hash)
+            @fact_list[:threads_per_core] = hash[ITEMS[:threads_per_core]].to_i / hash[ITEMS[:cores_per_socket]].to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/macosx/swap_memory.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class SwapMemory < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_swap_memory(fact_name) }
+          end
+
+          def read_swap_memory(fact_name)
+            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/facter/resolvers/macosx/system_memory.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class SystemMemory < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @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/facter/resolvers/macosx/system_profiler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class SystemProfiler < BaseResolver
+        SP_HARDWARE_DATA_TYPE = %i[model_name model_identifier processor_speed number_of_processors processor_name
+                                   total_number_of_cores l2_cache_per_core l3_cache memory boot_rom_version
+                                   smc_version_system serial_number_system hardware_uuid hyper-threading_technology
+                                   activation_lock_status].freeze
+
+        SP_SOFTWARE_DATA_TYPE = %i[system_version kernel_version boot_volume boot_mode computer_name
+                                   user_name secure_virtual_memory system_integrity_protection time_since_boot].freeze
+
+        SP_ETHERNET_DATA_TYPE = %i[type bus vendor_id device_id subsystem_vendor_id
+                                   subsystem_id revision_id bsd_name kext_name location version].freeze
+
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { retrieve_system_profiler(fact_name) }
+          end
+
+          def retrieve_system_profiler(fact_name)
+            case fact_name
+            when *SP_HARDWARE_DATA_TYPE
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPHardwareDataType'))
+            when *SP_SOFTWARE_DATA_TYPE
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPSoftwareDataType'))
+            when *SP_ETHERNET_DATA_TYPE
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPEthernetDataType'))
+            end
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/mountpoints.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Mountpoints < BaseResolver
+      include Facter::Util::Resolvers::FilesystemHelper
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_mounts(fact_name) }
+        end
+
+        def root_device
+          cmdline = Facter::Util::FileHelper.safe_read('/proc/cmdline')
+          match = cmdline.match(/root=([^\s]+)/)
+          root = match&.captures&.first
+
+          if !root.nil? && root.include?('=')
+            # We are dealing with the PARTUUID of the partition. Need to extract partition path.
+            root_partition_path = convert_partuuid_to_path(root)
+            root = root_partition_path unless root_partition_path.nil?
+          end
+          root
+        end
+
+        def convert_partuuid_to_path(root)
+          blkid_content = Facter::Core::Execution.execute('blkid', logger: log)
+          partuuid = root.split('=').last
+          match = blkid_content.match(/(.+)#{partuuid}/)
+          match&.captures&.first&.split(':')&.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(fact_name)
+          mounts = []
+          begin
+            Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |file_system|
+              mount = {}
+              get_mount_data(file_system, mount)
+
+              if mount[:path] =~ %r{^/(proc|sys)} && mount[:filesystem] != 'tmpfs' || mount[:filesystem] == 'autofs'
+                next
+              end
+
+              get_mount_sizes(mount)
+              mounts << mount
+            end
+          rescue LoadError => e
+            @log.debug("Could not read mounts: #{e}")
+          end
+
+          @fact_list[:mountpoints] = mounts
+          @fact_list[fact_name]
+        end
+
+        def get_mount_data(file_system, mount)
+          mount[:device] = compute_device(file_system.name)
+          mount[:filesystem] = file_system.mount_type
+          mount[:path] = file_system.mount_point
+          mount[:options] = file_system.options.split(',').map(&:strip)
+        end
+
+        def get_mount_sizes(mount)
+          begin
+            stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(mount[:path])
+            get_bytes_data(mount, stats)
+          rescue LoadError, Sys::Filesystem::Error => e
+            @log.debug("Could not get stats for mountpoint #{mount[:path]}, got #{e}")
+            mount[:size_bytes] = mount[:available_bytes] = mount[:used_bytes] = 0
+          end
+
+          populate_mount(mount)
+        end
+
+        def get_bytes_data(mount, stats)
+          mount[:size_bytes] = stats.bytes_total.abs
+          mount[:available_bytes] = stats.bytes_available.abs
+          mount[:used_bytes] = stats.bytes_used.abs
+        end
+
+        def populate_mount(mount)
+          total_bytes = mount[:used_bytes] + mount[:available_bytes]
+          mount[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(mount[:used_bytes], total_bytes)
+
+          mount[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:size_bytes])
+          mount[:available] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:available_bytes])
+          mount[:used] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:used_bytes])
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/networking.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Networking < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          interfaces_data
+          primary_interface
+          Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+          @fact_list[fact_name]
+        end
+
+        def primary_interface
+          primary_helper = Facter::Util::Resolvers::Networking::PrimaryInterface
+          primary_interface ||= primary_helper.read_from_route
+
+          primary_interface ||= primary_helper.find_in_interfaces(@fact_list[:interfaces])
+
+          @fact_list[:primary_interface] = primary_interface
+        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
+          # convert ip6 ranges into single ip. eg. 2001:db8:cafe::132:213 -->
+          # 2001:db8:cafe::132:213 is converted to 2001:db8:cafe::132:213
+          response.gsub!(/([\da-fA-F]+([.:]+[\da-fA-F]+)*)\s+-->\s+[\da-fA-F]+([.:]+[\da-fA-F]+)*/, '\\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:){5}\w?\w)|(?:infiniband)\s+((?:\w?\w:){19}\w?\w)/)
+                        &.captures&.compact&.first
+          parsed_interface_data[:mac] = mac unless mac.nil?
+        end
+
+        def extract_dhcp(interface_name, raw_data, parsed_interface_data)
+          return unless /status:\s+active/.match?(raw_data)
+
+          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 << Facter::Util::Resolvers::Networking.build_binding(ip, mask)
+          end
+          bindings
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/open_vz.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OpenVz < BaseResolver
+      # build
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { check_proc_vz(fact_name) }
+        end
+
+        def check_proc_vz(fact_name)
+          return if !Dir.exist?('/proc/vz') || File.file?('/proc/lve/list') || Dir.entries('/proc/vz').count.equal?(2)
+
+          @fact_list[:vm] = read_proc_status
+          @fact_list[fact_name]
+        end
+
+        def read_proc_status
+          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 /^envID:/.match?(parts[0])
+
+            @fact_list[:id] = parts[1]
+
+            return 'openvzhn' if parts[1] == '0'
+
+            return 'openvzve'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/openbsd/dhcp.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../networking'
+
+module Facter
+  module Resolvers
+    module Openbsd
+      class Dhcp < Facter::Resolvers::Networking
+        init_resolver
+        class << self
+          def extract_dhcp(interface_name, raw_data, parsed_interface_data)
+            return unless raw_data.match?(/status:\s+active/)
+
+            result = Facter::Core::Execution.execute("dhcpleasectl -l #{interface_name}", logger: log)
+            parsed_interface_data[:dhcp] = extract_values(result, /\sdhcp server (\S+)/).first unless result.empty?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Openbsd
+      class DmiBios < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          CTL_HW = 6
+          HW_VENDOR = 14
+          HW_PRODUCT = 15
+          HW_VERSION = 16
+          HW_SERIALNO = 17
+          HW_UUID = 18
+
+          def read_facts(fact_name)
+            require 'facter/resolvers/bsd/ffi/ffi_helper'
+
+            @fact_list[:bios_vendor]  = Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_VENDOR])
+            @fact_list[:bios_version] = Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_VERSION])
+
+            @fact_list[:product_name]   = Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_PRODUCT])
+            @fact_list[:product_serial] = Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_SERIALNO])
+            @fact_list[:product_uuid]   = Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_UUID])
+
+            @fact_list[:sys_vendor] = Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_VENDOR])
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/openbsd/mountpoints.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Openbsd
+      class Mountpoints < BaseResolver
+        init_resolver
+
+        BLOCK_SIZE = 512
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_mount(fact_name) }
+          end
+
+          def read_mount(fact_name)
+            @fact_list[:mountpoints] = {}
+            output = Facter::Core::Execution.execute('mount', logger: log)
+            output.split("\n").map do |line|
+              add_mount_points_fact(line)
+            end
+
+            retrieve_sizes_for_mounts
+            @fact_list[fact_name]
+          end
+
+          def add_mount_points_fact(line)
+            elem = line.split("\s")
+            options = elem.drop(5)
+            options.each { |option| option.tr!('(),', '') }
+            @fact_list[:mountpoints][elem[2]] = { device: elem[0], filesystem: elem[4],
+                                                  options: options }
+          end
+
+          def retrieve_sizes_for_mounts
+            output = Facter::Core::Execution.execute('df -P', logger: log)
+            output.split("\n").drop(1).map do |line|
+              next if line.match?(/-\s+-\s+-/)
+
+              mount_info = line.split("\s")
+              mount_info[3] = translate_to_bytes(mount_info[3])
+              mount_info[2] = translate_to_bytes(mount_info[2])
+              mount_info[1] = translate_to_bytes(mount_info[1])
+              compute_sizes(mount_info)
+            end
+          end
+
+          def translate_to_bytes(strin_size)
+            strin_size.to_i * BLOCK_SIZE
+          end
+
+          def compute_sizes(info)
+            available_bytes = info[3]
+            used_bytes = info[2]
+            size_bytes = info[1]
+            @fact_list[:mountpoints][info.last].merge!(
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, size_bytes),
+              available_bytes: available_bytes,
+              used_bytes: used_bytes,
+              size_bytes: size_bytes,
+              available: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes),
+              used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes),
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/openbsd/virtual.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Openbsd
+      class Virtual < BaseResolver
+        init_resolver
+
+        class << self
+          # :model
+
+          VM_GUEST_SYSCTL_NAMES = {
+            'VMM' => 'vmm',
+            'vServer' => 'vserver',
+            'oracle' => 'virtualbox',
+            'xen' => 'xenu',
+            'none' => nil
+          }.freeze
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          CTL_HW = 6
+          HW_PRODUCT = 15
+
+          def read_facts(fact_name)
+            require 'facter/resolvers/bsd/ffi/ffi_helper'
+
+            vm = Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_PRODUCT])
+            vm = if VM_GUEST_SYSCTL_NAMES.key?(vm)
+                   VM_GUEST_SYSCTL_NAMES[vm]
+                 else
+                   'physical'
+                 end
+            @fact_list[:vm] = vm
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end