facter 4.0.44 → 4.0.50

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

@@ -1,41 +1,53 @@
 # frozen_string_literal: true
 
 require_relative 'ffi/ffi.rb'
-require 'ipaddr'
-
 module Facter
   module Resolvers
     module Solaris
       class Networking < BaseResolver
+        init_resolver
         @log = Facter::Log.new(self)
-        @fact_list ||= {}
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_facts(fact_name) }
           end
 
           def read_facts(fact_name)
-            lifreqs = load_interfaces
-            @interfaces = {}
+            begin
+              lifreqs = load_interfaces
+              @interfaces = {}
+
+              lifreqs.each do |lifreq|
+                obtain_info_for_interface(lifreq)
+              end
+
+              @fact_list[:primary_interface] = Facter::Util::Resolvers::Networking::PrimaryInterface.read_from_route
 
-            lifreqs.each do |lifreq|
-              @interfaces[lifreq.name] ||= {}
+              unless @interfaces.empty?
+                @fact_list[:interfaces] = @interfaces
+                @fact_list[:primary_interface] ||=
+                  Facter::Util::Resolvers::Networking::PrimaryInterface.find_in_interfaces(@interfaces)
+              end
 
-              add_mac(lifreq)
-              add_bindings(lifreq)
-              add_mtu(lifreq)
-              add_dhcp(lifreq.name)
+              Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+            rescue StandardError => e
+              @log.log_exception(e)
             end
+            @fact_list[fact_name]
+          end
 
-            @fact_list = { interfaces: @interfaces } unless @interfaces.empty?
-            primary_interface
+          def obtain_info_for_interface(lifreq)
+            @interfaces[lifreq.name] ||= {}
 
-            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+            add_mac(lifreq)
+            add_bindings(lifreq)
+            add_mtu(lifreq)
 
-            @fact_list[fact_name]
+            dhcp = Facter::Util::Resolvers::Networking::Dhcp.get(lifreq.name, @log)
+            @interfaces[lifreq.name][:dhcp] = dhcp if dhcp
           end
 
           def add_mac(lifreq)
@@ -43,7 +55,10 @@ module Facter
 
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGARP, arp, lifreq.ss_family)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            if ioctl == -1
+              @log.debug("Could not read MAC address for interface #{lifreq.name} "\
+                          "error code is: #{::FFI::LastError.error}")
+            end
 
             mac = arp.sa_data_to_mac
             @interfaces[lifreq.name][:mac] ||= mac if mac.count('0') < 12
@@ -53,7 +68,7 @@ module Facter
             ip = inet_ntop(lifreq, lifreq.ss_family)
             _netmask, netmask_length = load_netmask(lifreq)
 
-            bindings = ::Resolvers::Utils::Networking.build_binding(ip, netmask_length)
+            bindings = Facter::Util::Resolvers::Networking.build_binding(ip, netmask_length)
 
             bindings_key = BINDINGS_KEY[lifreq.ss_family]
             @interfaces[lifreq.name][bindings_key] ||= []
@@ -63,7 +78,10 @@ module Facter
           def add_mtu(lifreq)
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFMTU, lifreq, lifreq.ss_family)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            if ioctl == -1
+              @log.error("Cold not read MTU, error code is #{::FFI::LastError.error}")
+              return
+            end
 
             @interfaces[lifreq.name][:mtu] ||= lifreq[:lifr_lifru][:lifru_metric]
           end
@@ -74,11 +92,12 @@ module Facter
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFNETMASK, netmask_lifreq, lifreq.ss_family)
 
             if ioctl == -1
-              @log.debug("Error! #{::FFI::LastError.error}")
-            else
-              netmask = inet_ntop(netmask_lifreq, lifreq.ss_family)
-              [netmask, calculate_mask_length(netmask)]
+              @log.error("Could not read Netmask, error code is: #{::FFI::LastError.error}")
+              return
             end
+
+            netmask = inet_ntop(netmask_lifreq, lifreq.ss_family)
+            [netmask, Facter::Util::Resolvers::Networking.calculate_mask_length(netmask)]
           end
 
           def inet_ntop(lifreq, ss_family)
@@ -100,7 +119,7 @@ module Facter
 
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFNUM, lifnum)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            @log.error("Could not read interface count, error code is: #{::FFI::LastError.error}") if ioctl == -1
 
             lifnum[:lifn_count]
           end
@@ -112,7 +131,14 @@ module Facter
 
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFCONF, lifconf)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            # we need to enlarge the scope of this pointer so that Ruby GC will not free the memory.
+            # If the pointer if freed, Lifreq structures will contain garbage from memory.
+            @long_living_pointer = lifconf
+
+            if ioctl == -1
+              @log.error("Could not read interface information, error code is: #{::FFI::LastError.error}")
+              return []
+            end
 
             interfaces = []
             interface_count.times do |i|
@@ -121,24 +147,6 @@ module Facter
 
             interfaces
           end
-
-          def calculate_mask_length(netmask)
-            ipaddr = IPAddr.new(netmask)
-            ipaddr.to_i.to_s(2).count('1')
-          end
-
-          def primary_interface
-            result = Facter::Core::Execution.execute('route -n get default', logger: log)
-
-            @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
-          end
-
-          def add_dhcp(interface_name)
-            dhcpinfo_command = Facter::Core::Execution.which('dhcpinfo') || '/sbin/dhcpinfo'
-            result = Facter::Core::Execution.execute("#{dhcpinfo_command} -i #{interface_name} ServerID", logger: log)
-
-            @interfaces[interface_name][:dhcp] = result.chomp
-          end
         end
       end
     end

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

@@ -4,19 +4,20 @@ module Facter
   module Resolvers
     module Solaris
       class OsRelease < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         OS_VERSION_REGEX_PATTERNS = ['Solaris \d+ \d+/\d+ s(\d+)[sx]?_u(\d+)wos_',
                                      'Solaris (\d+)[.](\d+)', 'Solaris (\d+)'].freeze
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { build_release_facts(fact_name) }
           end
 
           def build_release_facts(fact_name)
-            result = Util::FileHelper.safe_read('/etc/release', nil)
+            result = Facter::Util::FileHelper.safe_read('/etc/release', nil)
             return @fact_list[fact_name] = nil if result.nil?
 
             OS_VERSION_REGEX_PATTERNS.each do |os_version_regex|

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

@@ -4,11 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class Processors < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { collect_kstat_info(fact_name) }
           end
 

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

@@ -4,12 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class Zone < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { build_zone_fact(fact_name) }
           end
 

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

@@ -4,12 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class ZoneName < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { build_current_zone_name_fact(fact_name) }
           end
 

data/lib/facter/resolvers/specific_release_file.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SpecificReleaseFile < BaseResolver
+      # :release
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, options)
+          @fact_list.fetch(fact_name) { read_release_file(fact_name, options) }
+        end
+
+        def read_release_file(fact_name, options)
+          release_file = options[:release_file]
+          return unless release_file
+
+          output = Facter::Util::FileHelper.safe_read(release_file, nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          if options[:regex]
+            @fact_list[:release] = output.strip =~ /#{options[:regex]}/ ? Regexp.last_match : nil
+            return @fact_list[fact_name]
+          end
+
+          @fact_list[:release] = output.strip
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/{ssh_resolver.rb → ssh.rb}

@@ -2,15 +2,18 @@
 
 module Facter
   module Resolvers
-    class SshResolver < BaseResolver
+    class Ssh < BaseResolver
       @log = Facter::Log.new(self)
-      @fact_list ||= {}
+
+      init_resolver
+
       FILE_NAMES = %w[ssh_host_rsa_key.pub ssh_host_dsa_key.pub ssh_host_ecdsa_key.pub ssh_host_ed25519_key.pub].freeze
       FILE_PATHS = %w[/etc/ssh /usr/local/etc/ssh /etc /usr/local/etc /etc/opt/ssh].freeze
+
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
         end
 
@@ -20,11 +23,12 @@ module Facter
             next unless File.directory?(file_path)
 
             FILE_NAMES.each do |file_name|
-              file_content = Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
+              file_content = Facter::Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
               next unless file_content
 
               key_type, key = file_content.split(' ')
-              ssh_list << ::Resolvers::Utils::SshHelper.create_ssh(key_type, key)
+              ssh = Facter::Util::Resolvers::SshHelper.create_ssh(key_type, key)
+              ssh_list << ssh if ssh
             end
           end
           @fact_list[:ssh] = ssh_list

data/lib/facter/resolvers/{suse_release_resolver.rb → suse_release.rb}

@@ -7,17 +7,17 @@ module Facter
       # :version
       # :codename
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_suse_release(fact_name) }
         end
 
         def read_suse_release(fact_name)
-          output = Util::FileHelper.safe_read('/etc/SuSE-release', nil)
+          output = Facter::Util::FileHelper.safe_read('/etc/SuSE-release', nil)
           return @fact_list[fact_name] = nil if output.nil?
 
           output_strings = output.split(' ')

data/lib/facter/resolvers/{sw_vers_resolver.rb → sw_vers.rb}

@@ -6,13 +6,13 @@ module Facter
       # :productname
       # :productversion
       # :buildversion
-      #
-      @fact_list ||= {}
+
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { software_version_system_call(fact_name) }
         end
 

data/lib/facter/resolvers/{timezone_resolver.rb → timezone.rb}

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class Timezone < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { determine_timezone }
         end
 

data/lib/facter/resolvers/{uname_resolver.rb → uname.rb}

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class Uname < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { uname_system_call(fact_name) }
         end
 

data/lib/facter/resolvers/{uptime_resolver.rb → uptime.rb}

@@ -3,17 +3,17 @@
 module Facter
   module Resolvers
     class Uptime < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { uptime_system_call(fact_name) }
         end
 
         def uptime_system_call(fact_name)
-          seconds = Facter::UptimeParser.uptime_seconds_unix
+          seconds = Facter::Util::Facts::UptimeParser.uptime_seconds_unix
           build_fact_list(seconds)
 
           @fact_list[fact_name]
@@ -22,7 +22,7 @@ module Facter
         def build_fact_list(seconds)
           return @fact_list[:uptime] = 'unknown' unless seconds
 
-          @fact_list = Utils::UptimeHelper.create_uptime_hash(seconds)
+          @fact_list = Facter::Util::Resolvers::UptimeHelper.create_uptime_hash(seconds)
         end
       end
     end

data/lib/facter/resolvers/virt_what.rb

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class VirtWhat < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { retrieve_from_virt_what(fact_name) }
         end
 

data/lib/facter/resolvers/vmware.rb

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class Vmware < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { vmware_command(fact_name) }
         end