facter 4.0.28

data/lib/framework/core/fact_loaders/fact_loader.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Facter
+  class FactLoader
+    include Singleton
+
+    attr_reader :internal_facts, :external_facts, :facts
+
+    def initialize
+      @log = Log.new(self)
+
+      @internal_facts = []
+      @external_facts = []
+      @facts = []
+    end
+
+    def load(options)
+      @internal_loader ||= InternalFactLoader.new
+      @external_fact_loader ||= ExternalFactLoader.new
+
+      @facts = []
+      @external_facts = []
+      load_internal_facts(options)
+      load_external_facts(options)
+
+      @facts
+    end
+
+    private
+
+    def load_internal_facts(options)
+      @log.debug('Loading internal facts')
+
+      if options[:user_query] || options[:show_legacy]
+        # if we have a user query, then we must search in core facts and legacy facts
+        @log.debug('Loading all internal facts')
+        @internal_facts = @internal_loader.facts
+      else
+        @log.debug('Load only core facts')
+        @internal_facts = @internal_loader.core_facts
+      end
+
+      @internal_facts = block_facts(@internal_facts, options)
+      @facts.concat(@internal_facts)
+    end
+
+    def load_external_facts(options)
+      @log.debug('Loading external facts')
+      if options[:custom_facts]
+        @log.debug('Loading custom facts')
+        @external_facts.concat(@external_fact_loader.custom_facts)
+      end
+
+      if options[:external_facts]
+        @log.debug('Loading external facts')
+        @external_facts.concat(@external_fact_loader.external_facts)
+      end
+
+      @facts.concat(@external_facts)
+    end
+
+    def block_facts(facts, options)
+      blocked_facts = options[:blocked_facts] || []
+
+      facts = facts.reject do |fact|
+        blocked_facts.select { |blocked_fact| fact.name.match(/^#{blocked_fact}/) }.any?
+      end
+
+      facts
+    end
+  end
+end

data/lib/framework/core/fact_loaders/internal_fact_loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Facter
+  class InternalFactLoader
+    attr_reader :facts
+
+    def core_facts
+      @facts.select { |fact| fact.type == :core }
+    end
+
+    def legacy_facts
+      @facts.select { |fact| fact.type == :legacy }
+    end
+
+    def initialize(os_descendents = nil)
+      @facts = []
+
+      os_descendents ||= OsDetector.instance.hierarchy
+      load_all_oses_in_descending_order(os_descendents)
+    end
+
+    private
+
+    def load_all_oses_in_descending_order(os_descendents)
+      os_descendents.reverse_each do |os|
+        load_for_os(os)
+      end
+    end
+
+    def load_for_os(operating_system)
+      # select only classes
+      classes = ClassDiscoverer.instance.discover_classes(operating_system)
+
+      classes.each do |class_name|
+        fact_name = class_name::FACT_NAME
+
+        # if fact is already loaded, skip it
+        next if @facts.any? { |fact| fact.name == fact_name }
+
+        type = class_name.const_defined?('TYPE') ? class_name::TYPE : :core
+        load_fact(fact_name, class_name, type)
+        next unless class_name.const_defined?('ALIASES')
+
+        [*class_name::ALIASES].each { |fact_alias| load_fact(fact_alias, class_name, :legacy) }
+      end
+    end
+
+    def load_fact(fact_name, klass, type)
+      loaded_fact = LoadedFact.new(fact_name, klass, type)
+      @facts << loaded_fact
+    end
+  end
+end

data/lib/framework/core/fact_manager.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Facter
+  class FactManager
+    include Singleton
+
+    def initialize
+      @internal_fact_mgr = InternalFactManager.new
+      @external_fact_mgr = ExternalFactManager.new
+      @fact_loader = FactLoader.instance
+      @log = Log.new(self)
+    end
+
+    def searched_facts(user_query = [])
+      loaded_facts = @fact_loader.load(Options.get)
+      QueryParser.parse(user_query, loaded_facts)
+    end
+
+    def resolve_facts(user_query = [])
+      loaded_facts = @fact_loader.load(Options.get)
+      searched_facts = QueryParser.parse(user_query, loaded_facts)
+
+      cache_manager = Facter::CacheManager.new
+      searched_facts, cached_facts = cache_manager.resolve_facts(searched_facts)
+      internal_facts = @internal_fact_mgr.resolve_facts(searched_facts)
+      external_facts = @external_fact_mgr.resolve_facts(searched_facts)
+
+      resolved_facts = override_core_facts(internal_facts, external_facts)
+
+      cache_manager.cache_facts(resolved_facts)
+      resolved_facts = resolved_facts.concat(cached_facts)
+
+      FactFilter.new.filter_facts!(resolved_facts)
+
+      resolved_facts
+    end
+
+    def resolve_core(user_query = [])
+      loaded_facts_hash = @fact_loader.internal_facts
+
+      searched_facts = QueryParser.parse(user_query, loaded_facts_hash)
+      resolved_facts = @internal_fact_mgr.resolve_facts(searched_facts)
+      FactFilter.new.filter_facts!(resolved_facts)
+
+      resolved_facts
+    end
+
+    private
+
+    def override_core_facts(core_facts, custom_facts)
+      return core_facts unless custom_facts
+
+      custom_facts.each do |custom_fact|
+        core_facts.delete_if { |core_fact| root_fact_name(core_fact) == custom_fact.name }
+      end
+
+      core_facts + custom_facts
+    end
+
+    def root_fact_name(fact)
+      fact.name.split('.').first
+    end
+  end
+end

data/lib/framework/core/file_loader.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+require 'yaml'
+require 'hocon'
+require 'hocon/config_value_factory'
+require 'singleton'
+require 'logger'
+
+def load_dir(*dirs)
+  folder_path = File.join(ROOT_DIR, dirs)
+  return unless Dir.exist?(folder_path.tr('*', ''))
+
+  files_to_require = Dir.glob(File.join(folder_path, '*.rb')).reject { |file| file =~ %r{/ffi/} }
+  files_to_require.each(&method(:require))
+end
+
+def load_lib_dirs(*dirs)
+  load_dir(['lib', dirs])
+end
+
+load_lib_dirs('framework', 'core', 'options')
+require "#{ROOT_DIR}/lib/framework/core/options"
+require "#{ROOT_DIR}/lib/framework/logging/logger_helper"
+require "#{ROOT_DIR}/lib/framework/logging/logger"
+
+require "#{ROOT_DIR}/lib/util/file_helper"
+
+require "#{ROOT_DIR}/lib/resolvers/base_resolver"
+require "#{ROOT_DIR}/lib/framework/detector/os_hierarchy"
+require "#{ROOT_DIR}/lib/framework/detector/os_detector"
+
+require "#{ROOT_DIR}/lib/framework/config/config_reader"
+require "#{ROOT_DIR}/lib/framework/config/fact_groups"
+
+load_dir(['config'])
+
+load_lib_dirs('resolvers', 'utils')
+load_lib_dirs('resolvers')
+load_lib_dirs('facts_utils')
+load_lib_dirs('framework', 'core')
+load_lib_dirs('models')
+load_lib_dirs('framework', 'core', 'fact_loaders')
+load_lib_dirs('framework', 'core', 'fact', 'internal')
+load_lib_dirs('framework', 'core', 'fact', 'external')
+load_lib_dirs('framework', 'formatters')
+
+os_hierarchy = OsDetector.instance.hierarchy
+os_hierarchy.each { |operating_system| load_lib_dirs('facts', operating_system.downcase, '**') }
+os_hierarchy.each { |operating_system| load_lib_dirs('resolvers', operating_system.downcase, '**') }
+
+require "#{ROOT_DIR}/lib/custom_facts/core/legacy_facter"
+load_lib_dirs('framework', 'utils')
+load_lib_dirs('util')
+
+require "#{ROOT_DIR}/lib/framework/core/fact_augmenter"
+require "#{ROOT_DIR}/lib/framework/parsers/query_parser"

data/lib/framework/core/options.rb

@@ -0,0 +1,64 @@
+# 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 = {}, user_query = nil)
+        Facter::OptionStore.cli = true
+        Facter::OptionStore.show_legacy = false
+        Facter::OptionStore.user_query = user_query
+        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 = '' if key == 'log_level' && value == 'log_level'
+          OptionStore.set(key, value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# 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
+
+      private
+
+      def augment_all
+        if Options.cli?
+          augment_cli(Facter::ConfigReader.cli)
+          augment_ruby(Facter::ConfigReader.global)
+        end
+        augment_custom(Facter::ConfigReader.global)
+        augment_external(Facter::ConfigReader.global)
+        augment_show_legacy(Facter::ConfigReader.global)
+        augment_facts(Facter::ConfigReader.ttls, Facter::ConfigReader.fact_groups)
+      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?
+          @options[:custom_facts] = !file_global_conf['no-custom-facts'] unless file_global_conf['no-custom-facts'].nil?
+        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?
+          @options[:external_facts] = !global_conf['no-external-facts'] unless global_conf['no-external-facts'].nil?
+        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
+
+        @options[:ruby] = global_conf['no-ruby'].nil? ? true : !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_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/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