facter 4.0.26 → 4.0.32

data/lib/facter/resolvers/aix/utils/info_extractor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facter
+  module InfoExtractor
+    MEGABYTES_EXPONENT = 1024**2
+    GIGABYTES_EXPONENT = 1024**3
+
+    def self.extract(content, regex)
+      content = content.each_line.map do |line|
+        next unless regex =~ line
+
+        line.split(/:\s*|\s{2,}/)
+      end
+
+      content.flatten!.reject!(&:nil?)
+
+      Hash[*content]
+    end
+  end
+end

data/lib/facter/resolvers/augeas_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Augeas < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_augeas_version(fact_name) }
+        end
+
+        def read_augeas_version(fact_name)
+          @fact_list[:augeas_version] = read_augeas_from_cli
+          @fact_list[:augeas_version] ||= read_augeas_from_gem
+
+          @fact_list[fact_name]
+        end
+
+        def read_augeas_from_cli
+          output = Facter::Core::Execution.execute('augparse --version 2>&1', logger: log)
+          Regexp.last_match(1) if output =~ /^augparse (\d+\.\d+\.\d+)/
+        end
+
+        def read_augeas_from_gem
+          require 'augeas'
+
+          if Gem.loaded_specs['augeas']
+            ::Augeas.create { |aug| aug.get('/augeas/version') }
+          else
+            # it is used for legacy augeas <= 0.5.0 (ruby-augeas gem)
+            ::Augeas.open { |aug| aug.get('/augeas/version') }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Bsd
+    module FfiHelper
+      module Libc
+        extend FFI::Library
+
+        ffi_lib 'c'
+        attach_function :getloadavg, %i[pointer int], :int
+        attach_function :sysctl, %i[pointer uint pointer pointer pointer size_t], :int
+      end
+
+      def self.read_load_averages
+        raw_loadavg = FFI::MemoryPointer.new(:double, 3)
+
+        res = Libc.getloadavg(raw_loadavg, 3)
+        return unless res == 3
+
+        raw_loadavg.read_array_of_double(res)
+      end
+
+      def self.sysctl(type, oids)
+        name = FFI::MemoryPointer.new(:uint, oids.size)
+        name.write_array_of_uint(oids)
+        namelen = oids.size
+
+        oldp = FFI::Pointer::NULL
+        oldlenp = FFI::MemoryPointer.new(:size_t)
+
+        newp = FFI::Pointer::NULL
+        newlen = 0
+
+        if type == :string
+          res = Libc.sysctl(name, namelen, oldp, oldlenp, newp, newlen)
+          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.sysctl(name, namelen, oldp, oldlenp, newp, newlen)
+        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/bsd/processors.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Bsd
+      class Processors < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
+          end
+
+          def collect_processors_info(fact_name)
+            require 'facter/resolvers/bsd/ffi/ffi_helper'
+
+            @fact_list[:logical_count] = logical_count
+            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            @fact_list[:speed] = speed * 1000 * 1000 if speed
+
+            @fact_list[fact_name]
+          end
+
+          CTL_HW = 6
+          HW_MODEL = 2
+          HW_NCPU = 3
+          HW_CPUSPEED = 12
+
+          def model
+            @model ||= Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_MODEL])
+          end
+
+          def logical_count
+            @logical_count ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_NCPU])
+          end
+
+          def speed
+            @speed ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_CPUSPEED])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{resolvers/docker_lxc.rb → facter/resolvers/containers.rb}

@@ -2,7 +2,7 @@
 
 module Facter
   module Resolvers
-    class DockerLxc < BaseResolver
+    class Containers < BaseResolver
       # :virtual
       # :hypervisor
 
@@ -20,13 +20,14 @@ module Facter
         def read_cgroup(fact_name)
           output_cgroup = Util::FileHelper.safe_read('/proc/1/cgroup', nil)
           output_environ = Util::FileHelper.safe_read('/proc/1/environ', nil)
-          return if output_cgroup.nil? || output_environ.nil?
+          return unless output_cgroup && output_environ
 
           output_docker = %r{docker/(.+)}.match(output_cgroup)
           output_lxc = %r{^/lxc/([^/]+)}.match(output_cgroup)
           lxc_from_environ = /container=lxc/ =~ output_environ
 
           info, vm = extract_vm_and_info(output_docker, output_lxc, lxc_from_environ)
+          info, vm = extract_for_nspawn(output_environ) unless vm
           @fact_list[:vm] = vm
           @fact_list[:hypervisor] = { vm.to_sym => info } if vm
           @fact_list[fact_name]
@@ -43,6 +44,15 @@ module Facter
 
           [info ? { INFO[vm] => info } : {}, vm]
         end
+
+        def extract_for_nspawn(output_environ)
+          nspawn = /container=systemd-nspawn/ =~ output_environ
+          if nspawn
+            vm = 'systemd_nspawn'
+            info = Util::FileHelper.safe_read('/etc/machine-id', nil)
+          end
+          [info ? { 'id' => info.strip } : {}, vm]
+        end
       end
     end
   end

data/lib/facter/resolvers/dmi_decode.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DmiDecode < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      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)
+          @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,77 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Facter
+  module Resolvers
+    class Ec2 < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      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_CONNECTION_TIMEOUT = 0.6
+      EC2_SESSION_TIMEOUT = 5
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @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
+          @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_compoent(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_compoent(line)
+          array_match = /^(\d+)=.*$/.match(line)
+          array_match ? "#{array_match[1]}/" : line.strip
+        end
+
+        def get_data_from(url)
+          parsed_url = URI.parse(url)
+          http = Net::HTTP.new(parsed_url.host)
+          http.read_timeout = determine_session_timeout
+          http.open_timeout = EC2_CONNECTION_TIMEOUT
+          resp = http.get(parsed_url.path)
+          response_code_valid?(resp.code) ? resp.body : ''
+        rescue StandardError => e
+          log.debug("Trying to connect to #{url} but got: #{e.message}")
+          ''
+        end
+
+        def response_code_valid?(http_code)
+          http_code.to_i.equal?(200)
+        end
+
+        def determine_session_timeout
+          session_env = ENV['EC2_SESSION_TIMEOUT']
+          session_env ? session_env.to_i : EC2_SESSION_TIMEOUT
+        end
+      end
+    end
+  end
+end

data/lib/{resolvers → facter/resolvers}/facterversion_resolver.rb

@@ -14,8 +14,7 @@ module Facter
         end
 
         def read_version_file
-          version_file = ::File.join(ROOT_DIR, 'VERSION')
-          @fact_list[:facterversion] = ::File.read(version_file).chomp('')
+          @fact_list[:facterversion] = Facter::VERSION
         end
       end
     end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Freebsd
+    module FfiHelper
+      module Libc
+        extend FFI::Library
+
+        ffi_lib 'c'
+        attach_function :sysctlbyname, %i[string pointer pointer pointer size_t], :int
+      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/geom_resolver.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Geom < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+            require 'rexml/document'
+
+            read_disks
+            read_partitions
+
+            @fact_list[fact_name]
+          end
+
+          def read_disks
+            @fact_list[:disks] = {}
+
+            each_geom_class_provider('DISK') do |provider|
+              name = provider.get_text('./name').value
+
+              @fact_list[:disks][name] = %i[read_model read_serial_number read_size].map do |x|
+                send(x, provider)
+              end.inject(:merge)
+            end
+          end
+
+          def read_partitions
+            @fact_list[:partitions] = {}
+
+            each_geom_class_provider('PART') do |provider|
+              name = provider.get_text('./name').value
+
+              @fact_list[:partitions][name] = %i[read_partlabel read_partuuid read_size].map do |x|
+                send(x, provider)
+              end.inject(:merge)
+            end
+          end
+
+          def each_geom_class_provider(geom_class_name, &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::FactsUtils::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
+            @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