openfact 5.0.0.rc0

data/lib/facter/resolvers/gce.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Gce < BaseResolver
+      init_resolver
+
+      METADATA_URL = 'http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=json'
+      HEADERS = { "Metadata-Flavor": 'Google', "Accept": 'application/json' }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          log.debug('reading Gce metadata')
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = query_for_metadata
+          @fact_list[fact_name]
+        end
+
+        def query_for_metadata
+          gce_data = extract_to_hash(Facter::Util::Resolvers::Http.get_request(METADATA_URL, HEADERS, {}, false))
+          parse_instance(gce_data)
+
+          gce_data.empty? ? nil : gce_data
+        end
+
+        def extract_to_hash(metadata)
+          JSON.parse(metadata)
+        rescue JSON::ParserError => e
+          log.debug("Trying to parse result but got: #{e.message}")
+          {}
+        end
+
+        def parse_instance(gce_data)
+          instance_data = gce_data['instance']
+          return if instance_data.nil? || instance_data.empty?
+
+          # See https://cloud.google.com/compute/docs/metadata for information about these values
+          %w[sshKeys ssh-keys].each do |name|
+            keys = gce_data.dig('project', 'attributes', name)
+            gce_data['project']['attributes'][name] = keys.strip.split("\n") if keys
+
+            keys = instance_data.dig('attributes', name)
+            instance_data['attributes'][name] = keys.strip.split("\n") if keys
+          end
+
+          %w[image machineType zone].each do |key|
+            instance_data[key] = instance_data[key].split('/').last if instance_data[key]
+          end
+
+          network = instance_data.dig('networkInterfaces', 0, 'network')
+          instance_data['networkInterfaces'][0]['network'] = network.split('/').last unless network.nil?
+
+          gce_data['instance'] = instance_data
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/hostname.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Hostname < BaseResolver
+      # :fqdn
+      # :domain
+      # :hostname
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+        end
+
+        def retrieve_info(fact_name)
+          require 'socket'
+          output = Socket.gethostname
+          unless output
+            log.debug('Socket.gethostname failed to return hostname')
+            return
+          end
+
+          hostname, domain = retrieve_from_fqdn(output)
+
+          fqdn = retrieve_with_addrinfo(hostname) if hostname_and_no_domain?(hostname, domain)
+
+          _, domain = retrieve_from_fqdn(fqdn) if exists_and_valid_fqdn?(fqdn, hostname)
+
+          domain = read_domain unless exists_and_not_empty?(domain)
+
+          construct_fact_list(hostname, domain, fqdn)
+          @fact_list[fact_name]
+        end
+
+        def retrieve_from_fqdn(output)
+          if output =~ /(.*?)\.(.+$)/
+            log.debug("Managed to read hostname: #{Regexp.last_match(1)} and domain: #{Regexp.last_match(2)}")
+            [Regexp.last_match(1), Regexp.last_match(2)]
+          else
+            log.debug("Only managed to read hostname: #{output}, no domain was found.")
+            [output, '']
+          end
+        end
+
+        def retrieve_with_addrinfo(host)
+          begin
+            name = Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)[0]
+          rescue StandardError => e
+            @log.debug("Socket.getaddrinfo failed to retrieve fqdn for hostname #{host} with: #{e}")
+            return
+          end
+          return if name.nil? || name.empty? || host == name[2] || name[2] == name[3]
+
+          name[2]
+        end
+
+        def exists_and_valid_fqdn?(fqdn, hostname)
+          exists_and_not_empty?(fqdn) && fqdn.start_with?("#{hostname}.")
+        end
+
+        def hostname_and_no_domain?(hostname, domain)
+          domain.empty? && !hostname.empty?
+        end
+
+        def read_domain
+          file_content = Facter::Util::FileHelper.safe_read('/etc/resolv.conf')
+          if file_content =~ /^domain\s+([^.]\S+)/
+            Regexp.last_match(1)
+          elsif file_content =~ /^search\s+([^.]\S+)/
+            Regexp.last_match(1)
+          end
+        end
+
+        def construct_fqdn(host, domain, fqdn)
+          return fqdn if exists_and_not_empty?(fqdn)
+          return if host.nil? || host.empty?
+
+          exists_and_not_empty?(domain) ? "#{host}.#{domain}" : host
+        end
+
+        def construct_fact_list(hostname, domain, fqdn)
+          @fact_list[:hostname] = hostname
+          @fact_list[:domain] = domain
+          @fact_list[:fqdn] = construct_fqdn(@fact_list[:hostname], @fact_list[:domain], fqdn)
+        end
+
+        def exists_and_not_empty?(variable)
+          variable && !variable.empty?
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/identity.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class PosxIdentity < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_identity(fact_name) }
+        end
+
+        def retrieve_identity(fact_name)
+          require 'etc'
+
+          login_info = Etc.getpwuid
+          @fact_list[:gid] = login_info.gid
+          @fact_list[:group] = Etc.getgrgid(login_info.gid).name
+          @fact_list[:privileged] = login_info.uid.zero?
+          @fact_list[:uid] = login_info.uid
+          @fact_list[:user] = login_info.name
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Containers < BaseResolver
+        # :virtual
+        # :hypervisor
+
+        init_resolver
+
+        INFO = { 'docker' => 'id', 'lxc' => 'name' }.freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) do
+              read_environ(fact_name) || read_cgroup(fact_name)
+            end
+          end
+
+          def read_cgroup(fact_name)
+            output_cgroup = Facter::Util::FileHelper.safe_read('/proc/1/cgroup', nil)
+            return unless output_cgroup
+
+            output_docker = %r{docker/(.+)}.match(output_cgroup)
+            output_lxc = %r{^/lxc/([^/]+)}.match(output_cgroup)
+
+            info, vm = extract_vm_and_info(output_docker, output_lxc)
+            @fact_list[:vm] = vm
+            @fact_list[:hypervisor] = { vm.to_sym => info } if vm
+            @fact_list[fact_name]
+          end
+
+          def read_environ(fact_name)
+            begin
+              container = Facter::Util::Linux::Proc.getenv_for_pid(1, 'container')
+            rescue StandardError => e
+              log.warn("Unable to getenv for pid 1, '#{e}'")
+              return nil
+            end
+            return if container.nil? || container.empty?
+
+            info = {}
+            case container
+            when 'lxc'
+              vm = 'lxc'
+            when 'lxc-virtwhat'
+              vm = 'lxc-virtwhat'
+            when 'podman'
+              vm = 'podman'
+            when 'crio'
+              vm = 'crio'
+            when 'zone'
+              return nil
+            when 'systemd-nspawn'
+              vm = 'systemd_nspawn'
+              info = { 'id' => Facter::Util::FileHelper.safe_read('/etc/machine-id', nil).strip }
+            else
+              vm = 'container_other'
+              log.warn("Container runtime, '#{container}', is unsupported, setting to '#{vm}'")
+            end
+            @fact_list[:vm] = vm
+            @fact_list[:hypervisor] = { vm.to_sym => info } if vm
+            @fact_list[fact_name]
+          end
+
+          def extract_vm_and_info(output_docker, output_lxc)
+            vm = nil
+            if output_docker
+              vm = 'docker'
+              info = output_docker[1]
+            elsif output_lxc
+              vm = 'lxc'
+              info = output_lxc[1]
+            end
+
+            [info ? { INFO[vm] => info } : {}, vm]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Disks < BaseResolver
+        init_resolver
+
+        DIR = '/sys/block'
+        FILE_PATHS = { model: 'device/model',
+                       size: 'size',
+                       vendor: 'device/vendor',
+                       type: 'queue/rotational',
+                       serial: 'false',
+                       wwn: 'false' }.freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) do
+              return unless @fact_list.empty?
+
+              build_disks_hash
+
+              read_facts
+
+              @fact_list[:disks] = nil if @fact_list[:disks].empty?
+              @fact_list[fact_name]
+            end
+          end
+
+          def lsblk(option, disk)
+            result = Facter::Core::Execution.execute(
+              "lsblk -dn -o #{option} /dev/#{disk}", on_fail: '', timeout: 1
+            ).strip
+            result.empty? ? nil : result
+          end
+
+          def read_facts
+            FILE_PATHS.each do |key, file|
+              @fact_list[:disks].each do |disk, value|
+                file_path = File.join(DIR, disk, file)
+
+                result = if file == 'false'
+                           lsblk(key, disk)
+                         else
+                           Facter::Util::FileHelper.safe_read(file_path, nil)&.strip
+                         end
+
+                next unless result
+
+                value[key] = case key
+                             when :size
+                               # Linux always considers sectors to be 512 bytes long
+                               # independently of the devices real block size.
+                               construct_size(value, result)
+                             when :type
+                               result == '0' ? 'ssd' : 'hdd'
+                             else
+                               result
+                             end
+              end
+            end
+          end
+
+          def build_disks_hash
+            valid_disks = Facter::Util::FileHelper.dir_children(DIR)
+                                                  .select { |disk| File.readable?(File.join(DIR, disk, 'device')) }
+
+            @fact_list[:disks] = {}
+            valid_disks.each { |disk| @fact_list[:disks][disk] = {} }
+          end
+
+          def construct_size(facts, value)
+            value = value.to_i * 512
+            facts[:size_bytes] = value
+            facts[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class DmiBios < BaseResolver
+        init_resolver
+
+        class << self
+          # :bios_vendor
+          # :bios_date
+          # :bios_version
+          # :board_asset_tag
+          # :board_vendor
+          # :board_serial
+          # :board_name
+          # :chassis_asset_tag
+          # :chassis_type
+          # :sys_vendor
+          # :product_serial
+          # :product_name
+          # :product_uuid
+          # :product_version
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            files = %w[bios_date bios_vendor bios_version board_asset_tag board_vendor board_name
+                       board_serial chassis_asset_tag chassis_type sys_vendor product_name
+                       product_serial product_uuid product_version]
+            return unless File.directory?('/sys/class/dmi')
+
+            file_content = Facter::Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
+            file_content = file_content.encode('UTF-8', invalid: :replace) if file_content
+            if files.include?(fact_name.to_s) && file_content
+              file_content = file_content.strip
+              @fact_list[fact_name] = file_content unless file_content.empty?
+              chassis_to_name(@fact_list[fact_name]) if fact_name == :chassis_type
+            end
+            @fact_list[fact_name]
+          end
+
+          def chassis_to_name(chassis_type)
+            types = ['Other', nil, 'Desktop', 'Low Profile Desktop', 'Pizza Box', 'Mini Tower', 'Tower',
+                     'Portable', 'Laptop', 'Notebook', 'Hand Held', 'Docking Station', 'All in One', 'Sub Notebook',
+                     'Space-Saving', 'Lunch Box', 'Main System Chassis', 'Expansion Chassis', 'SubChassis',
+                     'Bus Expansion Chassis', 'Peripheral Chassis', 'Storage Chassis', 'Rack Mount Chassis',
+                     'Sealed-Case PC', 'Multi-system', 'CompactPCI', 'AdvancedTCA', 'Blade', 'Blade Enclosure',
+                     'Tablet', 'Convertible', 'Detachable']
+            @fact_list[:chassis_type] = types[chassis_type.to_i - 1]
+          end
+        end
+      end
+    end
+  end
+end

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
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @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 =  Facter::Util::Resolvers::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/linux/filesystems.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Filesystems < BaseResolver
+        # :systems
+
+        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::Util::FileHelper.safe_readlines('/proc/filesystems', nil)
+            return unless output
+
+            filesystems = []
+            output.each do |line|
+              tokens = line.split(' ')
+              filesystems << tokens if tokens.size == 1 && tokens.first != 'fuseblk'
+            end
+            @fact_list[:systems] = filesystems.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class FipsEnabled < BaseResolver
+        # :fips_enabled
+
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_fips_file(fact_name) }
+          end
+
+          def read_fips_file(fact_name)
+            file_output = Facter::Util::FileHelper.safe_read('/proc/sys/crypto/fips_enabled')
+            @fact_list[:fips_enabled] = file_output.strip == '1'
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Hostname < BaseResolver
+        # :fqdn
+        # :domain
+        # :hostname
+
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+          end
+
+          def retrieve_info(fact_name)
+            require 'socket'
+
+            output = retrieving_hostname
+            return nil unless output
+
+            # Check if the gethostname method retrieved fqdn
+            hostname, domain = parse_fqdn(output)
+
+            fqdn = retrieve_fqdn_for_host(hostname) if hostname_and_no_domain?(hostname, domain)
+
+            _, domain = parse_fqdn(fqdn) if exists_and_valid_fqdn?(fqdn, hostname)
+
+            domain = read_domain unless exists_and_not_empty?(domain)
+
+            construct_fact_list(hostname, domain, fqdn)
+            @fact_list[fact_name]
+          end
+
+          def retrieving_hostname
+            output = Socket.gethostname || ''
+            if output.empty? || output['0.0.0.0']
+              begin
+                require_relative '../../../facter/util/resolvers/ffi/hostname'
+
+                output = Facter::Util::Resolvers::Ffi::Hostname.getffihostname
+              rescue LoadError => e
+                log.debug(e.message)
+                output = nil
+              end
+            end
+
+            log.debug("Tried to retrieve hostname and got: #{output}")
+            output unless output&.empty?
+          end
+
+          def parse_fqdn(output)
+            if output =~ /(.*?)\.(.+$)/
+              log.debug("Managed to read hostname: #{Regexp.last_match(1)} and domain: #{Regexp.last_match(2)}")
+              [Regexp.last_match(1), Regexp.last_match(2)]
+            else
+              log.debug("Only managed to read hostname: #{output}, no domain was found.")
+              [output, '']
+            end
+          end
+
+          def retrieve_fqdn_for_host(host)
+            begin
+              name = Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)[0]
+            rescue StandardError => e
+              log.debug("Socket.getaddrinfo failed to retrieve fqdn for hostname #{host} with: #{e}")
+            end
+
+            return name[2] if !name.nil? && !name.empty? && host != name[2] && name[2] != name[3]
+
+            retrieve_fqdn_for_host_with_ffi(host)
+          end
+
+          def retrieve_fqdn_for_host_with_ffi(host)
+            require_relative '../../../facter/util/resolvers/ffi/hostname'
+
+            fqdn = Facter::Util::Resolvers::Ffi::Hostname.getffiaddrinfo(host)
+            log.debug("FFI getaddrinfo was called and it retrieved: #{fqdn}")
+            fqdn
+          rescue LoadError => e
+            log.debug(e.message)
+            nil
+          end
+
+          def exists_and_valid_fqdn?(fqdn, hostname)
+            exists_and_not_empty?(fqdn) && fqdn.start_with?("#{hostname}.")
+          end
+
+          def hostname_and_no_domain?(hostname, domain)
+            domain.empty? && !hostname.empty?
+          end
+
+          def read_domain
+            file_content = Facter::Util::FileHelper.safe_read('/etc/resolv.conf')
+            if file_content =~ /^domain\s+([^.]\S+)/
+              Regexp.last_match(1)
+            elsif file_content =~ /^search\s+([^.]\S+)/
+              Regexp.last_match(1)
+            end
+          end
+
+          def construct_fqdn(host, domain, fqdn)
+            return fqdn if exists_and_not_empty?(fqdn)
+            return if host.nil? || host.empty?
+
+            exists_and_not_empty?(domain) ? "#{host}.#{domain}" : host
+          end
+
+          def construct_fact_list(hostname, domain, fqdn)
+            @fact_list[:hostname] = hostname
+            @fact_list[:domain] = domain
+            @fact_list[:fqdn] = construct_fqdn(@fact_list[:hostname], @fact_list[:domain], fqdn)
+          end
+
+          def exists_and_not_empty?(variable)
+            variable && !variable.empty?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      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::Util::FileHelper.safe_read('/proc/loadavg')
+            @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