facter 4.0.46 → 4.0.51

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      module FFI
+        class SockaddrDl < ::FFI::Struct
+          layout :sdl_len, :uchar,
+                 :sdl_family, :uchar,
+                 :sdl_index, :ushort,
+                 :sdl_type, :uchar,
+                 :sdl_nlen, :uchar,
+                 :sdl_alen, :uchar,
+                 :sdl_slen, :uchar,
+                 :sdl_data, [:char, 120]
+        end
+
+        class IfMsghdr < ::FFI::Struct
+          layout :ifm_msglen, :ushort,
+                 :ifm_version, :uchar,
+                 :ifm_type, :uchar,
+                 :ifm_addrs, :int,
+                 :ifm_flags, :int,
+                 :ifm_index, :ushort,
+                 :ifm_addrlen, :uchar
+        end
+
+        class Sockaddr < ::FFI::Struct
+          layout :sa_len, :uchar,
+                 :sa_family, :uchar,
+                 :sa_data, [:char, 14]
+        end
+
+        class InAddr < ::FFI::Struct
+          layout :s_addr, :uint
+        end
+
+        class In6Addr < ::FFI::Struct
+          layout :u6_addr8, [:uchar, 16]
+        end
+
+        class SockaddrIn < ::FFI::Struct
+          layout :sin_len, :uchar,
+                 :sin_family, :uchar,
+                 :sin_port, :ushort,
+                 :sin_addr, InAddr,
+                 :sin_zero, [:uchar, 8]
+        end
+
+        class SockaddrIn6 < ::FFI::Struct
+          layout :sin6_len, :uchar,
+                 :sin6_family, :uchar,
+                 :sin6_port, :ushort,
+                 :sin6_flowinfo, :uint,
+                 :sin6_addr, In6Addr,
+                 :sin6_scope_id, :uint
+        end
+
+        class SockaddrStorage < ::FFI::Struct
+          layout :ss_len, :uchar,
+                 :ss_family, :uchar,
+                 :ss_pad, [:char, 6],
+                 :ss_align, :long_long,
+                 :ss_pad2, [:char, 1264]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/{filesystem_resolver.rb → filesystem.rb}

@@ -9,12 +9,12 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_vtf_file(fact_name) }
           end
 
           def read_vtf_file(fact_name)
-            file_content = Util::FileHelper.safe_readlines('/etc/vfs')
+            file_content = Facter::Util::FileHelper.safe_readlines('/etc/vfs')
             return if file_content.empty?
 
             file_content = file_content.map do |line|

data/lib/facter/resolvers/aix/{hardware_resolver.rb → hardware.rb}

@@ -9,13 +9,13 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_hardware(fact_name) }
         end
 
         def read_hardware(fact_name)
-          require_relative 'utils/odm_query'
-          odmquery = Facter::ODMQuery.new
+          require 'facter/util/aix/odm_query'
+          odmquery = Facter::Util::Aix::ODMQuery.new
           odmquery
             .equals('name', 'sys0')
             .equals('attribute', 'modelname')

data/lib/facter/resolvers/aix/{load_averages_resolver.rb → load_averages.rb}

@@ -9,14 +9,14 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
           end
 
           def read_load_averages(fact_name)
             require_relative 'ffi/ffi_helper'
             @fact_list[:load_averages] = {}.tap do |h|
-              h['1m'], h['5m'], h['15m'] = Facter::Aix::FfiHelper.read_load_averages
+              h['1m'], h['5m'], h['15m'] = FfiHelper.read_load_averages
             end
 
             @fact_list[fact_name]

data/lib/facter/resolvers/aix/memory.rb

@@ -10,7 +10,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { execute_svmon(fact_name) }
           end
 
@@ -44,7 +44,7 @@ module Facter
             { available_bytes: content[3].to_i * pagesize,
               total_bytes: total,
               used_bytes: used,
-              capacity: FilesystemHelper.compute_capacity(used, total) }
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used, total) }
           end
 
           def populate_swap(content, pagesize)
@@ -56,7 +56,7 @@ module Facter
             { available_bytes: total - used,
               total_bytes: total,
               used_bytes: used,
-              capacity: FilesystemHelper.compute_capacity(used, total) }
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used, total) }
           end
         end
       end

data/lib/facter/resolvers/aix/mountpoints.rb

@@ -11,7 +11,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_mount(fact_name) }
           end
 
@@ -53,13 +53,13 @@ module Facter
             used_bytes = info[2]
             size_bytes = info[1]
             @fact_list[:mountpoints][info.last].merge!(
-              capacity: FilesystemHelper.compute_capacity(used_bytes, size_bytes),
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, size_bytes),
               available_bytes: available_bytes,
               used_bytes: used_bytes,
               size_bytes: size_bytes,
-              available: FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes),
-              used: FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes),
-              size: FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+              available: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes),
+              used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes),
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes)
             )
           end
         end

data/lib/facter/resolvers/aix/{networking_resolver.rb → networking.rb}

@@ -9,7 +9,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_netstat(fact_name) }
           end
 
@@ -17,39 +17,27 @@ module Facter
             @fact_list[:interfaces] = {}
             output = Facter::Core::Execution.execute('netstat -rn', logger: log)
             output = output.each_line.select { |line| (line =~ /\s\s[0-9]+.[0-9]+.[0-9]+.[0-9]+|\s\s.*:[0-9a-f]+/) }
-            extract_interfaces(output)
+            @fact_list[:interfaces] = load_interfaces
 
             populate_with_mtu_and_mac!(@fact_list[:interfaces])
             get_primary_interface_info(output)
-            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+            Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
             @fact_list[fact_name]
           end
 
           def get_primary_interface_info(output)
-            primary_interface_info = output.find { |line| line =~ /=>/ }&.split(' ')
+            primary_interface_info = output.find { |line| line =~ /default/ }&.split(' ')
             @fact_list[:primary_interface] = primary_interface_info[5] if primary_interface_info
           end
 
-          def extract_interfaces(netstat_output)
-            netstat_output.each do |line|
-              next if line =~ /default/
-
-              info = line.split("\s")
-              mask_length = info[0].match(%r{/([0-9]+)|%([0-9]+)})
-              next unless mask_length
-
-              is_ipv4 = info[1] =~ /[0-9]+.[0-9]+.[0-9]+.[0-9]+/
-              build_bindings(info[5], info[1], mask_length[1] || mask_length[2], is_ipv4)
-            end
-          end
-
           def build_bindings(name, ip, mask_length, is_ipv4)
             bind_to_add = is_ipv4 ? :bindings : :bindings6
             ip = ip.gsub(/%[0-9]$/, '') # remove mask information if it exists
             mask_length = mask_length.to_i - 1 unless is_ipv4
             @fact_list[:interfaces][name] ||= {}
             @fact_list[:interfaces][name][bind_to_add] ||= []
-            @fact_list[:interfaces][name][bind_to_add] << ::Resolvers::Utils::Networking.build_binding(ip, mask_length)
+            @fact_list[:interfaces][name][bind_to_add] << Facter::Util::Resolvers::Networking
+                                                          .build_binding(ip, mask_length)
           end
 
           def populate_with_mtu_and_mac!(interfaces)
@@ -68,6 +56,12 @@ module Facter
           def format_mac_address(address)
             address.split('.').map { |e| format('%<mac_address>02s', mac_address: e) }.join(':').tr(' ', '0')
           end
+
+          def load_interfaces
+            require_relative 'ffi/ffi_helper'
+
+            FfiHelper.read_interfaces
+          end
         end
       end
     end

data/lib/facter/resolvers/aix/nim.rb

@@ -9,7 +9,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_niminfo(fact_name) }
           end
 

data/lib/facter/resolvers/aix/os_level.rb

@@ -9,7 +9,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_oslevel(fact_name) }
           end
 

data/lib/facter/resolvers/aix/partitions.rb

@@ -9,12 +9,12 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { query_cudv(fact_name) }
           end
 
           def query_cudv(fact_name)
-            odmquery = Facter::ODMQuery.new
+            odmquery = Facter::Util::Aix::ODMQuery.new
             odmquery.equals('PdDvLn', 'logical_volume/lvsubclass/lvtype')
 
             result = odmquery.execute
@@ -40,13 +40,13 @@ module Facter
 
             return if stdout.empty?
 
-            info_hash =  InfoExtractor.extract(stdout, /PPs:|PP SIZE|TYPE:|LABEL:|MOUNT/)
+            info_hash =  Facter::Util::Aix::InfoExtractor.extract(stdout, /PPs:|PP SIZE|TYPE:|LABEL:|MOUNT/)
             size_bytes = compute_size(info_hash)
 
             part_info = {
               filesystem: info_hash['TYPE'],
               size_bytes: size_bytes,
-              size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes)
             }
             mount = info_hash['MOUNT POINT']
             label = info_hash['LABEL']
@@ -59,9 +59,9 @@ module Facter
             physical_partitions = info_hash['PPs'].to_i
             size_physical_partition = info_hash['PP SIZE']
             exp = if size_physical_partition[/mega/]
-                    InfoExtractor::MEGABYTES_EXPONENT
+                    Facter::Util::Aix::InfoExtractor::MEGABYTES_EXPONENT
                   else
-                    InfoExtractor::GIGABYTES_EXPONENT
+                    Facter::Util::Aix::InfoExtractor::GIGABYTES_EXPONENT
                   end
             size_physical_partition.to_i * physical_partitions * exp
           end

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

@@ -9,7 +9,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { query_pddv(fact_name) }
           end
 
@@ -17,7 +17,7 @@ module Facter
             @fact_list[:models] = []
             @fact_list[:logical_count] = 0
 
-            odmquery = Facter::ODMQuery.new
+            odmquery = Facter::Util::Aix::ODMQuery.new
             odmquery.equals('class', 'processor')
 
             result = odmquery.execute
@@ -32,7 +32,7 @@ module Facter
           end
 
           def populate_from_cudv(name)
-            odmquery = Facter::ODMQuery.new
+            odmquery = Facter::Util::Aix::ODMQuery.new
             odmquery.equals('PdDvLn', name)
 
             result = odmquery.execute
@@ -45,7 +45,7 @@ module Facter
           end
 
           def query_cuat(name)
-            odmquery = Facter::ODMQuery.new
+            odmquery = Facter::Util::Aix::ODMQuery.new
             odmquery.equals('name', name)
 
             result = odmquery.execute

data/lib/facter/resolvers/aix/serialnumber.rb

@@ -9,12 +9,12 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_serialnumber(fact_name) }
           end
 
           def read_serialnumber(fact_name)
-            odmquery = Facter::ODMQuery.new
+            odmquery = Facter::Util::Aix::ODMQuery.new
             odmquery
               .equals('name', 'sys0')
               .equals('attribute', 'systemid')

data/lib/facter/resolvers/{augeas_resolver.rb → augeas.rb}

@@ -8,7 +8,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_augeas_version(fact_name) }
         end
 

data/lib/facter/resolvers/base_resolver.rb

@@ -20,13 +20,16 @@ module Facter
         Facter::SessionCache.subscribe(self)
       end
 
-      def self.resolve(fact_name)
+      def self.resolve(fact_name, options = {})
         @semaphore.synchronize do
           subscribe_to_manager
-          post_resolve(fact_name)
+          post_resolve(fact_name, options)
 
           cache_nil_for_unresolved_facts(fact_name)
         end
+      rescue NoMethodError => e
+        log.debug("Could not resolve #{fact_name}, got #{e}")
+        @fact_list[fact_name] = nil
       rescue LoadError, NameError => e
         log.debug("resolving fact #{fact_name}, but #{e}")
         @fact_list[fact_name] = nil
@@ -37,8 +40,8 @@ module Facter
         @fact_list[fact_name]
       end
 
-      def self.post_resolve(_fact_name)
-        raise NotImplementedError, "You must implement post_resolve(fact_name) method in #{name}"
+      def self.post_resolve(_fact_name, _options)
+        raise NotImplementedError, "You must implement post_resolve(fact_name, options) method in #{name}"
       end
     end
   end

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

@@ -10,7 +10,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
           end
 

data/lib/facter/resolvers/cloud.rb

@@ -10,7 +10,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { detect_azure(fact_name) }
         end
 
@@ -23,7 +23,7 @@ module Facter
             files.select! { |filename| filename =~ /^dhclient.*lease.*$/ }
             files.each do |file|
               path = File.join([path, file])
-              output = Util::FileHelper.safe_read(path)
+              output = Facter::Util::FileHelper.safe_read(path)
 
               if output.include?('option unknown-245') || output.include?('option 245')
                 @fact_list[:cloud_provider] = 'azure'

data/lib/facter/resolvers/containers.rb

@@ -13,13 +13,13 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_cgroup(fact_name) }
         end
 
         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)
+          output_cgroup = Facter::Util::FileHelper.safe_read('/proc/1/cgroup', nil)
+          output_environ = Facter::Util::FileHelper.safe_read('/proc/1/environ', nil)
           return unless output_cgroup && output_environ
 
           output_docker = %r{docker/(.+)}.match(output_cgroup)
@@ -49,7 +49,7 @@ module Facter
           nspawn = /container=systemd-nspawn/ =~ output_environ
           if nspawn
             vm = 'systemd_nspawn'
-            info = Util::FileHelper.safe_read('/etc/machine-id', nil)
+            info = Facter::Util::FileHelper.safe_read('/etc/machine-id', nil)
           end
           [info ? { 'id' => info.strip } : {}, vm]
         end