facter 4.0.29 → 4.0.34

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class DmiBios < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          #:model
+
+          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'
+
+            @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/{resolvers → facter/resolvers}/freebsd/ffi/ffi_helper.rb

@@ -8,10 +8,29 @@ module Facter
       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)

data/lib/{resolvers → facter/resolvers}/freebsd/processors.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'resolvers/bsd/processors'
+require 'facter/resolvers/bsd/processors'
 
 module Facter
   module Resolvers
@@ -17,7 +17,7 @@ module Facter
           end
 
           def collect_processors_info(fact_name)
-            require "#{ROOT_DIR}/lib/resolvers/freebsd/ffi/ffi_helper"
+            require 'facter/resolvers/freebsd/ffi/ffi_helper'
 
             @fact_list[:logical_count] = logical_count
             @fact_list[:models] = Array.new(logical_count, model) if logical_count && model

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class SwapMemory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_swap_memory(fact_name) }
+          end
+
+          def read_swap_memory(fact_name) # rubocop:disable Metrics/AbcSize
+            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] = 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_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class SystemMemory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { calculate_system_memory(fact_name) }
+          end
+
+          def calculate_system_memory(fact_name)
+            read_total_memory_in_bytes
+            read_available_memory_in_bytes
+
+            @fact_list[:used_bytes] = @fact_list[:total_bytes] - @fact_list[:available_bytes]
+            @fact_list[:capacity] = FilesystemHelper.compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
+
+            @fact_list[fact_name]
+          end
+
+          def read_available_memory_in_bytes
+            output = Facter::Core::Execution.execute('vmstat -H --libxo json', logger: log)
+            data = JSON.parse(output)
+            @fact_list[:available_bytes] = data['memory']['free-memory'] * 1024
+          end
+
+          def read_total_memory_in_bytes
+            require_relative 'ffi/ffi_helper'
+
+            @fact_list[:total_bytes] = Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'hw.physmem')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/load_averages.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class LoadAverages < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
+        end
+
+        def read_load_averages(fact_name)
+          require_relative 'utils/ffi/load_averages'
+          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Utils::Ffi::LoadAverages.read_load_averages).to_h
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

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

@@ -28,6 +28,8 @@ module Facter
 
         def retrieve_vm(output)
           output.each_line { |line| REGEX_VALUES.each { |key, value| return value if line =~ /#{key}/ } }
+
+          nil
         end
       end
     end

data/lib/{resolvers → facter/resolvers}/macosx/mountpoints_resolver.rb

@@ -14,7 +14,7 @@ module Facter
             @fact_list.fetch(fact_name) { read_mounts }
           end
 
-          def read_mounts # rubocop:disable Metrics/AbcSize
+          def read_mounts
             mounts = {}
             FilesystemHelper.read_mountpoints.each do |fs|
               device = fs.name
@@ -22,8 +22,6 @@ module Facter
               path = fs.mount_point
               options = fs.options.split(',').map(&:strip).map { |o| o == 'rootfs' ? 'root' : o }
 
-              next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
-
               mounts[path] = read_stats(path).tap do |hash|
                 hash[:device] = device
                 hash[:filesystem] = filesystem

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

@@ -11,6 +11,7 @@ module Facter
         private
 
         def post_resolve(fact_name)
+          log.debug('in networking_linux_resolver')
           @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
 
           @fact_list[fact_name]
@@ -36,12 +37,17 @@ module Facter
         end
 
         def retrieve_interface_info
+          log.debug('retrieve_interface_info')
           output = Facter::Core::Execution.execute('ip -o address', logger: log)
+          log.debug("ip -o address result is:\n#{output}")
+
           interfaces = {}
 
           output.each_line do |ip_line|
             ip_tokens = ip_line.split(' ')
 
+            log.debug("ip_tokens = #{ip_tokens}")
+            log.debug("interfaces = #{interfaces}")
             fill_ip_v4_info!(ip_tokens, interfaces)
             fill_io_v6_info!(ip_tokens, interfaces)
             find_dhcp!(ip_tokens, interfaces)
@@ -85,14 +91,23 @@ module Facter
           return unless lease_file
 
           dhcp = Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
-          dhcp ? dhcp.match(/SERVER_ADDRESS=(.*)/)[1] : nil
+
+          return unless dhcp
+
+          dhcp = dhcp.match(/SERVER_ADDRESS=(.*)/)
+          dhcp[1] if dhcp
         end
 
         def fill_ip_v4_info!(ip_tokens, network_info)
+          log.debug('fill_ip_v4_info!')
           return unless ip_tokens[2].casecmp('inet').zero?
 
           interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens)
 
+          log.debug("interface_name = #{interface_name}\n" \
+                      "ip4_address = #{ip4_address}\n" \
+                      "ip4_mask_length = #{ip4_mask_length}")
+
           binding = ::Resolvers::Utils::Networking.build_binding(ip4_address, ip4_mask_length)
           build_network_info_structure!(network_info, interface_name, :bindings)
 

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

@@ -34,6 +34,8 @@ module Facter
 
             next unless /^envID:/ =~ parts[0]
 
+            @fact_list[:id] = parts[1]
+
             return 'openvzhn' if parts[1] == '0'
 
             return 'openvzve'

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

@@ -56,7 +56,7 @@ module Facter
         def process_name
           return unless @fact_list[:name]
 
-          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red')
+          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red', 'oracle')
                                 @fact_list[:name].split(' ')[0..1].join
                               else
                                 @fact_list[:name].split(' ')[0].strip

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

@@ -32,9 +32,10 @@ module Facter
           version_codename = output_strings[1].split(' ')
 
           @fact_list[:name] = name(output_strings[0])
-          @fact_list[:version] = version_codename[0].strip
-          codename = version_codename[1].strip
-          @fact_list[:codename] = codename.gsub(/[()]/, '')
+          @fact_list[:version] = version_codename[0]&.strip
+
+          codename = version_codename[1]&.strip
+          @fact_list[:codename] = codename ? codename.gsub(/[()]/, '') : nil
 
           @fact_list[:identifier] = identifier(@fact_list[:name])
         end

data/lib/facter/resolvers/solaris/ffi/ffi.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require_relative 'structs.rb'
+require_relative 'functions.rb'
+
+module Facter
+  module Resolvers
+    module Solaris
+      module FFI
+        SIOCGLIFNUM       = -1_072_928_382
+        SIOCGLIFCONF      = -1_072_666_203
+        SIOCGLIFMTU       = -1_065_850_502
+        SIOCGLIFNETMASK   = -1_065_850_499
+        SIOCGARP          = -1_071_355_617
+        AF_INET           = 2
+        AF_INET6          = 26
+        AF_UNSPEC         = 0
+        SOCK_DGRAM        = 1
+        INET_ADDRSTRLEN   = 16
+        INET6_ADDRSTRLEN  = 46
+      end
+
+      BINDINGS_KEY = {
+        FFI::AF_INET => :bindings,
+        FFI::AF_INET6 => :bindings6
+      }.freeze
+    end
+  end
+end

data/lib/facter/resolvers/solaris/ffi/functions.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      module FFI
+        module Ioctl
+          extend ::FFI::Library
+          ffi_lib ::FFI::Library::LIBC, '/usr/lib/libsocket.so'
+
+          attach_function :ioctl_base, :ioctl, %i[int int pointer], :int
+          attach_function :open_socket, :socket, %i[int int int], :int
+          attach_function :close_socket, :shutdown, %i[int int], :int
+          attach_function :inet_ntop, %i[int pointer pointer uint], :string
+
+          def self.ioctl(call_const, pointer, address_family = AF_INET)
+            fd = Ioctl.open_socket(address_family, SOCK_DGRAM, 0)
+            result = ioctl_base(fd, call_const, pointer)
+            Ioctl.close_socket(fd, 2)
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/ffi/structs.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      module FFI
+        class SockaddrStorage < ::FFI::Struct
+          layout  :ss_family, :int16,
+                  :pad, [:char, 254]
+        end
+
+        class Sockaddr < ::FFI::Struct
+          layout  :sa_family, :sa_family_t,
+                  :sa_data, [:uchar, 14]
+        end
+
+        class Lifnum < ::FFI::Struct
+          layout  :lifn_family, :sa_family_t,
+                  :lifn_flags, :int,
+                  :lifn_count, :int
+        end
+
+        class Arpreq < ::FFI::Struct
+          layout  :arp_pa, Sockaddr,
+                  :arp_ha, Sockaddr,
+                  :arp_flags, :int
+
+          def sa_data_to_mac
+            self[:arp_ha][:sa_data].entries[0, 6].map do |s|
+              s.to_s(16).rjust(2, '0')
+            end.join ':'
+          end
+
+          def self.new_for_ioctl(lifreq)
+            arp = Arpreq.new
+            arp_addr = SockaddrIn.new(arp[:arp_pa].to_ptr)
+            arp_addr[:sin_addr][:s_addr] = SockaddrIn.new(lifreq.lifru_addr.to_ptr).s_addr
+
+            arp
+          end
+        end
+
+        class Lifru1 < ::FFI::Union
+          layout  :lifru_addrlen, :int,
+                  :lifru_ppa, :uint_t
+        end
+
+        class Lifru < ::FFI::Union
+          layout  :lifru_addr, SockaddrStorage,
+                  :lifru_dstaddr, SockaddrStorage,
+                  :lifru_broadaddr, SockaddrStorage,
+                  :lifru_token, SockaddrStorage,
+                  :lifru_subnet, SockaddrStorage,
+                  :lifru_flags, :uint64,
+                  :lifru_metric, :int,
+                  :pad, [:char, 80]
+        end
+
+        class Lifreq < ::FFI::Struct
+          layout  :lifr_name, [:char, 32],
+                  :lifr_lifru1, Lifru1,
+                  :lifr_movetoindex, :int,
+                  :lifr_lifru, Lifru,
+                  :pad, [:char, 80]
+
+          def name
+            self[:lifr_name].to_s
+          end
+
+          def ss_family
+            self[:lifr_lifru][:lifru_addr][:ss_family]
+          end
+
+          def lifru_addr
+            self[:lifr_lifru][:lifru_addr]
+          end
+        end
+
+        class Lifconf < ::FFI::Struct
+          layout  :lifc_family, :uint,
+                  :lifc_flags, :int,
+                  :lifc_len, :int,
+                  :lifc_buf, :pointer
+
+          def self.new_for_ioctl(interface_count)
+            lifconf = new
+            lifconf[:lifc_family] = 0
+            lifconf[:lifc_flags] = 0
+            lifconf[:lifc_len] = interface_count * Lifreq.size
+            lifconf[:lifc_buf] = ::FFI::MemoryPointer.new(Lifreq, interface_count)
+            lifconf
+          end
+        end
+
+        class Lifcu < ::FFI::Union
+          layout  :lifcu_buf, :caddr_t,
+                  :lifcu_req, Lifreq
+        end
+
+        class InAddr < ::FFI::Struct
+          layout :s_addr, :uint32_t
+        end
+
+        class SockaddrIn < ::FFI::Struct
+          layout  :sin_family, :sa_family_t,
+                  :sin_port, :in_port_t,
+                  :sin_addr, InAddr,
+                  :sin_zero, [:char, 8]
+
+          def s_addr
+            self[:sin_addr][:s_addr]
+          end
+        end
+      end
+    end
+  end
+end