openfact 5.0.0.rc0

data/lib/facter/resolvers/debian_version.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DebianVersion < BaseResolver
+      # :major
+      # :minor
+      # :full
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_debian_version(fact_name) }
+        end
+
+        def read_debian_version(fact_name)
+          file_content = Facter::Util::FileHelper.safe_read('/etc/debian_version')
+          @fact_list[:version] = file_content.strip unless file_content.empty?
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/dmi_decode.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DmiDecode < BaseResolver
+      init_resolver
+
+      ADDRESS_TO_VERSION = {
+        0xe8480 => 'ESXi 2.5',
+        0xe7c70 => 'ESXi 3.0',
+        0xe66c0 => 'ESXi 3.5',
+        0xe7910 => 'ESXi 3.5',
+        0xea550 => 'ESXi 4.0',
+        0xea6c0 => 'ESXi 4.0',
+        0xea2e0 => 'ESXi 4.1',
+        0xe72c0 => 'ESXi 5.0',
+        0xea0c0 => 'ESXi 5.1',
+        0xea050 => 'ESXi 5.5',
+        0xe99e0 => 'ESXi 6.0',
+        0xE9A40 => 'ESXi 6.0',
+        0xea580 => 'ESXi 6.5',
+        0xEA520 => 'ESXi 6.7',
+        0xEA490 => 'ESXi 6.7',
+        0xea5e0 => 'Fusion 8.5'
+      }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { run_dmidecode(fact_name) }
+        end
+
+        def run_dmidecode(fact_name)
+          output = Facter::Core::Execution.execute('dmidecode', logger: log)
+
+          @fact_list[:virtualbox_version] = output.match(/vboxVer_(\S+)/)&.captures&.first
+          @fact_list[:virtualbox_revision] = output.match(/vboxRev_(\S+)/)&.captures&.first
+          @fact_list[:vmware_version] = extract_vmware_version(output)
+
+          @fact_list[fact_name]
+        end
+
+        def extract_vmware_version(output)
+          address_of_version = output.match(/Address:\s(0x[a-zA-Z0-9]*)/)&.captures&.first
+
+          ADDRESS_TO_VERSION[address_of_version&.hex]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/ec2.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Ec2 < BaseResolver
+      init_resolver
+
+      EC2_METADATA_ROOT_URL = 'http://169.254.169.254/latest/meta-data/'
+      EC2_USERDATA_ROOT_URL = 'http://169.254.169.254/latest/user-data/'
+      EC2_SESSION_TIMEOUT = 5
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          log.debug('Querying Ec2 metadata')
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = {}
+          query_for_metadata(EC2_METADATA_ROOT_URL, @fact_list[:metadata])
+          @fact_list[:userdata] = get_data_from(EC2_USERDATA_ROOT_URL).strip.force_encoding('UTF-8')
+          @fact_list[fact_name]
+        end
+
+        def query_for_metadata(url, container)
+          metadata = get_data_from(url)
+          metadata.each_line do |line|
+            next if line.empty?
+
+            http_path_component = build_path_component(line)
+            next if http_path_component == 'security-credentials/'
+
+            if http_path_component.end_with?('/')
+              child = {}
+              child[http_path_component] = query_for_metadata("#{url}#{http_path_component}", child)
+              child.reject! { |key, _info| key == http_path_component }
+              name = http_path_component.chomp('/')
+              container[name] = child
+            else
+              container[http_path_component] = get_data_from("#{url}#{http_path_component}").strip
+            end
+          end
+        end
+
+        def build_path_component(line)
+          array_match = /^(\d+)=.*$/.match(line)
+          array_match ? "#{array_match[1]}/" : line.strip
+        end
+
+        def get_data_from(url)
+          headers = {}
+          headers['X-aws-ec2-metadata-token'] = v2_token if v2_token
+          Facter::Util::Resolvers::Http.get_request(url, headers, { session: determine_session_timeout }, false)
+        end
+
+        def determine_session_timeout
+          session_env = ENV['EC2_SESSION_TIMEOUT']
+          session_env ? session_env.to_i : EC2_SESSION_TIMEOUT
+        end
+
+        def v2_token
+          @v2_token ||= begin
+            token = Facter::Util::Resolvers::AwsToken.get
+            token == '' ? nil : token
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/eos_release.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class EosRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_eos_release(fact_name) }
+        end
+
+        def read_eos_release(fact_name)
+          output = Facter::Util::FileHelper.safe_read('/etc/Eos-release', nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          output_strings = output.split(' ')
+
+          @fact_list[:name] = output_strings[0]
+          @fact_list[:version] = output_strings[-1]
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/facterversion.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Facterversion < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_version_file }
+        end
+
+        def read_version_file
+          @fact_list[:facterversion] = Facter::VERSION
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class DmiBios < BaseResolver
+        init_resolver
+
+        class << self
+          # :model
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+
+            @fact_list[:bios_date]    = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.bios.reldate')
+            @fact_list[:bios_vendor]  = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.bios.vendor')
+            @fact_list[:bios_version] = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.bios.version')
+
+            @fact_list[:product_name]   = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.product')
+            @fact_list[:product_serial] = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.serial')
+            @fact_list[:product_uuid]   = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.uuid')
+
+            @fact_list[:sys_vendor] = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.maker')
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/freebsd/ffi/ffi_helper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Freebsd
+    module FfiHelper
+      module Libc
+        extend FFI::Library
+
+        KENV_GET = 0
+
+        KENV_MVALLEN = 128
+
+        ffi_lib 'c'
+        attach_function :kenv, %i[int string pointer int], :int
+        attach_function :sysctlbyname, %i[string pointer pointer pointer size_t], :int
+      end
+
+      def self.kenv(action, name, value = nil)
+        case action
+        when :get
+          len = Libc::KENV_MVALLEN + 1
+          value = FFI::MemoryPointer.new(:char, len)
+          res = Libc.kenv(Libc::KENV_GET, name, value, len)
+          return nil if res.negative?
+
+          value.read_string(res).chomp("\0")
+        else
+          raise "Action #{action} not supported"
+        end
+      end
+
+      def self.sysctl_by_name(type, name)
+        oldp = FFI::Pointer::NULL
+        oldlenp = FFI::MemoryPointer.new(:size_t)
+
+        newp = FFI::Pointer::NULL
+        newlenp = 0
+
+        if type == :string
+          res = Libc.sysctlbyname(name, oldp, oldlenp, newp, newlenp)
+          return nil if res.negative?
+        else
+          oldlenp.write(:size_t, FFI.type_size(type))
+        end
+
+        oldp = FFI::MemoryPointer.new(:uint8_t, oldlenp.read(:size_t))
+        res = Libc.sysctlbyname(name, oldp, oldlenp, newp, newlenp)
+        return nil if res.negative?
+
+        case type
+        when :string
+          oldp.read_string
+        else
+          oldp.read(type)
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/freebsd/freebsd_version.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class FreebsdVersion < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { freebsd_version_system_call(fact_name) }
+          end
+
+          def freebsd_version_system_call(fact_name)
+            output = Facter::Core::Execution.execute('/bin/freebsd-version -k', logger: log)
+
+            @fact_list[:installed_kernel] = output.strip unless output.empty?
+
+            output = Facter::Core::Execution.execute('/bin/freebsd-version -ru', logger: log)
+
+            build_fact_list(output) unless output.empty?
+
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(output)
+            freebsd_version_results = output.split("\n")
+
+            @fact_list[:running_kernel]     = freebsd_version_results[0].strip
+            @fact_list[:installed_userland] = freebsd_version_results[1].strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/freebsd/geom.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Geom < BaseResolver
+        init_resolver
+
+        DISKS_ATTRIBUTES = %i[read_model read_serial_number read_size].freeze
+        PARTITIONS_ATTRIBUTES = %i[read_partlabel read_partuuid read_size].freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+            require 'rexml/document'
+
+            topology = geom_topology
+            read_data('DISK', topology, DISKS_ATTRIBUTES)
+            read_data('PART', topology, PARTITIONS_ATTRIBUTES)
+
+            @fact_list[fact_name]
+          end
+
+          def read_data(fact_name, geom_topology, data_to_read)
+            fact_list_key = fact_name == 'DISK' ? :disks : :partitions
+            @fact_list[fact_list_key] = {}
+
+            each_geom_class_provider(fact_name, geom_topology) do |provider|
+              name = provider.get_text('./name').value
+
+              @fact_list[fact_list_key][name] = data_to_read.map do |x|
+                send(x, provider)
+              end.inject(:merge)
+            end
+          end
+
+          def each_geom_class_provider(geom_class_name, geom_topology, &block)
+            REXML::XPath.each(geom_topology, "/mesh/class[name/text() = '#{geom_class_name}']/geom/provider", &block)
+          end
+
+          def read_size(provider)
+            res = {}
+            return res unless (mediasize = provider.get_text('mediasize'))
+
+            mediasize = Integer(mediasize.value)
+
+            res[:size_bytes] = mediasize
+            res[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mediasize)
+            res
+          end
+
+          def read_model(provider)
+            res = {}
+            return res unless (model = provider.get_text('./config/descr'))
+
+            res[:model] = model.value
+            res
+          end
+
+          def read_partlabel(provider)
+            res = {}
+            return res unless (rawuuid = provider.get_text('./config/label'))
+
+            res[:partlabel] = rawuuid.value
+            res
+          end
+
+          def read_partuuid(provider)
+            res = {}
+            return res unless (rawuuid = provider.get_text('./config/rawuuid'))
+
+            res[:partuuid] = rawuuid.value
+            res
+          end
+
+          def read_serial_number(provider)
+            res = {}
+            return res unless (serial_number = provider.get_text('./config/ident'))
+
+            res[:serial_number] = serial_number.value
+            res
+          end
+
+          def geom_topology
+            REXML::Document.new(geom_confxml)
+          end
+
+          def geom_confxml
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'kern.geom.confxml')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../../facter/resolvers/bsd/processors'
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Processors < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
+          end
+
+          def collect_processors_info(fact_name)
+            require_relative '../../../facter/resolvers/freebsd/ffi/ffi_helper'
+
+            count = logical_count
+            model = processors_model
+            speed = processors_speed
+
+            @fact_list[:logical_count] = count
+            @fact_list[:models] = Array.new(count, model) if logical_count && model
+            @fact_list[:speed] = speed * 1000 * 1000 if speed
+
+            @fact_list[fact_name]
+          end
+
+          def processors_model
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'hw.model')
+          end
+
+          def logical_count
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.ncpu')
+          end
+
+          def processors_speed
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.clockrate')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      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('swapinfo -k', logger: log)
+            data = output.split("\n")[1..-1].map { |line| line.split(/\s+/) }
+
+            unless data.empty?
+              @fact_list[:total_bytes]     = kilobytes_to_bytes(data.map { |line| line[1].to_i }.inject(:+))
+              @fact_list[:used_bytes]      = kilobytes_to_bytes(data.map { |line| line[2].to_i }.inject(:+))
+              @fact_list[:available_bytes] = kilobytes_to_bytes(data.map { |line| line[3].to_i }.inject(:+))
+              @fact_list[:capacity] = Facter::Util::Resolvers::FilesystemHelper
+                                      .compute_capacity(@fact_list[:used_bytes],
+                                                        @fact_list[:total_bytes])
+              @fact_list[:encrypted] = data.map { |line| line[0].end_with?('.eli') }.all?
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def kilobytes_to_bytes(quantity)
+            (quantity.to_f * 1024).to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/freebsd/system_memory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      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_used_memory_in_bytes
+
+            @fact_list[:available_bytes] = @fact_list[:total_bytes] - @fact_list[:used_bytes]
+            @fact_list[:capacity] = Facter::Util::Resolvers::FilesystemHelper
+                                    .compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
+
+            @fact_list[fact_name]
+          end
+
+          def pagesize
+            @pagesize ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_page_size')
+          end
+
+          def read_used_memory_in_bytes
+            require_relative 'ffi/ffi_helper'
+
+            @fact_list[:used_bytes] = pagesize * (
+              Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_active_count') +
+              Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_wire_count')
+            )
+          end
+
+          def read_total_memory_in_bytes
+            require_relative 'ffi/ffi_helper'
+
+            @fact_list[:total_bytes] = pagesize *
+                                       Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_page_count')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Virtual < BaseResolver
+        init_resolver
+
+        class << self
+          # :model
+
+          VM_GUEST_SYSCTL_NAMES = {
+            'hv' => 'hyperv',
+            'microsoft' => 'hyperv',
+            'oracle' => 'virtualbox',
+            'xen' => 'xenu',
+            'none' => nil
+          }.freeze
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+
+            if Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'security.jail.jailed').zero?
+              vm = Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'kern.vm_guest')
+
+              vm = VM_GUEST_SYSCTL_NAMES[vm] if VM_GUEST_SYSCTL_NAMES.key?(vm)
+
+              @fact_list[:vm] = vm
+            else
+              @fact_list[:vm] = 'jail'
+            end
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end