facter 4.0.23

data/lib/framework/core/options/option_store.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Facter
+  class OptionStore
+    # default options
+    @debug = false
+    @verbose = false
+    # TODO: constant is not yet available when running puppet facts
+    @log_level = :warn
+    @show_legacy = true
+    @block = true
+    @custom_dir = []
+    @config_file_custom_dir = []
+    @custom_facts = true
+    @external_dir = []
+    @config_file_external_dir = []
+    @default_external_dir = []
+    @external_facts = true
+    @ruby = true
+    @cache = true
+    @blocked_facts = []
+    @user_query = []
+    @block_list = {}
+    @fact_groups = {}
+    @color = false
+
+    class << self
+      attr_reader :debug, :verbose, :log_level, :show_legacy, :trace, :ruby,
+                  :custom_facts, :blocked_facts
+
+      attr_accessor :config, :user_query, :strict, :json, :haml, :external_facts,
+                    :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
+                    :config_file_external_dir, :default_external_dir, :fact_groups,
+                    :block_list, :color
+
+      attr_writer :external_dir
+
+      def all
+        options = {}
+        instance_variables.each do |iv|
+          variable_name = iv.to_s.delete('@')
+          options[variable_name.to_sym] = OptionStore.send(variable_name.to_sym)
+        end
+        options
+      end
+
+      def ruby=(bool)
+        if bool == true
+          @ruby = true
+        else
+          @ruby = false
+          @custom_facts = false
+          @blocked_facts << 'ruby'
+        end
+      end
+
+      def external_dir
+        return fallback_external_dir if @external_dir.empty? && @external_facts
+
+        @external_dir
+      end
+
+      def blocked_facts=(*facts)
+        @blocked_facts += [*facts]
+
+        @blocked_facts.flatten!
+      end
+
+      def custom_dir
+        return @config_file_custom_dir unless @custom_dir.any?
+
+        @custom_dir
+      end
+
+      def custom_dir=(*dirs)
+        @ruby = true
+
+        @custom_dir = [*dirs]
+        @custom_dir.flatten!
+      end
+
+      def debug=(bool)
+        if bool == true
+          self.log_level = :debug
+        else
+          @debug = false
+          self.log_level = Facter::DEFAULT_LOG_LEVEL
+        end
+      end
+
+      def verbose=(bool)
+        if bool == true
+          @verbose = true
+          self.log_level = :info
+        else
+          @verbose = false
+          self.log_level = Facter::DEFAULT_LOG_LEVEL
+        end
+      end
+
+      def custom_facts=(bool)
+        if bool == true
+          @custom_facts = true
+          @ruby = true
+        else
+          @custom_facts = false
+        end
+      end
+
+      def log_level=(level)
+        level = level.to_sym
+        case level
+        when :trace
+          @log_level = :debug
+        when :debug
+          @log_level = :debug
+          @debug = true
+        else
+          @log_level = level
+        end
+
+        Facter::Log.level = @log_level
+      end
+
+      def show_legacy=(bool)
+        if bool == true
+          @show_legacy = bool
+          @ruby = true
+        else
+          @show_legacy = false
+        end
+      end
+
+      def trace=(bool)
+        Facter.trace(bool)
+      end
+
+      def set(key, value)
+        send("#{key}=".to_sym, value)
+      end
+
+      def reset
+        @debug = false
+        @verbose = false
+        # TODO: constant is not yet available when running puppet facts
+        @log_level = :warn
+        @show_legacy = true
+        @block = true
+        @ruby = true
+        @user_query = []
+        @cli = nil
+        @cache = true
+        reset_config
+      end
+
+      def reset_config
+        @custom_dir = []
+        @custom_facts = true
+        @external_dir = []
+        @default_external_dir = []
+        @external_facts = true
+        @blocked_facts = []
+        @fact_groups = {}
+        @block_list = {}
+      end
+
+      def fallback_external_dir
+        return @config_file_external_dir if @config_file_external_dir.any?
+
+        @default_external_dir
+      end
+    end
+  end
+end

data/lib/framework/core/options/options_validator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Facter
+  module OptionsValidator
+    INVALID_PAIRS_RULES = { '--color' => '--no-color',
+                            '--json' => ['--no-json', '-y', '--yaml', '--hocon'],
+                            '--yaml' => ['--no-yaml', '-j', '--hocon'],
+                            '--hocon' => '--no-hocon',
+                            '-j' => ['--no-json', '--hocon'],
+                            '-y' => ['--no-yaml', '-j', '--hocon'],
+                            '--puppet' => ['--no-puppet', '--no-ruby', '--no-custom-facts'],
+                            '-p' => ['--no-puppet', '--no-ruby', '--no-custom-facts'],
+                            '--no-external-facts' => '--external-dir',
+                            '--custom-dir' => ['--no-custom-facts', '--no-ruby'] }.freeze
+    DUPLICATED_OPTIONS_RULES = { '-j' => '--json', '-y' => '--yaml', '-p' => '--puppet', '-h' => '--help',
+                                 '-v' => '--version', '-l' => '--log-level', '-d' => '--debug',
+                                 '-c' => '--config' }.freeze
+    LOG_LEVEL = %i[none trace debug info warn error fatal].freeze
+
+    def self.validate(options)
+      DUPLICATED_OPTIONS_RULES.each do |key, value|
+        if options.include?(key) && options.include?(value)
+          write_error_and_exit("option #{value} cannot be specified more than once.")
+        end
+      end
+
+      INVALID_PAIRS_RULES.each do |key, value|
+        common_values = [value].flatten & options
+        if options.include?(key) && common_values.any?
+          write_error_and_exit("#{key} and #{common_values.first} options conflict: please specify only one.")
+        end
+      end
+    end
+
+    def self.write_error_and_exit(message)
+      log = Facter::Log.new(self)
+      log.error(message, true)
+      Facter::Cli.start(['--help'])
+
+      exit 1
+    end
+
+    def self.validate_configs(options)
+      conflicting_configs(options).each do |op|
+        next unless op.values[0] && op.values[1]
+
+        message = "#{op.keys[0]} and #{op.keys[1]} options conflict: please specify only one"
+        write_error_and_exit(message)
+      end
+      validate_log_options(options)
+    end
+
+    def self.conflicting_configs(options)
+      no_ruby = !options[:ruby]
+      no_custom_facts = !options[:custom_facts]
+      puppet = options[:puppet]
+      custom_dir = options[:custom_dir].nil? ? false : options[:custom_dir].any?
+      external_dir = options[:external_dir].nil? ? false : options[:external_dir].any?
+
+      [
+        { 'no-ruby' => no_ruby, 'custom-dir' => custom_dir },
+        { 'no-external-facts' => !options[:external_facts], 'external-dir' => external_dir },
+        { 'no-custom-facts' => no_custom_facts, 'custom-dir' => custom_dir },
+        { 'no-ruby' => no_ruby, 'puppet' => puppet },
+        { 'no-custom-facts' => no_custom_facts, 'puppet' => puppet }
+      ]
+    end
+
+    def self.validate_log_options(options)
+      # TODO: find a better way to do this
+      return if options[:debug] == true && options[:log_level] == :debug
+      return if options[:verbose] == true && options[:log_level] == :info
+
+      return unless [options[:debug],
+                     options[:verbose],
+                     options[:log_level] != Facter::DEFAULT_LOG_LEVEL]
+                    .count(true) > 1
+
+      message = 'debug, verbose, and log-level options conflict: please specify only one.'
+      write_error_and_exit(message)
+    end
+  end
+end

data/lib/framework/core/session_cache.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facter
+  class SessionCache
+    @semaphore = Mutex.new
+    @resolvers = []
+
+    def self.subscribe(resolver)
+      @semaphore.synchronize do
+        @resolvers << resolver
+      end
+    end
+
+    def self.invalidate_all_caches
+      @resolvers.uniq.each(&:invalidate_cache)
+      @resolvers = []
+    end
+  end
+end

data/lib/framework/detector/os_detector.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+class OsDetector
+  include Singleton
+
+  attr_reader :identifier, :version, :hierarchy
+
+  def initialize(*_args)
+    @log = Facter::Log.new(self)
+    @os_hierarchy = Facter::OsHierarchy.new
+    @identifier = detect
+  end
+
+  private
+
+  def detect
+    host_os = RbConfig::CONFIG['host_os']
+    identifier = case host_os
+                 when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+                   :windows
+                 when /darwin|mac os/
+                   :macosx
+                 when /linux/
+                   detect_distro
+                 when /freebsd/
+                   :freebsd
+                 when /bsd/
+                   :bsd
+                 when /solaris/
+                   :solaris
+                 when /aix/
+                   :aix
+                 else
+                   raise "unknown os: #{host_os.inspect}"
+                 end
+
+    @hierarchy = detect_hierarchy(identifier)
+    @identifier = identifier
+  end
+
+  def detect_hierarchy(identifier)
+    hierarchy = @os_hierarchy.construct_hierarchy(identifier)
+    if hierarchy.empty?
+      @log.debug("Could not detect hierarchy using os identifier: #{identifier} , trying with family")
+      hierarchy = @os_hierarchy.construct_hierarchy(detect_family)
+    end
+
+    if hierarchy.empty?
+      @log.debug("Could not detect hierarchy using family #{detect_family}, falling back to Linux")
+      hierarchy = @os_hierarchy.construct_hierarchy(:linux)
+    end
+
+    hierarchy
+  end
+
+  def detect_family
+    Facter::Resolvers::OsRelease.resolve(:id_like)
+  end
+
+  def detect_distro
+    [Facter::Resolvers::OsRelease,
+     Facter::Resolvers::RedHatRelease,
+     Facter::Resolvers::SuseRelease].each do |resolver|
+      @identifier = resolver.resolve(:identifier)
+      @version = resolver.resolve(:version)
+      break if @identifier
+    end
+
+    @identifier&.downcase&.to_sym
+  end
+end

data/lib/framework/detector/os_hierarchy.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Facter
+  class OsHierarchy
+    def initialize
+      @log = Log.new(self)
+      json_file = Util::FileHelper.safe_read(File.join(ROOT_DIR, 'os_hierarchy.json'))
+
+      begin
+        @json_os_hierarchy = JSON.parse(json_file)
+      rescue JSON::ParserError => _e
+        @log.error('Could not parse os_hierarchy json')
+      end
+    end
+
+    def construct_hierarchy(searched_os)
+      return [] if searched_os.nil?
+
+      searched_os = searched_os.to_s.capitalize
+      if @json_os_hierarchy.nil?
+        @log.debug("There is no os_hierarchy, will fall back to: #{searched_os}")
+        return [searched_os]
+      end
+
+      @searched_path = []
+      search(@json_os_hierarchy, searched_os, [])
+
+      @searched_path.map { |os_name| os_name.to_s.capitalize }
+    end
+
+    private
+
+    def search(json_data, searched_element, path)
+      # we hit a dead end, the os was not found on this branch
+      # and we cannot go deeper
+      return unless json_data
+
+      json_data.each do |tree_node|
+        # we found the searched OS, so save the path from the tree
+        @searched_path = path.dup << tree_node if tree_node == searched_element
+
+        next unless tree_node.is_a?(Hash)
+
+        tree_node.each do |k, v|
+          return @searched_path = path.dup << k if k == searched_element
+
+          search(v, searched_element, path << k)
+          path.pop
+        end
+      end
+    end
+  end
+end

data/lib/framework/formatters/formatter_factory.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Facter
+  class FormatterFactory
+    def self.build(options)
+      return JsonFactFormatter.new if options[:json]
+      return YamlFactFormatter.new if options[:yaml]
+      return HoconFactFormatter.new if options[:hocon]
+
+      LegacyFactFormatter.new
+    end
+  end
+end

data/lib/framework/formatters/formatter_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  class FormatterHelper
+    class << self
+      def retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+        facts_to_display = {}
+        user_queries.each do |user_query|
+          fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
+
+          splitted_user_query = Utils.split_user_query(user_query)
+          printable_value = fact_collection.dig(*splitted_user_query)
+          facts_to_display.merge!(user_query => printable_value)
+        end
+
+        Facter::Utils.sort_hash_by_key(facts_to_display)
+      end
+
+      def retrieve_fact_collection(resolved_facts)
+        fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
+        Facter::Utils.sort_hash_by_key(fact_collection)
+      end
+
+      def retrieve_fact_value_for_single_query(user_query, resolved_facts)
+        fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
+        fact_collection = Utils.sort_hash_by_key(fact_collection)
+        splitted_user_query = Utils.split_user_query(user_query)
+        fact_collection.dig(*splitted_user_query)
+      end
+
+      private
+
+      def build_fact_collection_for_user_query(user_query, resolved_facts)
+        facts_for_query = resolved_facts.select { |resolved_fact| resolved_fact.user_query == user_query }
+        FactCollection.new.build_fact_collection!(facts_for_query)
+      end
+    end
+  end
+end