openfact 5.0.0.rc0

data/lib/facter/framework/core/options/config_file_options.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Facter
+  class ConfigFileOptions
+    class << self
+      def init(config_path = nil)
+        @options = {}
+        Facter::ConfigReader.init(config_path)
+
+        augment_config_path(config_path)
+
+        augment_all
+      end
+
+      def get
+        @options || {}
+      end
+
+      def clear
+        @options = {}
+      end
+
+      private
+
+      def augment_structured_facts(global_conf)
+        return if !global_conf || global_conf['force-dot-resolution'].nil?
+
+        @options[:force_dot_resolution] = global_conf['force-dot-resolution']
+      end
+
+      def augment_all
+        augment_cli(Facter::ConfigReader.cli) if Options.cli?
+        augment_globals
+        augment_facts(Facter::ConfigReader.ttls, Facter::ConfigReader.fact_groups)
+      end
+
+      def augment_globals
+        augment_ruby(Facter::ConfigReader.global)
+
+        augment_structured_facts(Facter::ConfigReader.global)
+        augment_custom(Facter::ConfigReader.global)
+        augment_external(Facter::ConfigReader.global)
+        augment_show_legacy(Facter::ConfigReader.global)
+        augment_sequential(Facter::ConfigReader.global)
+      end
+
+      def augment_config_path(config_path)
+        @options[:config] = config_path
+      end
+
+      def augment_cli(file_cli_conf)
+        return unless file_cli_conf
+
+        @options[:debug] = file_cli_conf['debug'] unless file_cli_conf['debug'].nil?
+        @options[:trace] = file_cli_conf['trace'] unless file_cli_conf['trace'].nil?
+        @options[:verbose] = file_cli_conf['verbose'] unless file_cli_conf['verbose'].nil?
+        @options[:log_level] = file_cli_conf['log-level'].to_sym unless file_cli_conf['log-level'].nil?
+      end
+
+      def augment_custom(file_global_conf)
+        return unless file_global_conf
+
+        if Options.cli? && !file_global_conf['no-custom-facts'].nil?
+          @options[:no_custom_facts] = file_global_conf['no-custom-facts']
+        end
+
+        @options[:custom_dir] = file_global_conf['custom-dir'] unless file_global_conf['custom-dir'].nil?
+        @options[:config_file_custom_dir] = @options[:custom_dir] || []
+      end
+
+      def augment_external(global_conf)
+        return unless global_conf
+
+        if Options.cli? && !global_conf['no-external-facts'].nil?
+          @options[:no_external_facts] = global_conf['no-external-facts']
+        end
+
+        @options[:external_dir] = [global_conf['external-dir']].flatten unless global_conf['external-dir'].nil?
+        @options[:config_file_external_dir] = @options[:external_dir] || []
+      end
+
+      def augment_ruby(global_conf)
+        return unless global_conf
+        return unless Options.cli?
+
+        @options[:no_ruby] = global_conf['no-ruby'].nil? ? false : global_conf['no-ruby']
+      end
+
+      def augment_show_legacy(global_conf)
+        return unless global_conf
+
+        @options[:show_legacy] = global_conf['show-legacy'] unless global_conf['show-legacy'].nil?
+      end
+
+      def augment_sequential(global_conf)
+        return unless global_conf
+
+        @options[:sequential] = global_conf['sequential'] unless global_conf['sequential'].nil?
+      end
+
+      def augment_facts(ttls, groups)
+        fact_groups = Facter::FactGroups.new
+
+        @options[:blocked_facts] = fact_groups.blocked_facts unless fact_groups.blocked_facts.nil?
+        @options[:block_list] = fact_groups.block_list
+        @options[:ttls] = ttls unless ttls.nil?
+
+        f_groups = fact_groups.groups || {}
+        f_groups = groups.merge(f_groups) unless groups.nil?
+        @options[:fact_groups] = f_groups
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# 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
+    @custom_facts = true
+    @blocked_facts = []
+    @ruby = true
+    @external_facts = true
+    @config = nil
+    @strict = false
+    @json = false
+    @cache = true
+    @yaml = false
+    @puppet = false
+    @ttls = []
+    @block = true
+    @cli = nil
+    @config_file_custom_dir = []
+    @config_file_external_dir = []
+    @default_external_dir = []
+    @fact_groups = {}
+    @sequential = true
+    @ttls = []
+    @block_list = []
+    @color = true
+    @trace = false
+    @timing = false
+    @external_dir = []
+    @custom_dir = []
+    @hocon = false
+    @allow_external_loggers = true
+    @force_dot_resolution = false
+    @http_debug = false
+
+    class << self
+      attr_reader :debug, :verbose, :log_level, :show_legacy,
+                  :custom_facts, :blocked_facts, :ruby, :external_facts
+
+      attr_accessor :config, :strict, :json,
+                    :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
+                    :config_file_external_dir, :default_external_dir, :fact_groups, :force_dot_resolution,
+                    :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers, :http_debug
+
+      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 no_ruby=(bool)
+        if bool
+          @ruby = false
+          @custom_facts = false
+          @blocked_facts << 'ruby'
+        else
+          @ruby = true
+        end
+      end
+
+      def no_block=(bool)
+        @block = !bool
+      end
+
+      def no_cache=(bool)
+        @cache = !bool
+      end
+
+      def no_color=(bool)
+        @color = !bool
+      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 no_custom_facts=(bool)
+        if bool == false
+          @custom_facts = true
+          @ruby = true
+        else
+          @custom_facts = false
+        end
+      end
+
+      def no_external_facts=(bool)
+        @external_facts = !bool
+      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 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
+        @ruby = true
+        @json = false
+        @hocon = false
+        @cache = true
+        @yaml = false
+        @puppet = false
+        @ttls = []
+        @block = true
+        @cli = nil
+        @http_debug = false
+        reset_config
+      end
+
+      def reset_config
+        @blocked_facts = []
+        @external_facts = true
+        @config = nil
+        @strict = false
+        @config_file_custom_dir = []
+        @config_file_external_dir = []
+        @default_external_dir = []
+        @fact_groups = {}
+        @block_list = {}
+        @color = true
+        @sequential = true
+        @ttls = []
+        @trace = false
+        @timing = false
+        @allow_external_loggers = true
+        reset_facts
+      end
+
+      def reset_facts
+        @custom_facts = true
+        @force_dot_resolution = false
+        @external_dir = []
+        @custom_dir = []
+      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/facter/framework/core/options/options_validator.rb

@@ -0,0 +1,90 @@
+# 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?
+      default_external_dir = Facter::OptionStore.default_external_dir
+      # --puppet/-p option adds an external directory and is not an explicitly
+      # set external_dir from cli or config file
+      default_external_dir += [Puppet[:pluginfactdest]] if puppet && const_defined?('Puppet')
+      external_dir = if options[:external_dir].nil? || options[:external_dir].none?
+                       false
+                     else
+                       options[:external_dir] != default_external_dir
+                     end
+      [
+        { '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/facter/framework/core/options.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Facter
+  class Options
+    class << self
+      def cli?
+        OptionStore.cli
+      end
+
+      def get
+        OptionStore.all
+      end
+
+      def [](key)
+        OptionStore.send(key.to_sym)
+      end
+
+      def []=(key, value)
+        OptionStore.send("#{key}=".to_sym, value)
+      end
+
+      def custom_dir?
+        OptionStore.custom_dir && OptionStore.custom_facts
+      end
+
+      def custom_dir
+        [OptionStore.custom_dir].flatten
+      end
+
+      def external_dir?
+        OptionStore.external_dir && OptionStore.external_facts
+      end
+
+      def external_dir
+        OptionStore.external_dir
+      end
+
+      def init
+        OptionStore.cli = false
+        ConfigFileOptions.init
+        store(ConfigFileOptions.get)
+      end
+
+      def init_from_cli(cli_options = {})
+        Facter::OptionStore.cli = true
+        Facter::OptionStore.show_legacy = false
+        Facter::OptionStore.trace = cli_options[:trace]
+        OptionStore.set(:config, cli_options[:config])
+        ConfigFileOptions.init(cli_options[:config])
+        store(ConfigFileOptions.get)
+        store(cli_options)
+
+        Facter::OptionsValidator.validate_configs(get)
+      end
+
+      def store(options)
+        options.each do |key, value|
+          value = munge_option(key, value)
+          OptionStore.set(key, value)
+        end
+      end
+
+      private
+
+      def munge_option(key, value)
+        return value unless key.to_sym == :log_level
+
+        case value.to_sym
+        when :log_level
+          ''
+        when :none
+          'unknown'
+        else
+          value
+        end
+      end
+    end
+  end
+end

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

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

data/lib/facter/framework/detector/os_detector.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+class OsDetector
+  include Singleton
+
+  attr_reader :identifier, :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 /openbsd/i
+                   :openbsd
+                 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")
+
+      # https://www.commandlinux.com/man-page/man5/os-release.5.html
+      detect_family.to_s.split.each do |family|
+        hierarchy = @os_hierarchy.construct_hierarchy(family)
+        return hierarchy unless hierarchy.empty?
+      end
+    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_based_on_release_file
+    @identifier = :devuan if File.readable?('/etc/devuan_version')
+    @identifier = :archlinux if File.readable?('/etc/arch-release')
+  end
+
+  def detect_distro
+    detect_based_on_release_file
+    return @identifier if @identifier
+
+    [Facter::Resolvers::OsRelease,
+     Facter::Resolvers::RedHatRelease,
+     Facter::Resolvers::SuseRelease].each do |resolver|
+      @identifier = resolver.resolve(:id)
+      break if @identifier
+    end
+
+    @identifier&.downcase&.to_sym
+  end
+end

data/lib/facter/framework/detector/os_hierarchy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../../facter/config'
+
+module Facter
+  class OsHierarchy
+    def initialize
+      @log = Log.new(self)
+      @os_hierarchy = Facter::Config::OS_HIERARCHY
+    end
+
+    def construct_hierarchy(searched_os)
+      return [] if searched_os.nil?
+
+      searched_os = searched_os.to_s.capitalize
+      if @os_hierarchy.nil?
+        @log.debug("There is no os_hierarchy, will fall back to: #{searched_os}")
+        return [searched_os]
+      end
+
+      @searched_path = []
+      search(@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/facter/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/facter/framework/formatters/formatter_helper.rb

@@ -0,0 +1,37 @@
+# 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 = FactCollection.new
+        user_queries.each do |user_query|
+          fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
+
+          printable_value = fact_collection.dig_fact(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)
+        fact_collection.dig_fact(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