facter 4.0.28

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

data/lib/framework/formatters/hocon_fact_formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  class HoconFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      return if user_queries.count < 1
+      return format_for_multiple_user_queries(user_queries, resolved_facts) if user_queries.count > 1
+
+      user_query = user_queries.first
+      return format_for_no_query(resolved_facts) if user_query.empty?
+      return format_for_single_user_query(user_queries.first, resolved_facts) unless user_query.empty?
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('Formatting for no user query')
+      fact_collection = FormatterHelper.retrieve_fact_collection(resolved_facts)
+      hash_to_hocon(fact_collection)
+    end
+
+    def format_for_multiple_user_queries(user_queries, resolved_facts)
+      @log.debug('Formatting for multiple user queries')
+
+      facts_to_display = FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+      hash_to_hocon(facts_to_display)
+    end
+
+    def format_for_single_user_query(user_query, resolved_facts)
+      @log.debug('Formatting for single user query')
+
+      fact_value = FormatterHelper.retrieve_fact_value_for_single_query(user_query, resolved_facts)
+
+      return '' unless fact_value
+
+      fact_value.class == Hash ? hash_to_hocon(fact_value) : fact_value
+    end
+
+    def hash_to_hocon(fact_collection)
+      render_opts = Hocon::ConfigRenderOptions.new(false, false, true, false)
+      Hocon::ConfigFactory.parse_string(fact_collection.to_json).root.render(render_opts)
+    end
+  end
+end

data/lib/framework/formatters/json_fact_formatter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  class JsonFactFormatter
+    def initialize
+      @log = Facter::Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      if user_queries.count == 1 && user_queries.first.empty?
+        format_for_no_query(resolved_facts)
+      else
+        format_for_user_queries(user_queries, resolved_facts)
+      end
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('No user query provided')
+
+      fact_collection = FormatterHelper.retrieve_fact_collection(resolved_facts)
+      JSON.pretty_generate(fact_collection)
+    end
+
+    def format_for_user_queries(user_queries, resolved_facts)
+      @log.debug('User provided a query')
+
+      facts_to_display = FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+      JSON.pretty_generate(facts_to_display)
+    end
+  end
+end

data/lib/framework/formatters/legacy_fact_formatter.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Facter
+  class LegacyFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      return if user_queries.count < 1
+      return format_for_multiple_user_queries(user_queries, resolved_facts) if user_queries.count > 1
+
+      user_query = user_queries.first
+      return format_for_no_query(resolved_facts) if user_query.empty?
+
+      format_for_single_user_query(user_queries.first, resolved_facts)
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('Formatting for no user query')
+      fact_collection = Facter::FormatterHelper.retrieve_fact_collection(resolved_facts)
+      pretty_json = hash_to_facter_format(fact_collection)
+
+      pretty_json = remove_enclosing_accolades(pretty_json)
+      remove_comma_and_quotation(pretty_json)
+    end
+
+    def format_for_multiple_user_queries(user_queries, resolved_facts)
+      @log.debug('Formatting for multiple user queries')
+
+      facts_to_display = Facter::FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+
+      facts_to_display.each { |k, v| facts_to_display[k] = v.nil? ? '' : v }
+      pretty_json = hash_to_facter_format(facts_to_display)
+      pretty_json = remove_enclosing_accolades(pretty_json)
+      pretty_json = remove_comma_and_quotation(pretty_json)
+
+      @log.debug('Remove quotes from value if value is a string')
+      pretty_json.gsub(/^(\S*) => \"(.*)\"/, '\1 => \2')
+    end
+
+    def format_for_single_user_query(user_query, resolved_facts)
+      @log.debug('Formatting for single user query')
+
+      fact_value = Facter::FormatterHelper.retrieve_fact_value_for_single_query(user_query, resolved_facts)
+
+      return fact_value if fact_value.is_a?(String)
+
+      pretty_json = fact_value.nil? ? '' : hash_to_facter_format(fact_value)
+
+      @log.debug('Remove quotes from value if it is a simple string')
+      pretty_json.gsub(/^"(.*)\"/, '\1')
+    end
+
+    def hash_to_facter_format(facts_hash)
+      @log.debug('Converting hash to pretty json')
+      pretty_json = JSON.pretty_generate(facts_hash)
+
+      @log.debug('Change key value delimiter from : to =>')
+      pretty_json.gsub!(/":\s/, '" => ')
+
+      @log.debug('Remove quotes from parent nodes')
+      pretty_json.gsub!(/\"(.*)\"\ =>/, '\1 =>')
+
+      @log.debug('Remove double backslashes from paths')
+      pretty_json.gsub(/\\\\/, '\\')
+    end
+
+    def remove_enclosing_accolades(pretty_fact_json)
+      @log.debug('Removing enclosing accolades')
+      pretty_fact_json = pretty_fact_json[1..-2]
+
+      @log.debug('Remove empty lines')
+      pretty_fact_json.gsub!(/^$\n/, '')
+
+      @log.debug('Fix indentation after removing enclosed accolades')
+      pretty_fact_json = pretty_fact_json.gsub(/^\s\s(.*)$/, '\1')
+
+      @log.debug('remove comas from query results')
+      pretty_fact_json.gsub(/^},/, '}')
+    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')
+      output.split("\n")
+            .map! { |line| line =~ /^[\s]+/ ? line : line.gsub(/,$|(?<!\\)\"/, '').gsub('\\"', '"') }.join("\n")
+    end
+  end
+end