facter 4.0.26 → 4.0.28

data/acceptance/tests/options/verbose.rb

@@ -0,0 +1,12 @@
+# This test is intended to ensure that the --verbose command-line option
+# works properly. This option provides verbose (INFO) output to stderr.
+test_name "C99986: --verbose command-line option prints verbose information to stderr" do
+
+  agents.each do |agent|
+    step "Agent #{agent}: retrieve verbose info from stderr using --verbose option" do
+      on(agent, facter('--verbose')) do
+        assert_match(/INFO .* executed with command line: --verbose/, stderr, "Expected stderr to contain verbose (INFO) statements")
+      end
+    end
+  end
+end

data/acceptance/tests/options/version.rb

@@ -0,0 +1,12 @@
+# This test is intended to ensure that the --version command-line option works
+# properly. This option outputs the current Facter version.
+test_name "C99983: --version command-line option returns the version string" do
+
+  agents.each do |agent|
+    step "Agent #{agent}: retrieve version info using the --version option" do
+      on(agent, facter('--version')) do
+        assert_match(/\d+\.\d+\.\d+/, stdout, "Output #{stdout} is not a recognized version string")
+      end
+    end
+  end
+end

data/acceptance/tests/options/yaml.rb

@@ -0,0 +1,43 @@
+# This test is intended to ensure that the --yaml command-line option works
+# properly. This option causes Facter to output facts in YAML format.
+# A custom fact is used to test for parity between Facter's output and
+# the expected YAML output.
+test_name "C99967: --yaml command-line option results in valid YAML output" do
+
+  require 'yaml'
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  content = <<EOM
+Facter.add('structured_fact') do
+  setcode do
+    { "foo" => {"nested" => "value1"}, "bar" => "value2", "baz" => "value3" }
+  end
+end
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create a structured custom fact" do
+      custom_dir = get_user_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      custom_fact = File.join(custom_dir, 'custom_fact.rb')
+      on(agent, "mkdir -p '#{custom_dir}'")
+      create_remote_file(agent, custom_fact, content)
+      on(agent, "chmod +x '#{custom_fact}'")
+
+      teardown do
+        on(agent, "rm -f '#{custom_fact}'")
+      end
+
+      step "Agent #{agent}: retrieve output using the --yaml option" do
+        on(agent, facter("--custom-dir '#{custom_dir}' --yaml structured_fact")) do
+          begin
+            expected = {"structured_fact" => {"foo" => {"nested" => "value1"}, "bar" => "value2", "baz" => "value3" }}
+            assert_equal(expected, YAML.load(stdout), "YAML output does not match expected output")
+          rescue
+            fail_test "Couldn't parse output as YAML"
+          end
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/ticket_1123_facter_with_invalid_locale.rb

@@ -0,0 +1,23 @@
+test_name 'C89524: facter should not crash with invalid locale setting' do
+  tag 'risk:high', 'facter_3'
+
+
+  confine :except, :platform => 'windows'
+  confine :except, :platform => /^cisco_/ # See CISCO-43
+  confine :except, :platform => /^huawei/ # See HUAWEI-24
+
+  agents.each do |agent|
+    step 'facter should run when started with an invalid locale' do
+      on(agent, facter('facterversion'), :environment => {'LANG' => 'ABCD'}) do |facter_output|
+        assert_match(/^\d+\.\d+\.\d+$/, facter_output.stdout, 'facter did not continue running')
+
+        if agent['platform'] !~ /solaris|aix|cumulus|osx/
+          step 'facter should return an error message when started with an invalid locale' do
+            assert_match(/locale environment variables were bad; continuing with LANG=C LC_ALL=C/, facter_output.stderr,
+                         'Expected facter to return a locale error message')
+          end
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/ticket_1238_hostname_fqdn.rb

@@ -0,0 +1,57 @@
+test_name 'C93827: facter fqdn should return the hostname when its a fully qualified domain name' do
+  tag 'risk:high'
+  require 'timeout'
+
+  confine :except, :platform => 'windows'
+
+  fqdn = 'foo.bar.example.org'
+  fqdn_long = 'a23456789.b23456789.c23456789.d23456789.e23456789.f23456789.wxyz'
+
+  agents.each do |agent|
+    orig_hostname = on(agent, 'hostname').stdout.chomp
+
+    teardown do
+      step 'restore original hostname' do
+        on(agent, "hostname #{orig_hostname}")
+      end
+    end
+
+    step "set hostname as #{fqdn}" do
+      on(agent, "hostname #{fqdn}")
+      begin
+        Timeout.timeout(20) do
+          until on(agent, 'hostname').stdout =~ /#{fqdn}/
+            sleep(0.25) # on Solaris 11 hostname returns before the hostname is updated
+          end
+        end
+      rescue Timeout::Error
+        raise "Failed to reset the hostname of the test machine to #{fqdn}"
+      end
+    end
+
+    step 'validate facter uses hostname as the fqdn if its a fully qualified domain name' do
+      on(agent, 'facter fqdn') do |facter_output|
+        assert_equal(fqdn, facter_output.stdout.chomp, 'facter did not return the hostname set by the test')
+      end
+    end
+  end
+
+  step "long hostname as #{fqdn_long}" do
+    on(agent, "hostname #{fqdn_long}")
+    begin
+      Timeout.timeout(20) do
+        until on(agent, 'hostname').stdout =~ /#{fqdn_long}/
+          sleep(0.25) # on Solaris 11 hostname returns before the hostname is updated
+        end
+      end
+    rescue Timeout::Error
+      raise "Failed to reset the hostname of the test machine to #{fqdn_long}"
+    end
+  end
+
+  step 'validate facter uses hostname as the LONG fqdn if its a fully qualified domain name' do
+    on(agent, 'facter fqdn') do |facter_output|
+      assert_equal(fqdn_long, facter_output.stdout.chomp, 'facter did not return the hostname set by the test')
+    end
+  end
+end

data/lib/custom_facts/core/execution/base.rb

@@ -6,6 +6,8 @@ module Facter
       class Base
         STDERR_MESSAGE = 'Command %s resulted with the following stderr message: %s'
 
+        # This is part of the public API. No race condition can happen
+        # here because custom facts are executed sequentially
         def with_env(values)
           old = {}
           values.each do |var, value|
@@ -38,27 +40,22 @@ module Facter
           expand = options.fetch(:expand, true)
           logger = options[:logger]
 
-          # Set LC_ALL and LANG to force i18n to C for the duration of this exec;
-          # this ensures that any code that parses the
-          # output of the command can expect it to be in a consistent / predictable format / locale
-          with_env 'LC_ALL' => 'C', 'LANG' => 'C' do
-            expanded_command = if !expand && builtin_command?(command) || logger
-                                 command
-                               else
-                                 expand_command(command)
-                               end
+          expanded_command = if !expand && builtin_command?(command) || logger
+                               command
+                             else
+                               expand_command(command)
+                             end
 
-            if expanded_command.nil?
-              if on_fail == :raise
-                raise Facter::Core::Execution::ExecutionFailure.new,
-                      "Could not execute '#{command}': command not found"
-              end
-
-              return on_fail
+          if expanded_command.nil?
+            if on_fail == :raise
+              raise Facter::Core::Execution::ExecutionFailure.new,
+                    "Could not execute '#{command}': command not found"
             end
 
-            execute_command(expanded_command, on_fail, logger)
+            return on_fail
           end
+
+          execute_command(expanded_command, on_fail, logger)
         end
 
         private
@@ -82,7 +79,10 @@ module Facter
 
         def execute_command(command, on_fail, logger = nil)
           begin
-            out, stderr, _status_ = Open3.capture3(command.to_s)
+            # Set LC_ALL and LANG to force i18n to C for the duration of this exec;
+            # this ensures that any code that parses the
+            # output of the command can expect it to be in a consistent / predictable format / locale
+            out, stderr, _status_ = Open3.capture3({ 'LC_ALL' => 'C', 'LANG' => 'C' }, command.to_s)
             log_stderr(stderr, command, logger)
           rescue StandardError => e
             return '' if logger

data/lib/custom_facts/util/collection.rb

@@ -95,8 +95,7 @@ module LegacyFacter
         return @external_facts unless @external_facts.nil?
 
         load_external_facts
-        external_facts = @facts.select { |_k, v| v.options[:fact_type] == :external }
-        @external_facts = Facter::Utils.deep_copy(external_facts.keys)
+        @external_facts = @facts.select { |_k, v| v.options[:fact_type] == :external }
       end
 
       def invalidate_custom_facts
@@ -148,11 +147,7 @@ module LegacyFacter
 
       def value(name)
         fact = fact(name)
-        fact_value = fact&.value
-        return Facter.core_value(name) if fact_value.nil?
-
-        core_value = Facter.core_value(name) if fact.used_resolution_weight <= 0
-        core_value.nil? ? fact_value : core_value
+        fact&.value
       end
 
       private

data/lib/custom_facts/util/config.rb

@@ -8,7 +8,7 @@ module LegacyFacter
   module Util
     module Config
       def self.ext_fact_loader
-        @ext_fact_loader || LegacyFacter::Util::DirectoryLoader.default_loader
+        @ext_fact_loader || LegacyFacter::Util::DirectoryLoader.new
       end
 
       def self.ext_fact_loader=(loader)

data/lib/custom_facts/util/directory_loader.rb

@@ -30,55 +30,82 @@ module LegacyFacter
       EXTERNAL_FACT_WEIGHT = 10_000
 
       # Directory for fact loading
-      attr_reader :directory
+      attr_reader :directories
 
-      def initialize(dir, weight = nil)
-        @directory = dir
-        @weight = weight || EXTERNAL_FACT_WEIGHT
+      def initialize(dir = LegacyFacter::Util::Config.external_facts_dirs, weight = EXTERNAL_FACT_WEIGHT)
+        @directories = [dir].flatten
+        @weight = weight
       end
 
-      def self.loader_for(dir)
-        raise NoSuchDirectoryError unless File.directory?(dir)
+      # Load facts from files in fact directory using the relevant parser classes to
+      # parse them.
+      def load(collection)
+        weight = @weight
+
+        searched_facts, cached_facts = load_directory_entries(collection)
+
+        load_cached_facts(collection, cached_facts, weight)
 
-        LegacyFacter::Util::DirectoryLoader.new(dir)
+        load_searched_facts(collection, searched_facts, weight)
       end
 
-      def self.default_loader
-        loaders = LegacyFacter::Util::Config.external_facts_dirs.collect do |dir|
-          LegacyFacter::Util::DirectoryLoader.new(dir)
+      private
+
+      def load_directory_entries(_collection)
+        cm = Facter::CacheManager.new
+        facts = []
+        entries.each do |file|
+          basename = File.basename(file)
+          if facts.find { |f| f.name == basename } && cm.group_cached?(basename)
+            Facter.log_exception(Exception.new("Caching is enabled for group \"#{basename}\" while "\
+              'there are at least two external facts files with the same filename'))
+          else
+            searched_fact = Facter::SearchedFact.new(basename, nil, [], nil, :file)
+            searched_fact.file = file
+            facts << searched_fact
+          end
         end
-        LegacyFacter::Util::CompositeLoader.new(loaders)
+
+        cm.resolve_facts(facts)
       end
 
-      # Load facts from files in fact directory using the relevant parser classes to
-      # parse them.
-      def load(collection)
-        weight = @weight
-        entries.each do |file|
-          parser = LegacyFacter::Util::Parser.parser_for(file)
+      def load_cached_facts(collection, cached_facts, weight)
+        cached_facts.each do |cached_fact|
+          collection.add(cached_fact.name, value: cached_fact.value, fact_type: :external,
+                                           file: cached_fact.file) { has_weight(weight) }
+        end
+      end
+
+      def load_searched_facts(collection, searched_facts, weight)
+        searched_facts.each do |fact|
+          parser = LegacyFacter::Util::Parser.parser_for(fact.file)
           next if parser.nil?
 
           data = parser.results
           if data == false
-            LegacyFacter.warn "Could not interpret fact file #{file}"
+            LegacyFacter.warn "Could not interpret fact file #{fact.file}"
           elsif (data == {}) || data.nil?
-            LegacyFacter.warn "Fact file #{file} was parsed but returned an empty data set"
+            LegacyFacter.warn "Fact file #{fact.file} was parsed but returned an empty data set"
           else
-            data.each { |p, v| collection.add(p, value: v, fact_type: :external) { has_weight(weight) } }
+            data.each do |p, v|
+              collection.add(p, value: v, fact_type: :external,
+                                file: fact.file) { has_weight(weight) }
+            end
           end
         end
       end
 
-      private
-
       def entries
-        Dir.entries(directory).find_all { |f| should_parse?(f) }.sort.map { |f| File.join(directory, f) }
+        dirs = @directories.select { |directory| File.directory?(directory) }.map do |directory|
+          Dir.entries(directory).map { |directory_entry| File.join(directory, directory_entry) }
+        end
+        dirs.flatten.select { |f| should_parse?(f) }
       rescue Errno::ENOENT
         []
       end
 
       def should_parse?(file)
-        file !~ /^\./
+        File.basename(file) !~ /^\./
       end
     end
   end

data/lib/custom_facts/util/fact.rb

@@ -123,8 +123,10 @@ module Facter
           announce_when_no_suitable_resolution(suitable_resolutions)
           announce_when_no_value_found(@value)
 
-          @value
+          @value = resolve_value
         end
+
+        @value
       end
 
       # @api private
@@ -138,6 +140,13 @@ module Facter
 
       private
 
+      def resolve_value
+        return Facter.core_value(name) if @value.nil?
+
+        core_value = Facter.core_value(name) if @used_resolution_weight <= 0
+        core_value.nil? ? @value : core_value
+      end
+
       # Are we in the midst of a search?
       def searching?
         @searching

data/lib/custom_facts/util/resolution.rb

@@ -86,7 +86,7 @@ module Facter
       end
 
       def options(options)
-        accepted_options = %i[name value timeout weight fact_type]
+        accepted_options = %i[name value timeout weight fact_type file]
 
         accepted_options.each do |option_name|
           instance_variable_set("@#{option_name}", options.delete(option_name)) if options.key?(option_name)

data/lib/facts/aix/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facts/bsd/processors/count.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Bsd
+    module Processors
+      class Count
+        FACT_NAME = 'processors.count'
+        ALIASES = 'processorcount'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Bsd::Processors.resolve(:logical_count)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facts/bsd/processors/models.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Facts
+  module Bsd
+    module Processors
+      class Models
+        FACT_NAME = 'processors.models'
+        ALIASES = 'processor.*'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Bsd::Processors.resolve(:models)
+          return nil unless fact_value
+
+          facts = [Facter::ResolvedFact.new(FACT_NAME, fact_value)]
+          fact_value.each_with_index do |value, index|
+            facts.push(Facter::ResolvedFact.new("processor#{index}", value, :legacy))
+          end
+          facts
+        end
+      end
+    end
+  end
+end