facter 4.0.8.pre → 4.0.9.pre

data/.travis.yml

@@ -1,4 +1,4 @@
-sudo: false
+os: linux
 language: ruby
 cache:
   bundler: true
@@ -12,7 +12,7 @@ before_install:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
   - chmod +x ./cc-test-reporter
   - ./cc-test-reporter before-build
-matrix:
+jobs:
   include:
     - rvm: 2.6
       script:

data/VERSION

@@ -1 +1 @@
-4.0.8.pre
+4.0.9.pre

data/agent/facter-ng.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'coveralls', '~> 0.8.23'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.74.0'
   spec.add_development_dependency 'rubycritic', '~> 4.1.0'

data/facter.gemspec

@@ -37,7 +37,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'coveralls', '~> 0.8.23'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.74.0'
   spec.add_development_dependency 'rubocop-performance', '~> 1.5'

data/lib/custom_facts/util/collection.rb

@@ -136,15 +136,11 @@ module LegacyFacter
       def value(name)
         fact = fact(name)
 
-        return Facter.core_value(name) if fact.nil?
+        return Facter.core_value(name) if fact.nil? || fact.value.nil?
 
-        value = fact&.value
-        weight = fact&.used_resolution_weight || 0
+        core_value = Facter.core_value(name) if fact.used_resolution_weight <= 0
 
-        core_value = Facter.core_value(name)
-        return core_value if weight <= 0 && core_value
-
-        value
+        core_value.nil? ? fact.value : core_value
       end
 
       private

data/lib/custom_facts/util/fact.rb

@@ -20,6 +20,7 @@ module LegacyFacter
       # Fact options e.g. fact_type
       attr_accessor :options
 
+      # Weight of the resolution that was used to obtain the fact value
       attr_accessor :used_resolution_weight
 
       # Creates a new fact, with no resolution mechanisms. See {Facter.add}
@@ -32,12 +33,14 @@ module LegacyFacter
       def initialize(name, options = {})
         @name = name.to_s.downcase.intern
 
+        @options = Facter::Utils.deep_copy(options)
         extract_ldapname_option!(options)
 
         @ldapname ||= @name.to_s
 
         @resolves = []
         @searching = false
+        @used_resolution_weight = 0
 
         @value = nil
       end
@@ -52,7 +55,7 @@ module LegacyFacter
       #
       # @api private
       def add(options = {}, &block)
-        @options = options
+        @options = Facter::Utils.deep_copy(@options.merge(options))
         define_resolution(nil, options, &block)
       end
 
@@ -158,7 +161,7 @@ module LegacyFacter
       end
 
       def sort_by_weight(resolutions)
-        resolutions.sort { |a, b| b.weight <=> a.weight }
+        resolutions.sort { |a, b| b.weight.to_i <=> a.weight.to_i }
       end
 
       def find_first_real_value(resolutions)
@@ -168,7 +171,7 @@ module LegacyFacter
           rescue Facter::ResolveCustomFactError
             break
           end
-          @used_resolution_weight = resolve.weight
+          @used_resolution_weight = resolve.weight || 0
           return value unless value.nil?
         end
         nil

data/lib/custom_facts/util/parser.rb

@@ -65,6 +65,17 @@ module LegacyFacter
         def parse_results
           raise ArgumentError, 'Subclasses must respond to parse_results'
         end
+
+        def parse_executable_output(output)
+          res = nil
+          begin
+            res = YAML.safe_load output
+          rescue Exception => e
+            Facter.debug("Could not parse executable fact output as YAML or JSON (#{e.message})")
+          end
+          res = KeyValuePairOutputFormat.parse output unless res.is_a?(Hash)
+          res
+        end
       end
 
       module KeyValuePairOutputFormat
@@ -120,7 +131,7 @@ module LegacyFacter
 
       class ScriptParser < Base
         def parse_results
-          KeyValuePairOutputFormat.parse LegacyFacter::Core::Execution.exec(quote(filename))
+          parse_executable_output(LegacyFacter::Core::Execution.exec(quote(filename)))
         end
 
         private
@@ -154,7 +165,7 @@ module LegacyFacter
           shell_command =
             "\"#{powershell}\" -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File \"#{filename}\""
           output = LegacyFacter::Core::Execution.exec(shell_command)
-          KeyValuePairOutputFormat.parse(output)
+          parse_executable_output(output)
         end
       end
 

data/lib/facter.rb

@@ -11,151 +11,167 @@ module Facter
   class ResolveCustomFactError < StandardError; end
 
   @options = Options.instance
+  Log.add_legacy_logger(STDOUT)
+  @logger = Log.new(self)
 
-  def self.[](name)
-    fact(name)
-  end
+  class << self
+    def [](name)
+      fact(name)
+    end
 
-  def self.add(name, options = {}, &block)
-    options[:fact_type] = :custom
-    LegacyFacter.add(name, options, &block)
-  end
+    def add(name, options = {}, &block)
+      options[:fact_type] = :custom
+      LegacyFacter.add(name, options, &block)
+    end
 
-  def self.clear
-    LegacyFacter.clear
-  end
+    def clear
+      LegacyFacter.clear
+    end
 
-  def self.core_value(user_query)
-    user_query = user_query.to_s
-    resolved_facts = Facter::FactManager.instance.resolve_core([user_query])
-    fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
-    splitted_user_query = Facter::Utils.split_user_query(user_query)
-    fact_collection.dig(*splitted_user_query)
-  end
+    def core_value(user_query)
+      user_query = user_query.to_s
+      resolved_facts = Facter::FactManager.instance.resolve_core([user_query])
+      fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
+      splitted_user_query = Facter::Utils.split_user_query(user_query)
+      fact_collection.dig(*splitted_user_query)
+    end
 
-  def self.debug(msg)
-    return unless debugging?
+    def debug(msg)
+      return unless debugging?
 
-    @logger ||= Log.new(self)
-    @logger.debug(msg)
-    nil
-  end
+      @logger.debug(msg)
+      nil
+    end
 
-  def self.debugging?
-    Options[:debug]
-  end
+    def on_message(&block)
+      Facter::Log.on_message(&block)
+    end
 
-  def self.debugging(debug_bool)
-    @options.priority_options = { debug: debug_bool }
-    @options.refresh
+    def debugging?
+      Options[:debug]
+    end
 
-    debug_bool
-  end
+    def debugging(debug_bool)
+      @options.priority_options[:debug] = debug_bool
+      @options.refresh
 
-  def self.fact(name)
-    fact = Facter::Util::Fact.new(name)
-    val = value(name)
-    fact.add({}) { setcode { val } }
-    fact
-  end
+      debug_bool
+    end
 
-  def self.log_errors(missing_names)
-    @logger ||= Log.new(self)
+    def fact(name)
+      fact = Facter::Util::Fact.new(name)
+      val = value(name)
+      fact.add({}) { setcode { val } }
+      fact
+    end
 
-    missing_names.each do |missing_name|
-      @logger.error("fact \"#{missing_name}\" does not exist.", true)
+    def log_errors(missing_names)
+      missing_names.each do |missing_name|
+        @logger.error("fact \"#{missing_name}\" does not exist.", true)
+      end
     end
-  end
 
-  def self.method_missing(name, *args, &block)
-    @logger ||= Log.new(self)
-    @logger.error(
-      "--#{name}-- not implemented but required \n" \
-      'with params: ' \
-      "#{args.inspect} \n" \
-      'with block: ' \
-      "#{block.inspect}  \n" \
-      "called by:  \n" \
-      "#{caller} \n"
-    )
-    nil
-  end
+    def method_missing(name, *args, &block)
+      @logger.error(
+        "--#{name}-- not implemented but required \n" \
+        'with params: ' \
+        "#{args.inspect} \n" \
+        'with block: ' \
+        "#{block.inspect}  \n" \
+        "called by:  \n" \
+        "#{caller} \n"
+      )
+      nil
+    end
 
-  def self.reset
-    LegacyFacter.reset
-  end
+    def reset
+      LegacyFacter.reset
+    end
 
-  def self.search(*dirs)
-    LegacyFacter.search(*dirs)
-  end
+    def search(*dirs)
+      LegacyFacter.search(*dirs)
+    end
 
-  def self.search_external(dirs)
-    LegacyFacter.search_external(dirs)
-  end
+    def search_external(dirs)
+      LegacyFacter.search_external(dirs)
+    end
 
-  def self.search_external_path
-    LegacyFacter.search_external_path
-  end
+    def search_external_path
+      LegacyFacter.search_external_path
+    end
 
-  def self.search_path
-    LegacyFacter.search_path
-  end
+    def search_path
+      LegacyFacter.search_path
+    end
 
-  def self.to_hash
-    @options.priority_options = { to_hash: true }
-    @options.refresh
-    resolved_facts = Facter::FactManager.instance.resolve_facts(@options)
-    CacheManager.invalidate_all_caches
-    FactCollection.new.build_fact_collection!(resolved_facts)
-  end
+    def to_hash
+      @options.priority_options[:to_hash] = true
+      @options.refresh
 
-  def self.to_user_output(cli_options, *args)
-    @options.priority_options = { is_cli: true }.merge!(cli_options.map { |(k, v)| [k.to_sym, v] }.to_h)
-    @options.refresh(args)
+      log_blocked_facts
 
-    resolved_facts = Facter::FactManager.instance.resolve_facts(@options, args)
-    CacheManager.invalidate_all_caches
-    fact_formatter = Facter::FormatterFactory.build(@options)
+      resolved_facts = Facter::FactManager.instance.resolve_facts
+      CacheManager.invalidate_all_caches
+      FactCollection.new.build_fact_collection!(resolved_facts)
+    end
 
-    status = error_check(args, resolved_facts)
+    def to_user_output(cli_options, *args)
+      @options.priority_options = { is_cli: true }.merge!(cli_options.map { |(k, v)| [k.to_sym, v] }.to_h)
+      @options.refresh(args)
+      @logger.info("executed with command line: #{ARGV.drop(1).join(' ')}")
+      log_blocked_facts
 
-    [fact_formatter.format(resolved_facts), status || 0]
-  end
+      resolved_facts = Facter::FactManager.instance.resolve_facts(args)
+      CacheManager.invalidate_all_caches
+      fact_formatter = Facter::FormatterFactory.build(@options)
 
-  def self.trace?
-    LegacyFacter.trace?
-  end
+      status = error_check(args, resolved_facts)
 
-  def self.trace(bool)
-    LegacyFacter.trace(bool)
-  end
+      [fact_formatter.format(resolved_facts), status || 0]
+    end
 
-  def self.value(user_query)
-    @options.refresh([user_query])
-    user_query = user_query.to_s
-    resolved_facts = Facter::FactManager.instance.resolve_facts(@options, [user_query])
-    CacheManager.invalidate_all_caches
-    fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
-    splitted_user_query = Facter::Utils.split_user_query(user_query)
-    fact_collection.dig(*splitted_user_query)
-  end
+    def trace?
+      LegacyFacter.trace?
+    end
 
-  def self.version
-    version_file = ::File.join(ROOT_DIR, 'VERSION')
-    ::File.read(version_file).strip
-  end
+    def trace(bool)
+      LegacyFacter.trace(bool)
+    end
 
-  private_class_method def self.error_check(args, resolved_facts)
-    if Options.instance[:strict]
-      missing_names = args - resolved_facts.map(&:user_query).uniq
-      if missing_names.count.positive?
-        status = 1
-        log_errors(missing_names)
-      else
-        status = nil
-      end
+    def value(user_query)
+      @options.refresh([user_query])
+      user_query = user_query.to_s
+      resolved_facts = Facter::FactManager.instance.resolve_facts([user_query])
+      CacheManager.invalidate_all_caches
+      fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
+      splitted_user_query = Facter::Utils.split_user_query(user_query)
+      fact_collection.dig(*splitted_user_query)
+    end
+
+    def version
+      version_file = ::File.join(ROOT_DIR, 'VERSION')
+      ::File.read(version_file).strip
     end
 
-    status
+    private
+
+    def log_blocked_facts
+      block_list = BlockList.instance.block_list
+      @logger.debug("blocking collection of #{block_list.join("\s")} facts") if block_list.any? && Options[:block]
+    end
+
+    def error_check(args, resolved_facts)
+      if Options.instance[:strict]
+        missing_names = args - resolved_facts.map(&:user_query).uniq
+        if missing_names.count.positive?
+          status = 1
+          log_errors(missing_names)
+        else
+          status = nil
+        end
+      end
+
+      status
+    end
   end
 end

data/lib/facts/aix/augeas/version.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-module Facter
+module Facts
   module Aix
-    class AugeasVersion
-      FACT_NAME = 'augeas.version'
+    module Augeas
+      class Version
+        FACT_NAME = 'augeas.version'
 
-      def call_the_resolver
-        fact_value = Resolvers::Augeas.resolve(:augeas_version)
-        ResolvedFact.new(FACT_NAME, fact_value)
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Augeas.resolve(:augeas_version)
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
       end
     end
   end

data/lib/facts/aix/facterversion.rb

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