facter 4.0.23

data/lib/framework/cli/cli_launcher.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'thor'
+require "#{ROOT_DIR}/lib/framework/logging/logger.rb"
+Facter::Log.output(STDERR)
+require "#{ROOT_DIR}/lib/facter"
+require "#{ROOT_DIR}/lib/framework/cli/cli"
+
+Facter::OptionsValidator.validate(ARGV)
+ARGV.unshift(Facter::Cli.default_task) unless
+  Facter::Cli.all_tasks.key?(ARGV[0]) ||
+  Facter::Cli.instance_variable_get(:@map).key?(ARGV[0])
+
+begin
+  Facter::Cli.start(ARGV, debug: true)
+rescue Thor::UnknownArgumentError => e
+  Facter::OptionsValidator.write_error_and_exit("unrecognised option '#{e.unknown.first}'")
+end

data/lib/framework/config/config_reader.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  class ConfigReader
+    class << self
+      attr_accessor :conf
+
+      def init(config_path = nil)
+        config_path ||= default_path
+        refresh_config(config_path)
+        self
+      end
+
+      def block_list
+        @conf['facts'] && @conf['facts']['blocklist']
+      end
+
+      def ttls
+        @conf['facts'] && @conf['facts']['ttls']
+      end
+
+      def global
+        @conf['global']
+      end
+
+      def cli
+        @conf['cli']
+      end
+
+      def fact_groups
+        @conf['fact-groups']
+      end
+
+      def refresh_config(config_path)
+        @conf = File.readable?(config_path) ? Hocon.load(config_path) : {}
+      end
+
+      private
+
+      def default_path
+        os = OsDetector.instance.identifier
+
+        windows_path = File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'etc', 'facter.conf')
+        linux_path = File.join('/', 'etc', 'puppetlabs', 'facter', 'facter.conf')
+
+        os == :windows ? windows_path : linux_path
+      end
+    end
+  end
+end

data/lib/framework/config/fact_groups.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Facter
+  class FactGroups
+    attr_reader :groups, :block_list
+
+    @groups_ttls = []
+
+    STRING_TO_SECONDS = { 'seconds' => 1, 'minutes' => 60, 'hours' => 3600, 'days' => 3600 * 24 }.freeze
+
+    def initialize(group_list_path = nil)
+      @groups_file_path = group_list_path || File.join(ROOT_DIR, 'fact_groups.conf')
+      @groups ||= File.readable?(@groups_file_path) ? Hocon.load(@groups_file_path) : {}
+      load_groups
+    end
+
+    # Breakes down blocked groups in blocked facts
+    def blocked_facts
+      fact_list = []
+
+      @block_list.each do |group_name|
+        facts_for_block = @groups[group_name]
+
+        fact_list += facts_for_block || [group_name]
+      end
+
+      fact_list
+    end
+
+    # Get the group name a fact is part of
+    def get_fact_group(fact_name)
+      @groups.detect { |k, v| break k if Array(v).find { |f| fact_name =~ /^#{f}.*/ } }
+    end
+
+    # Get config ttls for a given group
+    def get_group_ttls(group_name)
+      return unless (ttls = @groups_ttls.find { |g| g[group_name] })
+
+      ttls_to_seconds(ttls[group_name])
+    end
+
+    private
+
+    def load_groups
+      config = ConfigReader.init(Options[:config])
+      @block_list = config.block_list || {}
+      @groups_ttls = config.ttls || {}
+      @groups.merge!(config.fact_groups) if config.fact_groups
+    end
+
+    def ttls_to_seconds(ttls)
+      duration, unit = ttls.split(' ', 2)
+      duration.to_i * STRING_TO_SECONDS[unit]
+    end
+  end
+end

data/lib/framework/core/cache_manager.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Facter
+  class CacheManager
+    def initialize
+      @groups = {}
+      @log = Log.new(self)
+      @fact_groups = Facter::FactGroups.new
+      @cache_dir = LegacyFacter::Util::Config.facts_cache_dir
+    end
+
+    def resolve_facts(searched_facts)
+      return searched_facts, [] if !File.directory?(@cache_dir) || !Options[:cache]
+
+      facts = []
+      searched_facts.each do |fact|
+        res = resolve_fact(fact)
+        facts << res if res
+      end
+      facts.each do |fact|
+        searched_facts.delete_if { |f| f.name == fact.name }
+      end
+      [searched_facts, facts]
+    end
+
+    def cache_facts(resolved_facts)
+      return unless Options[:cache]
+
+      resolved_facts.each do |fact|
+        cache_fact(fact)
+      end
+
+      begin
+        write_cache unless @groups.empty?
+      rescue Errno::EACCES => e
+        @log.warn("Could not write cache: #{e.message}")
+      end
+    end
+
+    private
+
+    def resolve_fact(searched_fact)
+      group_name = @fact_groups.get_fact_group(searched_fact.name)
+      return unless group_name
+
+      return unless group_cached?(group_name)
+
+      return unless check_ttls?(group_name)
+
+      data = read_group_json(group_name)
+      return unless data
+
+      @log.debug("loading cached values for #{group_name} facts")
+      create_fact(searched_fact, data[searched_fact.name])
+    end
+
+    def create_fact(searched_fact, value)
+      Facter::ResolvedFact.new(searched_fact.name, value, searched_fact.type,
+                               searched_fact.user_query, searched_fact.filter_tokens)
+    end
+
+    def cache_fact(fact)
+      group_name = @fact_groups.get_fact_group(fact.name)
+      return if !group_name || fact.value.nil?
+
+      return unless group_cached?(group_name)
+
+      @groups[group_name] ||= {}
+      @groups[group_name][fact.name] = fact.value
+    end
+
+    def write_cache
+      unless File.directory?(@cache_dir)
+        require 'fileutils'
+        FileUtils.mkdir_p(@cache_dir)
+      end
+
+      @groups.each do |group_name, data|
+        next unless check_ttls?(group_name)
+
+        @log.debug("caching values for #{group_name} facts")
+        cache_file_name = File.join(@cache_dir, group_name)
+        File.write(cache_file_name, JSON.pretty_generate(data))
+      end
+    end
+
+    def read_group_json(group_name)
+      return @groups[group_name] if @groups.key?(group_name)
+
+      cache_file_name = File.join(@cache_dir, group_name)
+      data = nil
+      file = Util::FileHelper.safe_read(cache_file_name)
+      begin
+        data = JSON.parse(file)
+      rescue JSON::ParserError
+        delete_cache(group_name)
+      end
+      @groups[group_name] = data
+    end
+
+    def group_cached?(group_name)
+      cached = @fact_groups.get_group_ttls(group_name) ? true : false
+      delete_cache(group_name) unless cached
+      cached
+    end
+
+    def check_ttls?(group_name)
+      ttls = @fact_groups.get_group_ttls(group_name)
+      return false unless ttls
+
+      cache_file_name = File.join(@cache_dir, group_name)
+      if File.readable?(cache_file_name)
+        file_time = File.mtime(cache_file_name)
+        expire_date = file_time + ttls
+        return true if expire_date > Time.now
+
+        File.delete(cache_file_name)
+      end
+
+      @log.debug("#{group_name} facts cache file expired/missing")
+      true
+    end
+
+    def delete_cache(group_name)
+      cache_file_name = File.join(@cache_dir, group_name)
+      File.delete(cache_file_name) if File.readable?(cache_file_name)
+    end
+  end
+end

data/lib/framework/core/fact/external/external_fact_manager.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  class ExternalFactManager
+    def resolve_facts(searched_facts)
+      searched_facts = filter_external_facts(searched_facts)
+      external_facts(searched_facts)
+    end
+
+    private
+
+    def filter_external_facts(searched_facts)
+      searched_facts.select { |searched_fact| %i[custom external].include?(searched_fact.type) }
+    end
+
+    def external_facts(custom_facts)
+      resolved_custom_facts = []
+
+      custom_facts.each do |custom_fact|
+        fact_value = LegacyFacter.value(custom_fact.name)
+        resolved_fact = ResolvedFact.new(custom_fact.name, fact_value, :custom)
+        resolved_fact.filter_tokens = []
+        resolved_fact.user_query = custom_fact.user_query
+
+        resolved_custom_facts << resolved_fact
+      end
+
+      resolved_custom_facts
+    end
+  end
+end

data/lib/framework/core/fact/internal/core_fact.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facter
+  class CoreFact
+    def initialize(searched_fact)
+      @searched_fact = searched_fact
+    end
+
+    def create
+      fact_class = @searched_fact.fact_class
+
+      fact_class.new.call_the_resolver
+    end
+  end
+end

data/lib/framework/core/fact/internal/internal_fact_manager.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Facter
+  class InternalFactManager
+    @@log = Facter::Log.new(self)
+
+    def resolve_facts(searched_facts)
+      searched_facts = filter_internal_facts(searched_facts)
+
+      threads = start_threads(searched_facts)
+
+      join_threads(threads, searched_facts)
+    end
+
+    private
+
+    def filter_internal_facts(searched_facts)
+      searched_facts.select { |searched_fact| %i[core legacy].include? searched_fact.type }
+    end
+
+    def start_threads(searched_facts)
+      threads = []
+      # only resolve a fact once, even if multiple search facts depend on that fact
+      searched_facts
+        .uniq { |searched_fact| searched_fact.fact_class.name }
+        .each do |searched_fact|
+        threads << Thread.new do
+          begin
+            fact = CoreFact.new(searched_fact)
+            fact.create
+          rescue StandardError => e
+            @@log.error(e.backtrace.join("\n"))
+            nil
+          end
+        end
+      end
+
+      threads
+    end
+
+    def join_threads(threads, searched_facts)
+      resolved_facts = []
+
+      threads.each do |thread|
+        thread.join
+        resolved_facts << thread.value unless thread.value.nil?
+      end
+
+      resolved_facts.flatten!
+
+      FactAugmenter.augment_resolved_facts(searched_facts, resolved_facts)
+    end
+  end
+end

data/lib/framework/core/fact_augmenter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module FactAugmenter
+    def self.augment_resolved_facts(searched_facts, resolved_facts)
+      augumented_resolved_facts = []
+      searched_facts.each do |searched_fact|
+        matched_facts = get_resolved_facts_for_searched_fact(searched_fact, resolved_facts)
+        augment_resolved_fact_for_user_query!(searched_fact, matched_facts)
+        augumented_resolved_facts.concat(matched_facts)
+      end
+
+      augumented_resolved_facts
+    end
+
+    private_class_method def self.get_resolved_facts_for_searched_fact(searched_fact, resolved_facts)
+      if searched_fact.name.include?('.*')
+        resolved_facts
+          .select { |resolved_fact| resolved_fact.name.match(searched_fact.user_query) }
+          .reject(&:user_query)
+          .uniq(&:name)
+      else
+        resolved_facts
+          .select { |resolved_fact| searched_fact.name.eql?(resolved_fact.name) }
+          .reject(&:user_query)
+          .uniq(&:name)
+      end
+    end
+
+    private_class_method def self.augment_resolved_fact_for_user_query!(searched_fact, matched_facts)
+      matched_facts.each do |matched_fact|
+        matched_fact.user_query = searched_fact.user_query
+        matched_fact.filter_tokens = searched_fact.filter_tokens
+      end
+    end
+  end
+end

data/lib/framework/core/fact_filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  # Filter inside value of a fact.
+  # e.g. os.release.major is the user query, os.release is the fact
+  # and major is the filter criteria inside tha fact
+  class FactFilter
+    def filter_facts!(searched_facts)
+      filter_legacy_facts!(searched_facts)
+      searched_facts.each do |fact|
+        fact.value = if fact.filter_tokens.any? && fact.value.respond_to?(:dig)
+                       fact.value.dig(*fact.filter_tokens)
+                     else
+                       fact.value
+                     end
+      end
+    end
+
+    private
+
+    def filter_legacy_facts!(resolved_facts)
+      return unless !Options[:show_legacy] && Options[:user_query].empty?
+
+      resolved_facts.reject!(&:legacy?)
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  class ClassDiscoverer
+    include Singleton
+
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def discover_classes(operating_system)
+      os_module_name = Module.const_get("Facts::#{operating_system}")
+
+      # select only classes
+      find_nested_classes(os_module_name, discovered_classes = [])
+      discovered_classes
+    rescue NameError
+      @log.debug("There is no module named #{operating_system}")
+      []
+    end
+
+    def find_nested_classes(mod, discovered_classes)
+      mod.constants.each do |constant_name|
+        if mod.const_get(constant_name).instance_of? Class
+          discovered_classes << mod.const_get(constant_name)
+        elsif mod.const_get(constant_name).instance_of? Module
+          find_nested_classes(Module.const_get("#{mod.name}::#{constant_name}"), discovered_classes)
+        end
+      end
+    end
+  end
+end