facter 4.0.23

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,163 @@
+# 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
+
+          @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 = build_binding(ip4_address, ip4_mask_length)
+          build_network_info_structure!(network_info, interface_name, 'bindings')
+
+          populate_other_ipv4_facts(network_info, interface_name, binding)
+        end
+
+        def populate_other_ipv4_facts(network_info, interface_name, binding)
+          network_info[interface_name]['bindings'] << binding
+          network_info[interface_name][:ip] ||= binding[:address]
+          network_info[interface_name][:network] ||= binding[:network]
+          network_info[interface_name][:netmask] ||= binding[:netmask]
+        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 = build_binding(ip6_address, ip6_mask_length)
+
+          build_network_info_structure!(network_info, interface_name, 'bindings6')
+
+          network_info[interface_name][:scope6] ||= ip_tokens[5]
+          populate_other_ipv6_facts(network_info, interface_name, binding)
+        end
+
+        def populate_other_ipv6_facts(network_info, interface_name, binding)
+          network_info[interface_name]['bindings6'] << binding
+          network_info[interface_name][:ip6] ||= binding[:address]
+          network_info[interface_name][:network6] ||= binding[:network]
+          network_info[interface_name][:netmask6] ||= binding[:netmask]
+        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_binding(addr, mask_length)
+          require 'ipaddr'
+
+          ip = IPAddr.new(addr)
+          mask_helper = ip.ipv6? ? 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' : '255.255.255.255'
+          mask = IPAddr.new(mask_helper).mask(mask_length)
+
+          { address: addr, netmask: mask.to_s, network: ip.mask(mask_length).to_s }
+        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

data/lib/resolvers/os_level_resolver.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OsLevel < BaseResolver
+      # build
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_oslevel(fact_name) }
+        end
+
+        def read_oslevel(fact_name)
+          output = Facter::Core::Execution.execute('/usr/bin/oslevel -s', logger: log)
+
+          @fact_list[:build] = output unless output.empty?
+          @fact_list[:kernel] = 'AIX'
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/os_release_resolver.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OsRelease < BaseResolver
+      # :pretty_name
+      # :name
+      # :version_id
+      # :version
+      # :id
+      # :id_like
+      # :ansi_color
+      # :home_url
+      # :support_url
+      # :bug_report_url
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_os_release_file(fact_name) }
+        end
+
+        def read_os_release_file(fact_name)
+          output = Util::FileHelper.safe_readlines('/etc/os-release')
+          return @fact_list[:name] = nil if output.empty?
+
+          pairs = []
+
+          output.each do |line|
+            pairs << line.strip.delete('"').split('=', 2)
+          end
+
+          fill_fact_list(pairs)
+          process_name
+          pad_version_id
+
+          @fact_list[fact_name]
+        end
+
+        def fill_fact_list(pairs)
+          result = Hash[*pairs.flatten]
+          result.each { |k, v| @fact_list[k.downcase.to_sym] = v }
+
+          @fact_list[:identifier] = @fact_list[:id]
+        end
+
+        def pad_version_id
+          @fact_list[:version_id] = "#{@fact_list[:version_id]}.0" unless @fact_list[:version_id] =~ /\./
+        end
+
+        def process_name
+          return unless @fact_list[:name]
+
+          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red')
+                                @fact_list[:name].split(' ')[0..1].join
+                              else
+                                @fact_list[:name].split(' ')[0].strip
+                              end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/partitions.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Partitions < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      BLOCK_PATH = '/sys/block'
+      BLOCK_SIZE = 512
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_partitions(fact_name) }
+        end
+
+        def read_partitions(fact_name)
+          @fact_list[:partitions] = {}
+          return {} unless File.readable?(BLOCK_PATH)
+
+          block_devices = Dir.entries(BLOCK_PATH).reject { |dir| dir =~ /^\.+/ }
+          block_devices.each do |block_device|
+            block_path = "#{BLOCK_PATH}/#{block_device}"
+            if File.directory?("#{block_path}/device")
+              extract_from_device(block_path)
+            elsif File.directory?("#{block_path}/dm")
+              extract_from_dm(block_path)
+            elsif File.directory?("#{block_path}/loop")
+              extract_from_loop(block_path)
+            end
+          end
+          @fact_list[fact_name]
+        end
+
+        def extract_from_device(block_path)
+          subdirs = browse_subdirectories(block_path)
+          subdirs.each do |subdir|
+            name = "/dev/#{subdir.split('/').last}"
+            populate_partitions(name, subdir)
+          end
+        end
+
+        def extract_from_dm(block_path)
+          map_name = Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
+          if map_name.empty?
+            populate_partitions("/dev#{block_path}", block_path)
+          else
+            populate_partitions("/dev/mapper/#{map_name}", block_path)
+          end
+        end
+
+        def extract_from_loop(block_path)
+          backing_file = Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
+          if backing_file.empty?
+            populate_partitions("/dev#{block_path}", block_path)
+          else
+            populate_partitions("/dev#{block_path}", block_path, backing_file)
+          end
+        end
+
+        def populate_partitions(partition_name, block_path, backing_file = nil)
+          @fact_list[:partitions][partition_name] = {}
+          size_bytes = Util::FileHelper.safe_read("#{block_path}/size", '0')
+                                       .chomp.to_i * BLOCK_SIZE
+          info_hash = { size_bytes: size_bytes,
+                        size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes),
+                        backing_file: backing_file }
+          info_hash.merge!(populate_from_blkid(partition_name))
+          @fact_list[:partitions][partition_name] = info_hash.reject { |_key, value| value.nil? }
+        end
+
+        def populate_from_blkid(partition_name)
+          return {} unless blkid_command?
+
+          @blkid_content ||= execute_and_extract_blkid_info
+          return {} unless @blkid_content[partition_name]
+
+          filesys = @blkid_content[partition_name]['TYPE']
+          uuid = @blkid_content[partition_name]['UUID']
+          label = @blkid_content[partition_name]['LABEL']
+          part_uuid = @blkid_content[partition_name]['PARTUUID']
+          part_label = @blkid_content[partition_name]['PARTLABEL']
+          { filesystem: filesys, uuid: uuid, label: label, partuuid: part_uuid, partlabel: part_label }
+        end
+
+        def blkid_command?
+          return @blkid_exists unless @blkid_exists.nil?
+
+          output = Facter::Core::Execution.execute('which blkid', logger: log)
+
+          @blkid_exists = !output.empty?
+        end
+
+        def execute_and_extract_blkid_info
+          stdout = Facter::Core::Execution.execute('blkid', logger: log)
+          output_hash = Hash[*stdout.split(/^([^:]+):/)[1..-1]]
+          output_hash.each do |key, value|
+            output_hash[key] = Hash[*value.delete('"').chomp.rstrip.split(/ ([^= ]+)=/)[1..-1]]
+          end
+        end
+
+        def browse_subdirectories(path)
+          dirs = Dir[File.join(path, '**', '*')].select { |p| File.directory? p }
+          dirs.select { |subdir| subdir.split('/').last.include?(path.split('/').last) }.reject(&:nil?)
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/path_resolver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Path < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_path_from_env }
+        end
+
+        def read_path_from_env
+          @fact_list[:path] = ENV['PATH']
+        end
+      end
+    end
+  end
+end