facter 4.0.28 → 4.0.29

data/lib/facts/macosx/system_profiler/hardware_uuid.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_hardware_uuid'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:hardware_uuid)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:hardware_uuid)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/kernel_version.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_kernel_version'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:kernel_version)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:kernel_version)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/l2_cache_per_core.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_l2_cache_per_core'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:l2_cache_per_core)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:l2_cache_per_core)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/l3_cache.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_l3_cache'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:l3_cache)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:l3_cache)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/memory.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_memory'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:memory)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:memory)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/model_identifier.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_machine_model'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:model_identifier)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:model_identifier)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/model_name.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_machine_name'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:model_name)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:model_name)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/processor_name.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_processor_name'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:processor_name)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:processor_name)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/processor_speed.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_current_processor_speed'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:processor_speed)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:processor_speed)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/processors.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_cpu_type'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:number_of_processors)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:number_of_processors)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/secure_virtual_memory.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_secure_vm'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:secure_virtual_memory)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:secure_virtual_memory)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/serial_number.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_serial_number'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:serial_number_system)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:serial_number_system)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/smc_version.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_smc_version_system'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:smc_version_system)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:smc_version_system)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/system_version.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_os_version'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:system_version)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:system_version)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/uptime.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_uptime'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:time_since_boot)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:time_since_boot)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/system_profiler/username.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = 'sp_user_name'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::SystemProfiler.resolve(:user_name)
+          fact_value = Facter::Resolvers::Macosx::SystemProfiler.resolve(:user_name)
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end

data/lib/facts/macosx/virtual.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facts
+  module Macosx
+    class Virtual
+      FACT_NAME = 'virtual'
+
+      def call_the_resolver
+        fact_value = check_vmware || check_virtualbox || check_parallels
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+
+      private
+
+      def check_vmware
+        model_identifier = Facter::Resolvers::Macosx::SystemProfiler.resolve(:model_identifier)
+        return 'vmware' if model_identifier&.start_with?('VMware')
+      end
+
+      def check_virtualbox
+        boot_rom_version = Facter::Resolvers::Macosx::SystemProfiler.resolve(:boot_rom_version)
+        return 'virtualbox' if boot_rom_version&.start_with?('VirtualBox')
+      end
+
+      def check_parallels
+        subsystem_vendor_id = Facter::Resolvers::Macosx::SystemProfiler.resolve(:subsystem_vendor_id)
+        return 'parallels' if subsystem_vendor_id&.start_with?('0x1ab8')
+      end
+    end
+  end
+end

data/lib/resolvers/aix/networking_resolver.rb

@@ -15,17 +15,59 @@ module Facter
           end
 
           def read_netstat(fact_name)
+            @fact_list[:interfaces] = {}
             output = Facter::Core::Execution.execute('netstat -rn', logger: log)
-            output = output.split("\n").select { |line| (line =~ /\s\s[0-9]+.[0-9]+.[0-9]+.[0-9]+|\s\s.*:[0-9a-f]+/) }
-            get_primary_interface_info(output)
+            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)
 
+            populate_with_mtu_and_mac!(@fact_list[:interfaces])
+            get_primary_interface_info(output)
+            ::Resolvers::Utils::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(' ')
-            @fact_list[:primary] = primary_interface_info[5]
-            @fact_list[:ip] = primary_interface_info[1]
+            primary_interface_info = output.find { |line| line =~ /=>/ }&.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)
+          end
+
+          def populate_with_mtu_and_mac!(interfaces)
+            output = Facter::Core::Execution.execute('netstat -in', logger: log)
+            output.each_line do |line|
+              next if line =~ /Name\s/
+
+              info = line.split("\s")
+              interface_name = info[0]
+              mac = info[3][/^([0-9a-f]{1,2}[\.:-]){5}([0-9a-f]{1,2})$/]
+              interfaces[interface_name][:mtu] = info[1].to_i
+              interfaces[interface_name][:mac] = format_mac_address(mac) if mac
+            end
+          end
+
+          def format_mac_address(address)
+            address.split('.').map { |e| format('%<mac_address>02s', mac_address: e) }.join(':').tr(' ', '0')
           end
         end
       end

data/lib/resolvers/macosx/{networking.rb → networking_resolver.rb}

@@ -16,11 +16,8 @@ module Facter
 
           def read_facts(fact_name)
             primary_interface
-            dhcp
             interfaces_data
-            unless @fact_list[:interfaces].nil?
-              ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list[:interfaces])
-            end
+            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
             @fact_list[fact_name]
           end
 
@@ -30,15 +27,6 @@ module Facter
             @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
           end
 
-          def dhcp
-            return if @fact_list[:primary_interface].nil?
-
-            result = Facter::Core::Execution.execute("ipconfig getoption #{@fact_list[:primary_interface]} " \
-                                                       'server_identifier', logger: log)
-
-            @fact_list[:dhcp] = result.match(/^[\d.a-f:\s]+$/)&.to_s&.strip
-          end
-
           def interfaces_data
             command_response = Facter::Core::Execution.execute('ifconfig -a', logger: log)
 
@@ -55,37 +43,47 @@ module Facter
             parsed_interfaces_data = {}
             interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
 
-            interfaces_data.each do |interface, properties|
-              values = {}
+            interfaces_data.each do |interface_name, raw_data|
+              parsed_interface_data = {}
 
-              extract_mtu(properties, values)
-              extract_mac(properties, values)
-              extract_ip_data(properties, values)
+              extract_mtu(raw_data, parsed_interface_data)
+              extract_mac(raw_data, parsed_interface_data)
+              extract_dhcp(interface_name, raw_data, parsed_interface_data)
+              extract_ip_data(raw_data, parsed_interface_data)
 
-              parsed_interfaces_data[interface] = values
+              parsed_interfaces_data[interface_name] = parsed_interface_data
             end
             @fact_list[:interfaces] = parsed_interfaces_data unless parsed_interfaces_data.empty?
           end
 
-          def extract_mtu(properties, values)
-            mtu = properties.match(/mtu\s+(\d+)/)&.captures&.first&.to_i
-            values[:mtu] = mtu unless mtu.nil?
+          def extract_mtu(raw_data, parsed_interface_data)
+            mtu = raw_data.match(/mtu\s+(\d+)/)&.captures&.first&.to_i
+            parsed_interface_data[:mtu] = mtu unless mtu.nil?
           end
 
-          def extract_mac(properties, values)
-            mac = properties.match(/(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/)&.captures&.first
-            values[:mac] = mac unless mac.nil?
+          def extract_mac(raw_data, parsed_interface_data)
+            mac = raw_data.match(/(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/)&.captures&.first
+            parsed_interface_data[:mac] = mac unless mac.nil?
+          end
+
+          def extract_dhcp(interface_name, raw_data, parsed_interface_data)
+            return unless raw_data =~ /status:\s+active/
+
+            result = Facter::Core::Execution.execute("ipconfig getoption #{interface_name} " \
+                                                       'server_identifier', logger: log)
+
+            parsed_interface_data[:dhcp] = result.match(/^[\d.a-f:\s]+$/)&.to_s&.strip unless result.empty?
           end
 
-          def extract_ip_data(properties, values)
-            ip = extract_values(properties, /inet (\S+)/)
-            mask = extract_values(properties, /netmask (\S+)/).map { |val| val.hex.to_s(2).count('1') }
+          def extract_ip_data(raw_data, parsed_interface_data)
+            ip = extract_values(raw_data, /inet (\S+)/)
+            mask = extract_values(raw_data, /netmask (\S+)/).map { |val| val.hex.to_s(2).count('1') }
 
-            ip6 = extract_values(properties, /inet6 (\S+)/).map { |val| val.gsub(/%.+/, '') }
-            mask6 = extract_values(properties, /prefixlen (\S+)/)
+            ip6 = extract_values(raw_data, /inet6 (\S+)/).map { |val| val.gsub(/%.+/, '') }
+            mask6 = extract_values(raw_data, /prefixlen (\S+)/)
 
-            values[:bindings] = create_bindings(ip, mask) unless ip.empty?
-            values[:bindings6] = create_bindings(ip6, mask6) unless ip6.empty?
+            parsed_interface_data[:bindings] = create_bindings(ip, mask) unless ip.empty?
+            parsed_interface_data[:bindings6] = create_bindings(ip6, mask6) unless ip6.empty?
           end
 
           def extract_values(data, regex)

data/lib/resolvers/macosx/system_profiler_resolver.rb

@@ -2,59 +2,43 @@
 
 module Facter
   module Resolvers
-    class SystemProfiler < BaseResolver
-      # model_name
-      # model_identifier
-      # processor_name
-      # processor_speed
-      # number_of_processors
-      # total_number_of_cores
-      # l2_cache_per_core
-      # l3_cache
-      # hyper-threading_technology
-      # memory
-      # boot_rom_version
-      # serial_number_system
-      # hardware_uuid
-      # activation_lock_status
-      # system_version
-      # kernel_version
-      # boot_volume
-      # boot_mode
-      # computer_name
-      # user_name
-      # secure_virtual_memory
-      # system_integrity_protection
-      # time_since_boot
-      # smc_version_system
-
-      @semaphore = Mutex.new
-      @fact_list = {}
-
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { retrieve_system_profiler(fact_name) }
-        end
-
-        def retrieve_system_profiler(fact_name)
-          @fact_list ||= {}
-
-          log.debug 'Executing command: system_profiler SPSoftwareDataType SPHardwareDataType'
-          output = Facter::Core::Execution.execute(
-            'system_profiler SPHardwareDataType SPSoftwareDataType', logger: log
-          ).force_encoding('UTF-8')
-          @fact_list = output.scan(/.*:[ ].*$/).map { |e| e.strip.match(/(.*?): (.*)/).captures }.to_h
-          normalize_factlist
-
-          @fact_list[fact_name]
-        end
-
-        def normalize_factlist
-          @fact_list = @fact_list.map do |k, v|
-            [k.downcase.tr(' ', '_').delete("\(\)").to_sym, v]
-          end.to_h
+    module Macosx
+      class SystemProfiler < BaseResolver
+        SP_HARDWARE_DATA_TYPE = %i[model_name model_identifier processor_speed number_of_processors processor_name
+                                   total_number_of_cores l2_cache_per_core l3_cache memory boot_rom_version
+                                   smc_version_system serial_number_system hardware_uuid hyper-threading_technology
+                                   activation_lock_status].freeze
+
+        SP_SOFTWARE_DATA_TYPE = %i[system_version kernel_version boot_volume boot_mode computer_name
+                                   user_name secure_virtual_memory system_integrity_protection time_since_boot].freeze
+
+        SP_ETHERNET_DATA_TYPE = %i[type bus vendor_id device_id subsystem_vendor_id
+                                   subsystem_id revision_id bsd_name kext_name location version].freeze
+
+        @semaphore = Mutex.new
+        @fact_list = {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { retrieve_system_profiler(fact_name) }
+          end
+
+          def retrieve_system_profiler(fact_name)
+            @fact_list ||= {}
+
+            case fact_name
+            when *SP_HARDWARE_DATA_TYPE
+              @fact_list.merge!(SystemProfileExecutor.execute('SPHardwareDataType'))
+            when *SP_SOFTWARE_DATA_TYPE
+              @fact_list.merge!(SystemProfileExecutor.execute('SPSoftwareDataType'))
+            when *SP_ETHERNET_DATA_TYPE
+              @fact_list.merge!(SystemProfileExecutor.execute('SPEthernetDataType'))
+            end
+
+            @fact_list[fact_name]
+          end
         end
       end
     end