facter 4.0.38 → 4.0.43

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

@@ -5,6 +5,10 @@ module Facts
     class Ec2Userdata
       FACT_NAME = 'ec2_userdata'
 
+      def initialize
+        @virtual = Facter::VirtualDetector.new
+      end
+
       def call_the_resolver
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
@@ -16,33 +20,7 @@ module Facts
       private
 
       def aws_hypervisors?
-        virtual = check_virt_what || check_xen || check_product_name || check_bios_vendor || check_lspci
-
-        virtual == 'kvm' || virtual =~ /xen/
-      end
-
-      def check_virt_what
-        Facter::Resolvers::VirtWhat.resolve(:vm)
-      end
-
-      def check_xen
-        Facter::Resolvers::Xen.resolve(:vm)
-      end
-
-      def check_product_name
-        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
-        return unless product_name
-
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
-      end
-
-      def check_bios_vendor
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        return 'kvm' if bios_vendor&.include?('Amazon EC2')
-      end
-
-      def check_lspci
-        Facter::Resolvers::Lspci.resolve(:vm)
+        @virtual.platform =~ /kvm|xen|aws/
       end
     end
   end

data/lib/facter/facts/linux/is_virtual.rb

@@ -5,59 +5,20 @@ module Facts
     class IsVirtual
       FACT_NAME = 'is_virtual'
 
-      def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        fact_value = check_docker_lxc || check_gce || retrieve_from_virt_what || check_vmware
-        fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
-
-        Facter::ResolvedFact.new(FACT_NAME, check_if_virtual(fact_value))
-      end
-
-      def check_gce
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        'gce' if bios_vendor&.include?('Google')
-      end
-
-      def check_docker_lxc
-        Facter::Resolvers::Containers.resolve(:vm)
+      def initialize
+        @virtual = Facter::VirtualDetector.new
       end
 
-      def check_vmware
-        Facter::Resolvers::Vmware.resolve(:vm)
-      end
+      def call_the_resolver
+        fact_value = @virtual.platform
 
-      def retrieve_from_virt_what
-        Facter::Resolvers::VirtWhat.resolve(:vm)
-      end
-
-      def check_open_vz
-        Facter::Resolvers::OpenVz.resolve(:vm)
-      end
-
-      def check_vserver
-        Facter::Resolvers::VirtWhat.resolve(:vserver)
-      end
-
-      def check_xen
-        Facter::Resolvers::Xen.resolve(:vm)
-      end
-
-      def check_other_facts
-        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        return 'kvm' if bios_vendor&.include?('Amazon EC2')
-        return unless product_name
-
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
-
-        nil
+        Facter::ResolvedFact.new(FACT_NAME, check_if_virtual(fact_value))
       end
 
-      def check_lspci
-        Facter::Resolvers::Lspci.resolve(:vm)
-      end
+      private
 
       def check_if_virtual(found_vm)
-        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?
+        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?.to_s
       end
     end
   end

data/lib/facter/facts/linux/virtual.rb

@@ -7,71 +7,16 @@ module Facts
 
       def initialize
         @log = Facter::Log.new(self)
+        @virtual = Facter::VirtualDetector.new
       end
 
-      def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def call_the_resolver
         @log.debug('Linux Virtual Resolver')
-
-        fact_value = check_docker_lxc || check_gce || retrieve_from_virt_what || check_vmware
-        fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
-
+        fact_value = @virtual.platform
         @log.debug("Fact value is: #{fact_value}")
 
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
-
-      def check_gce
-        @log.debug('Checking GCE')
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        'gce' if bios_vendor&.include?('Google')
-      end
-
-      def check_docker_lxc
-        @log.debug('Checking Docker and LXC')
-        Facter::Resolvers::Containers.resolve(:vm)
-      end
-
-      def check_vmware
-        @log.debug('Checking VMware')
-        Facter::Resolvers::Vmware.resolve(:vm)
-      end
-
-      def retrieve_from_virt_what
-        @log.debug('Checking virtual_what')
-        Facter::Resolvers::VirtWhat.resolve(:vm)
-      end
-
-      def check_open_vz
-        @log.debug('Checking OpenVZ')
-        Facter::Resolvers::OpenVz.resolve(:vm)
-      end
-
-      def check_vserver
-        @log.debug('Checking VServer')
-        Facter::Resolvers::VirtWhat.resolve(:vserver)
-      end
-
-      def check_xen
-        @log.debug('Checking XEN')
-        Facter::Resolvers::Xen.resolve(:vm)
-      end
-
-      def check_other_facts
-        @log.debug('Checking others')
-        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
-        bios_vendor =  Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        return 'kvm' if bios_vendor&.include?('Amazon EC2')
-        return unless product_name
-
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
-
-        nil
-      end
-
-      def check_lspci
-        @log.debug('Checking lspci')
-        Facter::Resolvers::Lspci.resolve(:vm)
-      end
     end
   end
 end

data/lib/facter/facts/solaris/disks.rb

@@ -24,7 +24,7 @@ module Facts
 
       def add_legacy_facts(disks, facts)
         disks.each do |disk_name, disk_info|
-          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes], :legacy))
           facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_vendor", disk_info[:vendor], :legacy))
         end
       end

data/lib/facter/facts/solaris/zones.rb

@@ -28,7 +28,7 @@ module Facts
         end
 
         resolved_facts << Facter::ResolvedFact.new('solaris_zones.zones', zones)
-        resolved_facts << Facter::ResolvedFact.new('zones', results.count.to_s, :legacy)
+        resolved_facts << Facter::ResolvedFact.new('zones', results.count, :legacy)
 
         resolved_facts.flatten
       end

data/lib/facter/facts_utils/virtual_detector.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Facter
+  class VirtualDetector
+    def initialize
+      @log = Facter::Log.new(self)
+    end
+
+    def platform # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      fact_value = check_docker_lxc || check_dmi || check_gce || retrieve_from_virt_what || check_vmware
+      fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
+
+      fact_value
+    end
+
+    def check_docker_lxc
+      @log.debug('Checking Docker and LXC')
+      Facter::Resolvers::Containers.resolve(:vm)
+    end
+
+    def check_dmi
+      @log.debug('Checking DMI')
+      vendor = Facter::Resolvers::DmiDecode.resolve(:vendor)
+      @log.debug("dmi detected vendor: #{vendor}")
+      return 'kvm' if vendor =~ /Amazon/
+
+      'xen' if vendor =~ /Xen/
+    end
+
+    def check_gce
+      @log.debug('Checking GCE')
+      bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+      'gce' if bios_vendor&.include?('Google')
+    end
+
+    def check_vmware
+      @log.debug('Checking VMware')
+      Facter::Resolvers::Vmware.resolve(:vm)
+    end
+
+    def retrieve_from_virt_what
+      @log.debug('Checking virtual_what')
+      Facter::Resolvers::VirtWhat.resolve(:vm)
+    end
+
+    def check_open_vz
+      @log.debug('Checking OpenVZ')
+      Facter::Resolvers::OpenVz.resolve(:vm)
+    end
+
+    def check_vserver
+      @log.debug('Checking VServer')
+      Facter::Resolvers::VirtWhat.resolve(:vserver)
+    end
+
+    def check_xen
+      @log.debug('Checking XEN')
+      Facter::Resolvers::Xen.resolve(:vm)
+    end
+
+    def check_other_facts
+      @log.debug('Checking others')
+      product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+      bios_vendor =  Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+      return 'kvm' if bios_vendor&.include?('Amazon EC2')
+      return unless product_name
+
+      Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+      nil
+    end
+
+    def check_lspci
+      @log.debug('Checking lspci')
+      Facter::Resolvers::Lspci.resolve(:vm)
+    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.'
 
@@ -94,6 +79,11 @@ module Facter
                  type: :boolean,
                  desc: 'Show legacy facts when querying all facts.'
 
+    class_option :puppet,
+                 type: :boolean,
+                 aliases: '-p',
+                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+
     class_option :yaml,
                  aliases: '-y',
                  type: :boolean,
@@ -103,17 +93,12 @@ module Facter
                  type: :boolean,
                  desc: 'Enable more aggressive error reporting.'
 
-    class_option :puppet,
-                 type: :boolean,
-                 aliases: '-p',
-                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
-
     class_option :timing,
                  type: :boolean,
                  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'
@@ -126,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
@@ -135,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
@@ -153,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
@@ -165,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