openfact 5.0.0.rc0

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Memory < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_meminfo_file(fact_name) }
+          end
+
+          def read_meminfo_file(fact_name)
+            meminfo_output = Facter::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] = memfree(output)
+            @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 memfree(output)
+            available = output.match(/MemAvailable:\s+(\d+)\s/)
+            return kilobytes_to_bytes(available[1]) if available
+
+            buffers = kilobytes_to_bytes(output.match(/Buffers:\s+(\d+)\s/)[1])
+            cached = kilobytes_to_bytes(output.match(/Cached:\s+(\d+)\s/)[1])
+            memfree = kilobytes_to_bytes(output.match(/MemFree:\s+(\d+)\s/)[1])
+            memfree + buffers + cached
+          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/facter/resolvers/linux/networking.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Networking < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
+
+            @fact_list[fact_name]
+          end
+
+          def retrieve_network_info(fact_name)
+            add_info_from_socket_reader
+            add_info_from_routing_table
+            retrieve_primary_interface
+            Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+            add_flags
+            @fact_list[fact_name]
+          end
+
+          def add_info_from_socket_reader
+            @fact_list[:interfaces] = Facter::Util::Linux::SocketParser.retrieve_interfaces(log)
+            mtu_and_indexes = interfaces_mtu_and_index
+
+            @fact_list[:interfaces].each_pair do |interface_name, iface|
+              mtu(interface_name, mtu_and_indexes, iface)
+              dhcp(interface_name, mtu_and_indexes, iface)
+              operstate(interface_name, iface)
+              physical(interface_name, iface)
+              linkspeed(interface_name, iface)
+              duplex(interface_name, iface)
+
+              @log.debug("Found interface #{interface_name} with #{@fact_list[:interfaces][interface_name]}")
+            end
+          end
+
+          def interfaces_mtu_and_index
+            mtu_and_indexes = {}
+            output = Facter::Core::Execution.execute('ip link show', logger: log)
+            output.each_line do |line|
+              next unless line.include?('mtu')
+
+              parse_ip_command_line(line, mtu_and_indexes)
+            end
+            mtu_and_indexes
+          end
+
+          def operstate(interface_name, iface)
+            state = Facter::Util::FileHelper.safe_read("/sys/class/net/#{interface_name}/operstate", nil)
+            iface[:operational_state] = state.strip if state
+          end
+
+          def physical(ifname, iface)
+            iface[:physical] = File.exist?("/sys/class/net/#{ifname}/device") || false
+          end
+
+          def duplex(interface_name, iface)
+            return unless iface[:physical]
+
+            # not all interfaces support this, wifi for example causes an EINVAL (Invalid argument)
+            begin
+              plex = Facter::Util::FileHelper.safe_read("/sys/class/net/#{interface_name}/duplex", nil)
+              iface[:duplex] = plex.strip if plex
+            rescue StandardError => e
+              @log.debug("Failed to read '/sys/class/net/#{interface_name}/duplex': #{e.message}")
+            end
+          end
+
+          def linkspeed(interface_name, iface)
+            return unless iface[:physical]
+
+            # not all interfaces support this, wifi for example causes an EINVAL (Invalid argument)
+            begin
+              speed = Facter::Util::FileHelper.safe_read("/sys/class/net/#{interface_name}/speed", nil)
+              iface[:speed] = speed.strip.to_i if speed
+            rescue StandardError => e
+              @log.debug("Failed to read '/sys/class/net/#{interface_name}/speed': #{e.message}")
+            end
+          end
+
+          def parse_ip_command_line(line, mtu_and_indexes)
+            mtu = line.match(/mtu (\d+)/)&.captures&.first&.to_i
+            index_tokens = line.split(':')
+            index = index_tokens[0].strip
+            # vlans are displayed as <vlan_name>@<physical_interface>
+            name = index_tokens[1].split('@').first.strip
+            mtu_and_indexes[name] = { index: index, mtu: mtu }
+          end
+
+          def mtu(interface_name, mtu_and_indexes, iface)
+            mtu = mtu_and_indexes.dig(interface_name, :mtu)
+            iface[:mtu] = mtu unless mtu.nil?
+          end
+
+          def dhcp(interface_name, mtu_and_indexes, iface)
+            dhcp = Facter::Util::Linux::Dhcp.dhcp(interface_name, mtu_and_indexes.dig(interface_name, :index), log)
+            iface[:dhcp] = dhcp unless dhcp.nil?
+          end
+
+          def add_info_from_routing_table
+            routes4, routes6 = Facter::Util::Linux::RoutingTable.read_routing_table(log)
+            compare_ips(routes4, :bindings)
+            compare_ips(routes6, :bindings6)
+          end
+
+          def add_flags
+            flags = Facter::Util::Linux::IfInet6.read_flags
+            flags.each_pair do |iface, ips|
+              next unless @fact_list[:interfaces].key?(iface)
+
+              ips.each_pair do |ip, ip_flags|
+                next unless @fact_list[:interfaces][iface].key?(:bindings6)
+
+                @fact_list[:interfaces][iface][:bindings6].each do |binding|
+                  next unless binding[:address] == ip
+
+                  binding[:flags] = ip_flags
+                end
+              end
+            end
+          end
+
+          def compare_ips(routes, binding_key)
+            routes.each do |route|
+              next unless @fact_list[:interfaces].key?(route[:interface])
+
+              interface_data = @fact_list[:interfaces][route[:interface]]
+              add_binding_if_missing(interface_data, binding_key, route)
+            end
+          end
+
+          def add_binding_if_missing(interface_data, binding_key, route)
+            interface_binding = interface_data[binding_key]
+
+            if interface_binding.nil?
+              interface_data[binding_key] = [{ address: route[:ip] }]
+            elsif interface_binding.none? { |binding| binding[:address] == route[:ip] }
+              interface_binding << { address: route[:ip] }
+            end
+          end
+
+          def retrieve_primary_interface
+            primary_helper = Facter::Util::Resolvers::Networking::PrimaryInterface
+            primary_interface = primary_helper.read_from_proc_route
+            primary_interface ||= primary_helper.read_from_ip_route
+            primary_interface ||= primary_helper.find_in_interfaces(@fact_list[:interfaces])
+
+            @fact_list[:primary_interface] = primary_interface
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Facter
+  module Resolvers
+    module Linux
+      class Processors < BaseResolver
+        init_resolver
+
+        MHZ_TO_HZ = 1_000_000
+
+        class << self
+          # :count
+          # :extensions
+          # :models
+          # :physical_count
+          # :speed
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_cpuinfo(fact_name) }
+          end
+
+          def read_cpuinfo(fact_name)
+            cpuinfo_output = Facter::Util::FileHelper.safe_readlines('/proc/cpuinfo')
+            return if cpuinfo_output.empty?
+
+            read_processors(cpuinfo_output) # + model names
+
+            @fact_list[:physical_count] = @fact_list[:physical_processors].uniq.length
+            @fact_list[:physical_count] = physical_devices_count if @fact_list[:physical_count].zero?
+            @fact_list[fact_name]
+          end
+
+          def read_processors(cpuinfo_output)
+            @fact_list[:extensions] = Set[Facter::Resolvers::Uname.resolve(:processor)]
+            @fact_list[:processors] = 0
+            @fact_list[:models] = []
+            @fact_list[:physical_processors] = []
+            cpuinfo_output.each do |line|
+              tokens = line.split(':')
+              count_processors(tokens)
+              construct_models_list(tokens)
+              count_physical_processors(tokens)
+              build_speed(tokens)
+              check_extensions(tokens)
+            end
+            @fact_list[:extensions] = @fact_list[:extensions].to_a
+            @fact_list[:extensions].sort!
+          end
+
+          def count_processors(tokens)
+            @fact_list[:processors] += 1 if tokens.first.strip == 'processor'
+          end
+
+          def construct_models_list(tokens)
+            return unless ['model name', 'cpu'].include?(tokens.first.strip)
+
+            @fact_list[:models] << tokens.last.strip
+          end
+
+          def count_physical_processors(tokens)
+            @fact_list[:physical_processors] << tokens.last.strip.to_i if tokens.first.strip == 'physical id'
+          end
+
+          def physical_devices_count
+            Dir.entries('/sys/devices/system/cpu')
+               .select { |dir| dir =~ /cpu[0-9]+$/ }
+               .select { |dir| File.exist?("/sys/devices/system/cpu/#{dir}/topology/physical_package_id") }
+               .map do |dir|
+              Facter::Util::FileHelper.safe_read("/sys/devices/system/cpu/#{dir}/topology/physical_package_id").strip
+            end
+               .uniq.count
+          end
+
+          def build_speed(tokens)
+            build_speed_for_power_pc(tokens) if tokens.first.strip == 'clock'
+            build_speed_for_x86(tokens) if tokens.first.strip == 'cpu MHz'
+          end
+
+          def build_speed_for_power_pc(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*MHz/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
+          end
+
+          def build_speed_for_x86(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
+          end
+
+          def check_extensions(tokens)
+            return unless tokens.first.strip == 'flags'
+
+            flags = tokens.last.split(' ')
+
+            # TODO: As we gain support for other arches, change the guard
+            # so we only check the flags for the corosponding arches
+            return unless @fact_list[:extensions].include?('x86_64')
+
+            @fact_list[:extensions].add('x86_64-v1') if (%w[cmov cx8 fpu fxsr lm mmx syscall sse2] - flags).empty?
+            @fact_list[:extensions].add('x86_64-v2') if (%w[cx16 lahf_lm popcnt sse4_1 sse4_2 ssse3] - flags).empty?
+            @fact_list[:extensions].add('x86_64-v3') if (%w[abm avx avx2 bmi1 bmi2 f16c fma movbe xsave] - flags).empty?
+            @fact_list[:extensions].add('x86_64-v4') if (%w[avx512f avx512bw avx512cd avx512dq avx512vl] - flags).empty?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Lscpu < BaseResolver
+        init_resolver
+
+        ITEMS = { threads_per_core: "-e 'Thread(s)'",
+                  cores_per_socket: "-e 'Core(s)'" }.freeze
+
+        class << self
+          # :cores_per_socket
+          # :threads_per_core
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_cpuinfo(fact_name) }
+          end
+
+          def read_cpuinfo(fact_name)
+            lscpu_output = Facter::Core::Execution.execute("lscpu | grep #{ITEMS.values.join(' ')}", logger: log)
+            build_fact_list(lscpu_output.split("\n"))
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(processors_data)
+            build_threads_per_core(processors_data[0])
+            build_cores_per_socket(processors_data[1])
+          end
+
+          def build_threads_per_core(index)
+            @fact_list[:threads_per_core] = index.split(': ')[1].to_i
+          end
+
+          def build_cores_per_socket(index)
+            @fact_list[:cores_per_socket] = index.split(': ')[1].to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/load_averages.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class LoadAverages < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
+        end
+
+        def read_load_averages(fact_name)
+          require_relative '../../facter/util/resolvers/ffi/load_averages'
+
+          log.debug('loading cpu load averages')
+          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Facter::Util::Resolvers::Ffi::LoadAverages
+            .read_load_averages).to_h
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/lpar.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Lpar < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_lpar(fact_name) }
+        end
+
+        def read_lpar(fact_name)
+          output = Facter::Core::Execution.execute('/usr/bin/lparstat -i', logger: log)
+          output.each_line do |line|
+            populate_lpar_data(line.split(':').map(&:strip))
+          end
+          @fact_list[fact_name]
+        end
+
+        def populate_lpar_data(key_value)
+          @fact_list[:lpar_partition_name]   = key_value[1]      if key_value[0] == 'Partition Name'
+          @fact_list[:lpar_partition_number] = key_value[1].to_i if key_value[0] == 'Partition Number'
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/lsb_release.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class LsbRelease < BaseResolver
+      # :lsb_version
+      # :distributor_id
+      # :description
+      # :release
+      # :codename
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
+        end
+
+        def retrieve_facts(fact_name)
+          lsb_release_installed? if @fact_list[:lsb_release_installed].nil?
+          read_lsb_release_file if @fact_list[:lsb_release_installed]
+          @fact_list[fact_name]
+        end
+
+        def lsb_release_installed?
+          @fact_list[:lsb_release_installed] = !Facter::Core::Execution.which('lsb_release').nil?
+        end
+
+        def read_lsb_release_file
+          output = Facter::Core::Execution.execute('lsb_release -a', logger: log)
+          build_fact_list(output)
+        end
+
+        def build_fact_list(info)
+          release_info = info.delete("\t").split("\n").map { |e| e.split(':', 2) }
+
+          result = Hash[*release_info.flatten]
+          result.each { |k, v| @fact_list[k.downcase.gsub(/\s/, '_').to_sym] = v }
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/lspci.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Lspci < BaseResolver
+      init_resolver
+
+      REGEX_VALUES = { 'VirtualBox' => 'virtualbox', 'XenSource' => 'xenhvm',
+                       'Microsoft Corporation Hyper-V' => 'hyperv', 'Class 8007: Google, Inc' => 'gce',
+                       'VM[wW]are' => 'vmware', '1ab8:' => 'parallels', '[Pp]arallels' => 'parallels',
+                       '(?i)(virtio)' => 'kvm' }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { lspci_command(fact_name) }
+        end
+
+        def lspci_command(fact_name)
+          output = Facter::Core::Execution.execute('lspci', logger: log)
+          return if output.empty?
+
+          @fact_list[:vm] = retrieve_vm(output)
+          @fact_list[fact_name]
+        end
+
+        def retrieve_vm(output)
+          output.each_line { |line| REGEX_VALUES.each { |key, value| return value if /#{key}/.match?(line) } }
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class DmiBios < BaseResolver
+        init_resolver
+
+        class << self
+          # :model
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts }
+          end
+
+          def read_facts
+            # OSX only supports the product name
+            output = Facter::Core::Execution.execute('sysctl -n hw.model', logger: log)
+            @fact_list[:macosx_model] = output&.strip
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class Filesystems < BaseResolver
+        # :macosx_filesystems
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_filesystems(fact_name) }
+          end
+
+          def read_filesystems(fact_name)
+            output = Facter::Core::Execution.execute('mount', logger: log)
+            filesystems = output.scan(/\(([a-z]+),*/).flatten
+            @fact_list[:macosx_filesystems] = filesystems.uniq.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class LoadAverages < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_load_averages_file(fact_name) }
+          end
+
+          def read_load_averages_file(fact_name)
+            output = Facter::Core::Execution.execute('sysctl -n vm.loadavg', logger: log)
+            @fact_list[:load_averages] = {}.tap { |h| _, h['1m'], h['5m'], h['15m'], = output.split.map(&:to_f) }
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      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 }
+          end
+
+          def read_mounts
+            mounts = {}
+            begin
+              Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
+                device = fs.name
+                filesystem = fs.mount_type
+                path = fs.mount_point
+                options = read_options(fs.options)
+
+                mounts[path] = read_stats(path).tap do |hash|
+                  hash[:device] = device
+                  hash[:filesystem] = filesystem
+                  hash[:options] = options if options.any?
+                end
+              end
+            rescue LoadError => e
+              @log.debug("Could not read mounts: #{e}")
+            end
+
+            @fact_list[:mountpoints] = mounts
+          end
+
+          def read_stats(path)
+            begin
+              stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(path)
+              size_bytes = stats.bytes_total
+              available_bytes = stats.bytes_available
+              used_bytes = size_bytes - available_bytes
+            rescue Sys::Filesystem::Error, LoadError
+              size_bytes = used_bytes = available_bytes = 0
+            end
+
+            {
+              size_bytes: size_bytes,
+              used_bytes: used_bytes,
+              available_bytes: available_bytes,
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, size_bytes),
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes),
+              available: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes),
+              used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
+            }
+          end
+
+          def read_options(options)
+            options_map = {
+              'read-only' => 'readonly',
+              'asynchronous' => 'async',
+              'synchronous' => 'noasync',
+              'quotas' => 'quota',
+              'rootfs' => 'root',
+              'defwrite' => 'deferwrites'
+            }
+
+            options.split(',').map(&:strip).map { |o| options_map.key?(o) ? options_map[o] : o }
+          end
+        end
+      end
+    end
+  end
+end