facter 4.0.35 → 4.0.40

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

@@ -6,14 +6,16 @@ module Facts
       FACT_NAME = 'ec2_metadata'
 
       def call_the_resolver
-        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
         fact_value = Facter::Resolvers::Ec2.resolve(:metadata)
 
-        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
       end
 
-      def aws?
+      private
+
+      def aws_hypervisors?
         virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
 
         virtual == 'kvm' || virtual =~ /xen/

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

@@ -6,14 +6,16 @@ module Facts
       FACT_NAME = 'ec2_userdata'
 
       def call_the_resolver
-        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
         fact_value = Facter::Resolvers::Ec2.resolve(:userdata)
 
-        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
       end
 
-      def aws?
+      private
+
+      def aws_hypervisors?
         virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
 
         virtual == 'kvm' || virtual =~ /xen/

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Gce
+      FACT_NAME = 'gce'
+
+      def call_the_resolver
+        virtualization = Facter::Resolvers::Virtualization.resolve(:virtual)
+
+        fact_value = virtualization&.include?('gce') ? Facter::Resolvers::Gce.resolve(:metadata) : nil
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/networking/scope6.rb

@@ -5,11 +5,13 @@ module Facts
     module Networking
       class Scope6
         FACT_NAME = 'networking.scope6'
+        ALIASES = 'scope6'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Windows::Networking.resolve(:scope6)
 
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+           Facter::ResolvedFact.new('scope6', fact_value, :legacy)]
         end
       end
     end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end

data/lib/facter/facts_utils/facts_utils.rb

@@ -6,5 +6,7 @@ module Facter
                          'KVM' => 'kvm', 'Virtual Machine' => 'hyperv', 'RHEV Hypervisor' => 'rhev',
                          'oVirt Node' => 'ovirt', 'HVM domU' => 'xenhvm', 'Bochs' => 'bochs', 'OpenBSD' => 'vmm',
                          'BHYVE' => 'bhyve' }.freeze
+
+    PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
   end
 end

data/lib/facter/framework/benchmarking/timer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+module Facter
+  module Framework
+    module Benchmarking
+      class Timer
+        class << self
+          def measure(fact_name)
+            if Options[:timing]
+              time = Benchmark.measure { yield }
+
+              puts "fact `#{fact_name}`, took: #{time.format('%r')} seconds"
+            else
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

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