facter 4.0.36 → 4.0.41

data/lib/facter/framework/cli/cli.rb

@@ -1,14 +1,18 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'thor'
+
 module Facter
   class Cli < Thor
-    check_unknown_options!
-
     class_option :color,
                  type: :boolean,
                  desc: 'Enable color output.'
 
+    class_option :no_color,
+                 type: :boolean,
+                 desc: 'Disable color output.'
+
     class_option :config,
                  aliases: '-c',
                  type: :string,
@@ -29,17 +33,6 @@ module Facter
                  repeatable: true,
                  desc: 'A directory to use for external facts.'
 
-    class_option :help,
-                 hide: true,
-                 aliases: '-h',
-                 type: :boolean,
-                 desc: 'Print this help message.'
-
-    class_option :man,
-                 hide: true,
-                 type: :boolean,
-                 desc: 'Display manual.'
-
     class_option :hocon,
                  type: :boolean,
                  desc: 'Output in Hocon format.'
@@ -49,36 +42,28 @@ module Facter
                  type: :boolean,
                  desc: 'Output in JSON format.'
 
-    class_option :list_block_groups,
-                 type: :boolean,
-                 desc: 'List the names of all blockable fact groups.'
-
-    class_option :list_cache_groups,
-                 type: :boolean,
-                 desc: 'List the names of all cacheable fact groups.'
-
     class_option :log_level,
                  aliases: '-l',
                  type: :string,
                  desc: 'Set logging level. Supported levels are: none, trace, debug, info, warn, error, and fatal.'
 
-    class_option :block,
+    class_option :no_block,
                  type: :boolean,
                  desc: 'Disable fact blocking.'
 
-    class_option :cache,
+    class_option :no_cache,
                  type: :boolean,
                  desc: 'Disable loading and refreshing facts from the cache'
 
-    class_option :custom_facts,
+    class_option :no_custom_facts,
                  type: :boolean,
                  desc: 'Disable custom facts.'
 
-    class_option :external_facts,
+    class_option :no_external_facts,
                  type: :boolean,
                  desc: 'Disable external facts.'
 
-    class_option :ruby,
+    class_option :no_ruby,
                  type: :boolean,
                  desc: 'Disable loading Ruby, facts requiring Ruby, and custom facts.'
 
@@ -90,6 +75,11 @@ module Facter
                  type: :boolean,
                  desc: 'Enable verbose (info) output.'
 
+    class_option :puppet,
+                 type: :boolean,
+                 aliases: '-p',
+                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+
     class_option :show_legacy,
                  type: :boolean,
                  desc: 'Show legacy facts when querying all facts.'
@@ -103,12 +93,12 @@ module Facter
                  type: :boolean,
                  desc: 'Enable more aggressive error reporting.'
 
-    class_option :puppet,
+    class_option :timing,
                  type: :boolean,
-                 aliases: '-p',
-                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+                 aliases: '-t',
+                 desc: 'Show how much time it took to resolve each fact'
 
-    desc '--man', 'Manual', hide: true
+    desc '--man', 'Display manual.', hide: true
     map ['--man'] => :man
     def man(*args)
       require 'erb'
@@ -121,7 +111,6 @@ module Facter
     end
 
     desc 'query', 'Default method', hide: true
-    desc '[options] [query] [query] [...]', ''
     def query(*args)
       output, status = Facter.to_user_output(@options, *args)
       puts output
@@ -130,13 +119,21 @@ module Facter
       exit status
     end
 
+    desc 'arg_parser', 'Parse arguments', hide: true
+    def arg_parser(*args)
+      # ignore unknown options
+      args.reject! { |arg| arg.start_with?('-') }
+
+      Facter.values(@options, args)
+    end
+
     desc '--version, -v', 'Print the version', hide: true
     map ['--version', '-v'] => :version
-    def version
+    def version(*_args)
       puts Facter::VERSION
     end
 
-    desc '--list-block-groups', 'List block groups', hide: true
+    desc '--list-block-groups', 'List block groups'
     map ['--list-block-groups'] => :list_block_groups
     def list_block_groups(*args)
       options = @options.map { |(k, v)| [k.to_sym, v] }.to_h
@@ -148,7 +145,7 @@ module Facter
       puts block_groups
     end
 
-    desc '--list-cache-groups', 'List cache groups', hide: true
+    desc '--list-cache-groups', 'List cache groups'
     map ['--list-cache-groups'] => :list_cache_groups
     def list_cache_groups(*args)
       options = @options.map { |(k, v)| [k.to_sym, v] }.to_h
@@ -160,6 +157,61 @@ module Facter
       puts cache_groups
     end
 
+    desc 'help', 'Help for all arguments'
+    def help(*args)
+      help_string = +''
+      help_string << help_header(args)
+      help_string << add_class_options_to_help
+      help_string << add_commands_to_help
+
+      puts help_string
+    end
+
+    no_commands do
+      def help_header(_args)
+        path = File.join(File.dirname(__FILE__), '../../')
+
+        Util::FileHelper.safe_read("#{path}fixtures/facter_help_header")
+      end
+
+      IGNORE_OPTIONS = %w[log_level color no_color].freeze
+
+      def add_class_options_to_help
+        help_class_options = +''
+        class_options = Cli.class_options
+        class_options.each do |class_option|
+          option = class_option[1]
+          next if option.hide
+
+          help_class_options << build_option(option.name, option.aliases, option.description)
+        end
+
+        help_class_options
+      end
+
+      def add_commands_to_help
+        help_command_options = +''
+        Cli.commands
+           .select { |_k, command_class| command_class.instance_of?(Thor::Command) }
+           .each do |_k, command|
+          help_command_options << build_option(command['name'], [], command['description'])
+        end
+
+        help_command_options
+      end
+
+      def build_option(name, aliases, description)
+        help_option = +''
+        help_option << aliases.join(',').rjust(10)
+        help_option << ' '
+        help_option << "[--#{name}]".ljust(30)
+        help_option << " #{description}"
+        help_option << "\n"
+
+        help_option
+      end
+    end
+
     def self.exit_on_failure?
       true
     end

data/lib/facter/framework/cli/cli_launcher.rb

@@ -1,59 +1,55 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'thor'
 require 'facter/framework/logging/logger.rb'
 Facter::Log.output(STDERR)
 require 'facter'
 require 'facter/framework/cli/cli'
 
 class CliLauncher
-  def initialize(args)
-    @args = args
-  end
-
-  def validate_options
-    Facter::OptionsValidator.validate(@args)
-  end
+  class << self
+    def prepare_arguments(args, task = Facter::Cli.default_task)
+      args.unshift(task) unless
+        check_if_arguments_is_known(Facter::Cli.all_tasks, args) ||
+        check_if_arguments_is_known(Facter::Cli.instance_variable_get(:@map), args) ||
+        !task
+
+      reorder_program_arguments(args)
+    end
 
-  def prepare_arguments
-    @args.unshift(Facter::Cli.default_task) unless
-      check_if_arguments_is_known(Facter::Cli.all_tasks, @args) ||
-      check_if_arguments_is_known(Facter::Cli.instance_variable_get(:@map), @args)
+    def start(args)
+      # stop parsing arguments if we don't recognize them
+      Thor.check_unknown_options!
+      Facter::Cli.start(args, debug: true)
+    rescue Thor::UnknownArgumentError => e
+      Facter::OptionsValidator.write_error_and_exit("unrecognised option '#{e.unknown.first}'")
+    end
 
-    @args = reorder_program_arguments(@args)
-  end
+    private
 
-  def start
-    Facter::Cli.start(@args, debug: true)
-  rescue Thor::UnknownArgumentError => e
-    Facter::OptionsValidator.write_error_and_exit("unrecognised option '#{e.unknown.first}'")
-  end
-
-  private
+    def check_if_arguments_is_known(known_arguments, program_arguments)
+      program_arguments.each do |argument|
+        return true if known_arguments.key?(argument)
+      end
 
-  def check_if_arguments_is_known(known_arguments, program_arguments)
-    program_arguments.each do |argument|
-      return true if known_arguments.key?(argument)
+      false
     end
 
-    false
-  end
-
-  def reorder_program_arguments(program_arguments)
-    priority_arguments = Facter::Cli.instance_variable_get(:@map)
+    def reorder_program_arguments(program_arguments)
+      priority_arguments = Facter::Cli.instance_variable_get(:@map)
 
-    priority_args = []
-    normal_args = []
+      priority_args = []
+      normal_args = []
 
-    program_arguments.each do |argument|
-      if priority_arguments.include?(argument)
-        priority_args << argument
-      else
-        normal_args << argument
+      program_arguments.each do |argument|
+        if priority_arguments.include?(argument)
+          priority_args << argument
+        else
+          normal_args << argument
+        end
       end
-    end
 
-    priority_args.concat(normal_args)
+      priority_args.concat(normal_args)
+    end
   end
 end

data/lib/facter/framework/config/fact_groups.rb

@@ -2,7 +2,7 @@
 
 module Facter
   class FactGroups
-    attr_reader :groups, :block_list
+    attr_reader :groups, :block_list, :facts_ttls
 
     @groups_ttls = []
 
@@ -14,6 +14,10 @@ module Facter
       @groups ||= File.readable?(@groups_file_path) ? Hocon.load(@groups_file_path) : {}
       load_groups
       load_groups_from_options
+      load_facts_ttls
+
+      # Reverse sort facts so that children have precedence when caching. eg: os.macosx vs os
+      @facts_ttls = @facts_ttls.sort.reverse.to_h
     end
 
     # Breakes down blocked groups in blocked facts
@@ -31,6 +35,9 @@ module Facter
 
     # Get the group name a fact is part of
     def get_fact_group(fact_name)
+      fact = get_fact(fact_name)
+      return fact[:group] if fact
+
       @groups.detect { |k, v| break k if Array(v).find { |f| fact_name =~ /^#{f}.*/ } }
     end
 
@@ -41,6 +48,15 @@ module Facter
       ttls_to_seconds(ttls[group_name])
     end
 
+    def get_fact(fact_name)
+      return @facts_ttls[fact_name] if @facts_ttls[fact_name]
+
+      result = @facts_ttls.select { |name, fact| break fact if fact_name =~ /^#{name}\..*/ }
+      return nil if result == {}
+
+      result
+    end
+
     private
 
     def load_groups_from_options
@@ -55,10 +71,28 @@ module Facter
       end
     end
 
+    def load_facts_ttls
+      @facts_ttls ||= {}
+      return if @groups_ttls == []
+
+      @groups_ttls.reduce(:merge).each do |group, ttls|
+        ttls = ttls_to_seconds(ttls)
+        if @groups[group]
+          @groups[group].each do |fact|
+            if (@facts_ttls[fact] && @facts_ttls[fact][:ttls] < ttls) || @facts_ttls[fact].nil?
+              @facts_ttls[fact] = { ttls: ttls, group: group }
+            end
+          end
+        else
+          @facts_ttls[group] = { ttls: ttls, group: group }
+        end
+      end
+    end
+
     def load_groups
       config = ConfigReader.init(Options[:config])
       @block_list = config.block_list || {}
-      @groups_ttls = config.ttls || {}
+      @groups_ttls = config.ttls || []
       @groups.merge!(config.fact_groups) if config.fact_groups
     end
 

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

@@ -40,31 +40,42 @@ module Facter
       end
     end
 
-    def group_cached?(group_name)
-      cached = @fact_groups.get_group_ttls(group_name) ? true : false
-      delete_cache(group_name) unless cached
+    def fact_cache_enabled?(fact_name)
+      fact = @fact_groups.get_fact(fact_name)
+      cached = if fact
+                 !fact[:ttls].nil?
+               else
+                 false
+               end
+
+      fact_group = @fact_groups.get_fact_group(fact_name)
+      delete_cache(fact_group) if fact_group && !cached
       cached
     end
 
     private
 
     def resolve_fact(searched_fact)
-      group_name =  if searched_fact.file
-                      searched_fact.name
-                    else
-                      @fact_groups.get_fact_group(searched_fact.name)
-                    end
+      return unless fact_cache_enabled?(searched_fact.name)
 
-      return unless group_name
+      fact = if searched_fact.file
+               @fact_groups.get_fact(File.basename(searched_fact.file))
+             else
+               @fact_groups.get_fact(searched_fact.name)
+             end
 
-      return unless group_cached?(group_name)
+      return unless fact
 
-      return unless check_ttls?(group_name)
+      return unless check_ttls?(fact[:group], fact[:ttls])
 
-      data = read_group_json(group_name)
+      read_fact(searched_fact, fact[:group])
+    end
+
+    def read_fact(searched_fact, fact_group)
+      data = read_group_json(fact_group)
       return unless data
 
-      @log.debug("loading cached values for #{group_name} facts")
+      @log.debug("loading cached values for #{searched_fact.name} facts")
 
       create_facts(searched_fact, data)
     end
@@ -93,7 +104,7 @@ module Facter
                    end
       return if !group_name || fact.value.nil?
 
-      return unless group_cached?(group_name)
+      return unless fact_cache_enabled?(fact.name)
 
       @groups[group_name] ||= {}
       @groups[group_name][fact.name] = fact.value
@@ -106,10 +117,12 @@ module Facter
       end
 
       @groups.each do |group_name, data|
-        next unless check_ttls?(group_name)
+        next unless check_ttls?(group_name, @fact_groups.get_group_ttls(group_name))
 
-        @log.debug("caching values for #{group_name} facts")
         cache_file_name = File.join(@cache_dir, group_name)
+        next if File.readable?(cache_file_name)
+
+        @log.debug("caching values for #{group_name} facts")
         File.write(cache_file_name, JSON.pretty_generate(data))
       end
     end
@@ -128,8 +141,7 @@ module Facter
       @groups[group_name] = data
     end
 
-    def check_ttls?(group_name)
-      ttls = @fact_groups.get_group_ttls(group_name)
+    def check_ttls?(group_name, ttls)
       return false unless ttls
 
       cache_file_name = File.join(@cache_dir, group_name)