facter 4.0.24 → 4.0.30

data/lib/facter/facts/windows/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Windows::AioAgentVersion.resolve(:aio_agent_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/ec2_metadata.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Ec2Metadata
+      FACT_NAME = 'ec2_metadata'
+
+      def call_the_resolver
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+
+        fact_value = Facter::Resolvers::Ec2.resolve(:metadata)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+      end
+
+      def aws?
+        virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
+
+        virtual == 'kvm' || virtual =~ /xen/
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/ec2_userdata.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Ec2Userdata
+      FACT_NAME = 'ec2_userdata'
+
+      def call_the_resolver
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+
+        fact_value = Facter::Resolvers::Ec2.resolve(:userdata)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+      end
+
+      def aws?
+        virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
+
+        virtual == 'kvm' || virtual =~ /xen/
+      end
+    end
+  end
+end

data/lib/facter/facts_utils/facts_utils.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Facter
+  module FactsUtils
+    HYPERVISORS_HASH = { 'VMware' => 'vmware', 'VirtualBox' => 'virtualbox', 'Parallels' => 'parallels',
+                         'KVM' => 'kvm', 'Virtual Machine' => 'hyperv', 'RHEV Hypervisor' => 'rhev',
+                         'oVirt Node' => 'ovirt', 'HVM domU' => 'xenhvm', 'Bochs' => 'bochs', 'OpenBSD' => 'vmm',
+                         'BHYVE' => 'bhyve' }.freeze
+  end
+end

data/lib/{framework → facter/framework}/cli/cli.rb

@@ -116,7 +116,7 @@ module Facter
     desc '--version, -v', 'Print the version', hide: true
     map ['--version', '-v'] => :version
     def version
-      puts FACTER_VERSION.to_s
+      puts Facter::VERSION
     end
 
     desc '--list-block-groups', 'List block groups'

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

@@ -0,0 +1,59 @@
+#!/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
+
+  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)
+
+    @args = reorder_program_arguments(@args)
+  end
+
+  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
+
+    false
+  end
+
+  def reorder_program_arguments(program_arguments)
+    priority_arguments = Facter::Cli.instance_variable_get(:@map)
+
+    priority_args = []
+    normal_args = []
+
+    program_arguments.each do |argument|
+      if priority_arguments.include?(argument)
+        priority_args << argument
+      else
+        normal_args << argument
+      end
+    end
+
+    priority_args.concat(normal_args)
+  end
+end

data/lib/{framework → facter/framework}/config/fact_groups.rb

@@ -9,7 +9,8 @@ module Facter
     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')
+      default_path = File.join(File.dirname(__FILE__), '../../fact_groups.conf')
+      @groups_file_path = group_list_path || default_path
       @groups ||= File.readable?(@groups_file_path) ? Hocon.load(@groups_file_path) : {}
       load_groups
     end

data/lib/{framework → facter/framework}/core/cache_manager.rb

@@ -13,14 +13,17 @@ module Facter
       return searched_facts, [] if !File.directory?(@cache_dir) || !Options[:cache]
 
       facts = []
-      searched_facts.each do |fact|
+      searched_facts.delete_if do |fact|
         res = resolve_fact(fact)
-        facts << res if res
+        if res
+          facts << res
+          true
+        else
+          false
+        end
       end
-      facts.each do |fact|
-        searched_facts.delete_if { |f| f.name == fact.name }
-      end
-      [searched_facts, facts]
+
+      [searched_facts, facts.flatten]
     end
 
     def cache_facts(resolved_facts)
@@ -37,10 +40,21 @@ 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
+      cached
+    end
+
     private
 
     def resolve_fact(searched_fact)
-      group_name = @fact_groups.get_fact_group(searched_fact.name)
+      group_name =  if searched_fact.file
+                      searched_fact.name
+                    else
+                      @fact_groups.get_fact_group(searched_fact.name)
+                    end
+
       return unless group_name
 
       return unless group_cached?(group_name)
@@ -51,16 +65,32 @@ module Facter
       return unless data
 
       @log.debug("loading cached values for #{group_name} facts")
-      create_fact(searched_fact, data[searched_fact.name])
+
+      create_facts(searched_fact, data)
     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)
+    def create_facts(searched_fact, data)
+      if searched_fact.type == :file
+        facts = []
+        data.each do |fact_name, fact_value|
+          fact = Facter::ResolvedFact.new(fact_name, fact_value, searched_fact.type,
+                                          searched_fact.user_query, searched_fact.filter_tokens)
+          fact.file = searched_fact.file
+          facts << fact
+        end
+        facts
+      else
+        [Facter::ResolvedFact.new(searched_fact.name, data[searched_fact.name], searched_fact.type,
+                                  searched_fact.user_query, searched_fact.filter_tokens)]
+      end
     end
 
     def cache_fact(fact)
-      group_name = @fact_groups.get_fact_group(fact.name)
+      group_name = if fact.file
+                     File.basename(fact.file)
+                   else
+                     @fact_groups.get_fact_group(fact.name)
+                   end
       return if !group_name || fact.value.nil?
 
       return unless group_cached?(group_name)
@@ -98,12 +128,6 @@ module Facter
       @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

data/lib/{framework → facter/framework}/core/fact/external/external_fact_manager.rb

@@ -17,10 +17,11 @@ module Facter
       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)
+        fact = LegacyFacter[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_fact.file = fact.options[:file]
 
         resolved_custom_facts << resolved_fact
       end