facter 4.0.35 → 4.0.36

data/lib/facter/facts/solaris/zones.rb

@@ -28,7 +28,7 @@ module Facts
         end
 
         resolved_facts << Facter::ResolvedFact.new('solaris_zones.zones', zones)
-        resolved_facts << Facter::ResolvedFact.new('zones', results.count, :legacy)
+        resolved_facts << Facter::ResolvedFact.new('zones', results.count.to_s, :legacy)
 
         resolved_facts.flatten
       end

data/lib/facter/facts/windows/ec2_metadata.rb

@@ -6,14 +6,16 @@ module Facts
       FACT_NAME = 'ec2_metadata'
 
       def call_the_resolver
-        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
         fact_value = Facter::Resolvers::Ec2.resolve(:metadata)
 
-        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
       end
 
-      def aws?
+      private
+
+      def aws_hypervisors?
         virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
 
         virtual == 'kvm' || virtual =~ /xen/

data/lib/facter/facts/windows/ec2_userdata.rb

@@ -6,14 +6,16 @@ module Facts
       FACT_NAME = 'ec2_userdata'
 
       def call_the_resolver
-        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
         fact_value = Facter::Resolvers::Ec2.resolve(:userdata)
 
-        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
       end
 
-      def aws?
+      private
+
+      def aws_hypervisors?
         virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
 
         virtual == 'kvm' || virtual =~ /xen/

data/lib/facter/facts/windows/gce.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Gce
+      FACT_NAME = 'gce'
+
+      def call_the_resolver
+        virtualization = Facter::Resolvers::Virtualization.resolve(:virtual)
+
+        fact_value = virtualization&.include?('gce') ? Facter::Resolvers::Gce.resolve(:metadata) : nil
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/networking/scope6.rb

@@ -5,11 +5,13 @@ module Facts
     module Networking
       class Scope6
         FACT_NAME = 'networking.scope6'
+        ALIASES = 'scope6'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Windows::Networking.resolve(:scope6)
 
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+           Facter::ResolvedFact.new('scope6', fact_value, :legacy)]
         end
       end
     end

data/lib/facter/facts/windows/sshalgorithmkey.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/sshfp_algorithm.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end

data/lib/facter/facts_utils/facts_utils.rb

@@ -6,5 +6,7 @@ module Facter
                          'KVM' => 'kvm', 'Virtual Machine' => 'hyperv', 'RHEV Hypervisor' => 'rhev',
                          'oVirt Node' => 'ovirt', 'HVM domU' => 'xenhvm', 'Bochs' => 'bochs', 'OpenBSD' => 'vmm',
                          'BHYVE' => 'bhyve' }.freeze
+
+    PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
   end
 end

data/lib/facter/framework/core/fact/internal/core_fact.rb

@@ -9,6 +9,8 @@ module Facter
     def create
       fact_class = @searched_fact.fact_class
 
+      return unless fact_class
+
       fact_class.new.call_the_resolver
     end
   end

data/lib/facter/framework/core/fact/internal/internal_fact_manager.rb

@@ -6,9 +6,8 @@ module Facter
 
     def resolve_facts(searched_facts)
       internal_searched_facts = filter_internal_facts(searched_facts)
-      threads = start_threads(internal_searched_facts)
-      resolved_facts = join_threads(threads, internal_searched_facts)
 
+      resolved_facts = resolve(internal_searched_facts)
       nil_resolved_facts = resolve_nil_facts(searched_facts)
 
       resolved_facts.concat(nil_resolved_facts)
@@ -29,36 +28,22 @@ module Facter
       resolved_facts
     end
 
-    def start_threads(searched_facts)
-      threads = []
-      # only resolve a fact once, even if multiple search facts depend on that fact
+    def resolve(searched_facts)
+      resolved_facts = []
+
       searched_facts
         .uniq { |searched_fact| searched_fact.fact_class.name }
         .each do |searched_fact|
-        threads << Thread.new do
-          begin
-            fact = CoreFact.new(searched_fact)
-            fact.create
-          rescue StandardError => e
-            @@log.log_exception(e)
-            nil
-          end
+        begin
+          fact = CoreFact.new(searched_fact)
+          fact_value = fact.create
+          resolved_facts << fact_value unless fact_value.nil?
+        rescue StandardError => e
+          @@log.log_exception(e)
         end
       end
 
-      threads
-    end
-
-    def join_threads(threads, searched_facts)
-      resolved_facts = []
-
-      threads.each do |thread|
-        thread.join
-        resolved_facts << thread.value unless thread.value.nil?
-      end
-
       resolved_facts.flatten!
-
       FactAugmenter.augment_resolved_facts(searched_facts, resolved_facts)
     end
   end

data/lib/facter/framework/core/fact_filter.rb

@@ -7,6 +7,8 @@ module Facter
   class FactFilter
     def filter_facts!(searched_facts)
       filter_legacy_facts!(searched_facts)
+      filter_blocked_legacy_facts!(searched_facts)
+
       searched_facts.each do |fact|
         fact.value = if fact.filter_tokens.any? && fact.value.respond_to?(:dig)
                        fact.value.dig(*fact.filter_tokens)
@@ -18,6 +20,17 @@ module Facter
 
     private
 
+    # This will filter out the legacy facts that should be blocked. Because some legacy facts are just aliases
+    # to the core ones, even if they are blocked, facter will resolved them but they won't be displayed.
+
+    def filter_blocked_legacy_facts!(facts)
+      blocked_facts = Options[:blocked_facts] || []
+
+      facts.reject! do |fact|
+        blocked_facts.select { |blocked_fact| fact.name.match(/^#{blocked_fact}/) && fact.type == :legacy }.any?
+      end
+    end
+
     def filter_legacy_facts!(resolved_facts)
       return unless !Options[:show_legacy] && Options[:user_query].empty?
 

data/lib/facter/framework/core/fact_loaders/fact_loader.rb

@@ -64,11 +64,34 @@ module Facter
     def block_facts(facts, options)
       blocked_facts = options[:blocked_facts] || []
 
+      reject_list_core, reject_list_legacy = construct_reject_lists(blocked_facts, facts)
+
       facts = facts.reject do |fact|
-        blocked_facts.select { |blocked_fact| fact.name.match(/^#{blocked_fact}/) }.any?
+        reject_list_core.include?(fact) || reject_list_core.find do |fact_to_block|
+          fact_to_block.klass == fact.klass
+        end || reject_list_legacy.include?(fact)
       end
 
       facts
     end
+
+    def construct_reject_lists(blocked_facts, facts)
+      reject_list_core = []
+      reject_list_legacy = []
+
+      blocked_facts.each do |blocked|
+        facts.each do |fact|
+          next unless fact.name =~ /^#{blocked}/
+
+          if fact.type == :core
+            reject_list_core << fact
+          else
+            reject_list_legacy << fact
+          end
+        end
+      end
+
+      [reject_list_core, reject_list_legacy]
+    end
   end
 end

data/lib/facter/framework/formatters/legacy_fact_formatter.rb

@@ -26,7 +26,8 @@ module Facter
       pretty_json = hash_to_facter_format(fact_collection)
 
       pretty_json = remove_enclosing_accolades(pretty_json)
-      remove_comma_and_quotation(pretty_json)
+      pretty_json = remove_comma_and_quotation(pretty_json)
+      handle_newlines(pretty_json)
     end
 
     def format_for_multiple_user_queries(user_queries, resolved_facts)
@@ -38,6 +39,7 @@ module Facter
       pretty_json = hash_to_facter_format(facts_to_display)
       pretty_json = remove_enclosing_accolades(pretty_json)
       pretty_json = remove_comma_and_quotation(pretty_json)
+      pretty_json = handle_newlines(pretty_json)
 
       @log.debug('Remove quotes from value if value is a string')
       pretty_json.gsub(/^(\S*) => \"(.*)\"/, '\1 => \2')
@@ -84,6 +86,11 @@ module Facter
       pretty_fact_json.gsub(/^},/, '}')
     end
 
+    def handle_newlines(pretty_fact_json)
+      @log.debug('Convert newline characters to actual newlines')
+      pretty_fact_json.gsub('\n', "\n")
+    end
+
     def remove_comma_and_quotation(output)
       # quotation marks that come after \ are not removed
       @log.debug('Remove unnecessary comma and quotation marks on root facts')

data/lib/facter/framework/formatters/yaml_fact_formatter.rb

@@ -56,7 +56,7 @@ module Facter
       return false if value[/^[0-9]+$/]
       return true if value =~ /y|Y|yes|Yes|YES|n|N|no|No|NO|True|TRUE|False|FALSE|on|On|ON|off|Off|OFF|:/
       return false if value[/[a-zA-Z]/]
-      return false if value[/[0-9]+\.[0-9]+\./]
+      return false if value[/[0-9]+\.[0-9]+/]
 
       true
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Serialnumber < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_serialnumber(fact_name) }
+          end
+
+          def read_serialnumber(fact_name)
+            odmquery = Facter::ODMQuery.new
+            odmquery
+              .equals('name', 'sys0')
+              .equals('attribute', 'systemid')
+            result = odmquery.execute
+
+            result.each_line do |line|
+              if line.include?('value')
+                @fact_list[:serialnumber] = line.split('=')[1].strip.delete('\"')[6..-1]
+                break
+              end
+            end
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/dmi_resolver.rb

@@ -12,6 +12,7 @@ module Facter
           # :bios_vendor
           # :bios_date
           # :bios_version
+          # :board_asset_tag
           # :board_vendor
           # :board_serial
           # :board_name
@@ -29,9 +30,9 @@ module Facter
           end
 
           def read_facts(fact_name)
-            files = %w[bios_date bios_vendor bios_version board_vendor board_name board_serial
-                       chassis_asset_tag chassis_type sys_vendor product_name product_serial
-                       product_uuid]
+            files = %w[bios_date bios_vendor bios_version board_asset_tag board_vendor board_name
+                       board_serial chassis_asset_tag chassis_type sys_vendor product_name
+                       product_serial product_uuid]
             return unless File.directory?('/sys/class/dmi')
 
             file_content = Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)

data/lib/facter/resolvers/ec2.rb

@@ -7,13 +7,13 @@ module Facter
       @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)
+          log.debug('Querying Ec2 metadata')
           @fact_list.fetch(fact_name) { read_facts(fact_name) }
         end
 
@@ -29,7 +29,7 @@ module Facter
           metadata.each_line do |line|
             next if line.empty?
 
-            http_path_component = build_path_compoent(line)
+            http_path_component = build_path_component(line)
             next if http_path_component == 'security-credentials/'
 
             if http_path_component.end_with?('/')
@@ -44,27 +44,13 @@ module Facter
           end
         end
 
-        def build_path_compoent(line)
+        def build_path_component(line)
           array_match = /^(\d+)=.*$/.match(line)
           array_match ? "#{array_match[1]}/" : line.strip
         end
 
         def get_data_from(url)
-          require 'net/http'
-
-          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)
+          Utils::Http.get_request(url, {}, { session: determine_session_timeout })
         end
 
         def determine_session_timeout

data/lib/facter/resolvers/gce.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Gce < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      METADATA_URL = 'http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=json'
+      HEADERS = { "Metadata-Flavor": 'Google', "Accept": 'application/json' }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          log.debug('reading Gce metadata')
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = query_for_metadata
+          @fact_list[fact_name]
+        end
+
+        def query_for_metadata
+          gce_data = extract_to_hash(Utils::Http.get_request(METADATA_URL, HEADERS))
+          parse_instance(gce_data)
+
+          gce_data.empty? ? nil : gce_data
+        end
+
+        def extract_to_hash(metadata)
+          JSON.parse(metadata)
+        rescue JSON::ParserError => e
+          log.debug("Trying to parse result but got: #{e.message}")
+          {}
+        end
+
+        def parse_instance(gce_data)
+          instance_data = gce_data['instance']
+          return if instance_data.nil? || instance_data.empty?
+
+          %w[image machineType zone].each do |key|
+            instance_data[key] = instance_data[key].split('/').last if instance_data[key]
+          end
+
+          network = instance_data.dig('networkInterfaces', 0, 'network')
+          instance_data['networkInterfaces'][0]['network'] = network.split('/').last unless network.nil?
+
+          gce_data['instance'] = instance_data
+        end
+      end
+    end
+  end
+end