facter 4.0.51 → 4.2.1

data/lib/facter/resolvers/solaris/mountpoints.rb

@@ -14,23 +14,26 @@ module Facter
             @fact_list.fetch(fact_name) { read_mounts(fact_name) }
           end
 
-          def root_device
-            cmdline = Facter::Util::FileHelper.safe_read('/proc/cmdline')
-            match = cmdline.match(/root=([^\s]+)/)
-            match&.captures&.first
-          end
-
-          def compute_device(device)
-            # If the "root" device, lookup the actual device from the kernel options
-            # This is done because not all systems symlink /dev/root
-            device = root_device if device == '/dev/root'
-            device
+          def exclude_auto_home_mounts!
+            @mounts.reject! do |mount|
+              parent = mount[:path].rpartition('/').first
+              @auto_home_paths.include?(parent)
+            end
           end
 
           def read_mounts(fact_name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-            mounts = []
+            @mounts = []
+            @auto_home_paths = []
+
             Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
-              device = compute_device(fs.name)
+              if fs.name == 'auto_home'
+                @auto_home_paths << fs.mount_point
+                next
+              end
+
+              next if fs.mount_type == 'autofs'
+
+              device = fs.name
               filesystem = fs.mount_type
               path = fs.mount_point
               options = fs.options.split(',').map(&:strip)
@@ -47,11 +50,14 @@ module Facter
               available = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes)
               used = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
 
-              mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
-                             .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+              @mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                              .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
                 .map { |v| binding.local_variable_get(v) })]
             end
-            @fact_list[:mountpoints] = mounts
+
+            exclude_auto_home_mounts!
+
+            @fact_list[:mountpoints] = @mounts
             @fact_list[fact_name]
           end
         end

data/lib/facter/resolvers/solaris/networking.rb

@@ -101,16 +101,31 @@ module Facter
           end
 
           def inet_ntop(lifreq, ss_family)
-            sockaddr = FFI::Sockaddr.new(lifreq.lifru_addr.to_ptr)
-            sockaddr_in = FFI::SockaddrIn.new(sockaddr.to_ptr)
-            ip = FFI::InAddr.new(sockaddr_in[:sin_addr].to_ptr)
-            buffer_size = FFI::INET_ADDRSTRLEN
-            buffer_size = FFI::INET6_ADDRSTRLEN if ss_family == FFI::AF_INET6
+            if ss_family == FFI::AF_INET
+              buffer_size = FFI::INET_ADDRSTRLEN
+              ip = get_ipv4(lifreq)
+            else # FFI::AF_INET6
+              buffer_size = FFI::INET6_ADDRSTRLEN
+              ip = get_ipv6(lifreq)
+            end
+
             buffer = ::FFI::MemoryPointer.new(:char, buffer_size)
 
             FFI::Ioctl.inet_ntop(ss_family, ip.to_ptr, buffer.to_ptr, buffer.size)
           end
 
+          def get_ipv4(lifreq)
+            sockaddr = FFI::Sockaddr.new(lifreq.lifru_addr.to_ptr)
+            sockaddr_in = FFI::SockaddrIn.new(sockaddr.to_ptr)
+            FFI::InAddr.new(sockaddr_in[:sin_addr].to_ptr)
+          end
+
+          def get_ipv6(lifreq)
+            sockaddr = FFI::Sockaddr.new(lifreq.lifru_addr.to_ptr)
+            sockaddr_in6 = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+            FFI::In6Addr.new(sockaddr_in6[:sin6_addr].to_ptr)
+          end
+
           def count_interfaces
             lifnum = FFI::Lifnum.new
             lifnum[:lifn_family] = FFI::AF_UNSPEC

data/lib/facter/resolvers/solaris/processors.rb

@@ -28,6 +28,13 @@ module Facter
             @fact_list[:physical_count] = output.scan(/chip_id .*/).uniq.size
             @fact_list[:speed] = output.scan(/current_clock_Hz .*/).first.gsub(/[a-zA-z\s]+/, '').to_i
             @fact_list[:models] = output.scan(/brand .*/).map { |elem| elem.gsub(/brand(\s+)/, '') }
+            calculate_threads_cores(output)
+          end
+
+          def calculate_threads_cores(output)
+            @fact_list[:core_count] = output.scan(/\score_id .*/).uniq.size
+            @fact_list[:threads_per_core] = @fact_list[:logical_count] / @fact_list[:core_count]
+            @fact_list[:cores_per_socket] = @fact_list[:core_count] / @fact_list[:physical_count]
           end
         end
       end

data/lib/facter/resolvers/solaris/zone.rb

@@ -38,7 +38,6 @@ module Facter
                 uuid: uuid,
                 status: status,
                 path: path
-
               }
             end
             zones_fact

data/lib/facter/resolvers/windows/ffi/identity_ffi.rb

@@ -12,4 +12,9 @@ module IdentityFFI
   ffi_convention :stdcall
   ffi_lib :shell32
   attach_function :IsUserAnAdmin, [], :win32_bool
+
+  def self.privileged?
+    result = self.IsUserAnAdmin()
+    result && result != FFI::WIN32FALSE
+  end
 end

data/lib/facter/resolvers/windows/ffi/kernel_ffi.rb

@@ -7,7 +7,7 @@ module KernelFFI
   extend FFI::Library
 
   ffi_convention :stdcall
-  ffi_lib [FFI::CURRENT_PROCESS, :ntdll]
+  ffi_lib :ntdll
   attach_function :RtlGetVersion, [:pointer], :int32
 
   STATUS_SUCCESS = 0

data/lib/facter/resolvers/windows/identity.rb

@@ -31,12 +31,7 @@ module Facter
             return
           end
 
-          { user: name_ptr.read_wide_string_with_length(size_ptr.read_uint32), privileged: privileged? }
-        end
-
-        def privileged?
-          result = IdentityFFI::IsUserAnAdmin()
-          result && result != FFI::WIN32FALSE
+          { user: name_ptr.read_wide_string_with_length(size_ptr.read_uint32), privileged: IdentityFFI.privileged? }
         end
 
         def retrieve_facts(fact_name)

data/lib/facter/resolvers/windows/processors.rb

@@ -19,14 +19,19 @@ module Facter
 
         def read_fact_from_win32_processor(fact_name)
           win = Facter::Util::Windows::Win32Ole.new
-          proc = win.exec_query('SELECT Name,Architecture,NumberOfLogicalProcessors FROM Win32_Processor')
+          query_string = 'SELECT Name,'\
+          'Architecture,'\
+          'NumberOfLogicalProcessors,'\
+          'NumberOfCores FROM Win32_Processor'
+          proc = win.exec_query(query_string)
           unless proc
             log.debug 'WMI query returned no results'\
             'for Win32_Processor with values Name, Architecture and NumberOfLogicalProcessors.'
             return
           end
           result = iterate_proc(proc)
-          build_fact_list(result)
+          cores_threads = calculate_cores_threads(proc, result)
+          build_fact_list(result, cores_threads)
           @fact_list[fact_name]
         end
 
@@ -40,7 +45,29 @@ module Facter
             isa ||= find_isa(proc.Architecture)
           end
 
-          { models: models, isa: isa, logical_count: logical_count.zero? ? models.count : logical_count }
+          { models: models,
+            isa: isa,
+            logical_count: logical_processors_count(logical_count, models.count) }
+        end
+
+        def calculate_cores_threads(result_proc, data_proc)
+          cores = 0
+          threads_per_core = 0
+          result_proc.each do |proc|
+            cores = proc.NumberOfCores
+            threads_per_core = if check_hyperthreading(data_proc[:logical_count], cores) ||
+                                  cores > data_proc[:logical_count]
+                                 1
+                               else
+                                 data_proc[:logical_count] / (cores * data_proc[:models].size)
+                               end
+          end
+          { cores_per_socket: cores,
+            threads_per_core: threads_per_core }
+        end
+
+        def check_hyperthreading(cores, logical_processors)
+          cores == logical_processors
         end
 
         def find_isa(arch)
@@ -52,11 +79,21 @@ module Facter
           log.debug 'Unable to determine processor type: unknown architecture'
         end
 
-        def build_fact_list(result)
+        def logical_processors_count(logical_count, models_count)
+          if logical_count.zero?
+            models_count
+          else
+            logical_count
+          end
+        end
+
+        def build_fact_list(result, cores_threads)
           @fact_list[:count] = result[:logical_count]
           @fact_list[:isa] = result[:isa]
           @fact_list[:models] = result[:models]
           @fact_list[:physicalcount] = result[:models].size
+          @fact_list[:cores_per_socket] = cores_threads[:cores_per_socket]
+          @fact_list[:threads_per_core] = cores_threads[:threads_per_core]
         end
       end
     end

data/lib/facter/resolvers/windows/uptime.rb

@@ -17,7 +17,7 @@ module Facter
             @fact_list.fetch(fact_name) { calculate_system_uptime(fact_name) }
           end
 
-          def substract_system_uptime_from_ole
+          def subtract_system_uptime_from_ole
             win = Facter::Util::Windows::Win32Ole.new
             opsystem = win.return_first('SELECT LocalDateTime,LastBootUpTime FROM Win32_OperatingSystem')
             unless opsystem
@@ -35,35 +35,16 @@ module Facter
           end
 
           def calculate_system_uptime(fact_name)
-            seconds = substract_system_uptime_from_ole.to_i if substract_system_uptime_from_ole
+            seconds = subtract_system_uptime_from_ole&.to_i
             if !seconds || seconds.negative?
               @log.debug 'Unable to determine system uptime!'
               return
             end
 
-            hours = seconds / 3600
-            days = hours / 24
-
-            result = { seconds: seconds, hours: hours, days: days }
-
-            result[:uptime] = determine_uptime(result)
-            build_fact_list(result)
-
+            @fact_list = Facter::Util::Resolvers::UptimeHelper.create_uptime_hash(seconds)
             @fact_list[fact_name]
           end
 
-          def determine_uptime(result_hash)
-            minutes = (result_hash[:seconds] - result_hash[:hours] * 3600) / 60
-
-            if result_hash[:days].zero?
-              "#{result_hash[:hours]}:#{minutes} hours"
-            elsif result_hash[:days] == 1
-              "#{result_hash[:days]} day"
-            else
-              "#{result_hash[:days]} days"
-            end
-          end
-
           def build_fact_list(system_uptime)
             @fact_list[:days] = system_uptime[:days]
             @fact_list[:hours] = system_uptime[:hours]

data/lib/facter/resolvers/windows/virtualization.rb

@@ -2,63 +2,65 @@
 
 module Facter
   module Resolvers
-    class Virtualization < BaseResolver
-      @log = Facter::Log.new(self)
+    module Windows
+      class Virtualization < BaseResolver
+        @log = Facter::Log.new(self)
 
-      init_resolver
+        init_resolver
 
-      class << self
-        # Virtual
-        # Is_Virtual
+        class << self
+          # Virtual
+          # Is_Virtual
 
-        MODEL_HASH = { 'VirtualBox' => 'virtualbox', 'VMware' => 'vmware', 'KVM' => 'kvm',
-                       'Bochs' => 'bochs', 'Google' => 'gce', 'OpenStack' => 'openstack' }.freeze
+          MODEL_HASH = { 'VirtualBox' => 'virtualbox', 'VMware' => 'vmware', 'KVM' => 'kvm',
+                         'Bochs' => 'bochs', 'Google' => 'gce', 'OpenStack' => 'openstack' }.freeze
 
-        private
+          private
 
-        def post_resolve(fact_name, _options)
-          @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
-        end
-
-        def read_fact_from_computer_system(fact_name)
-          win = Facter::Util::Windows::Win32Ole.new
-          comp = win.exec_query('SELECT Manufacturer,Model,OEMStringArray FROM Win32_ComputerSystem')
-          unless comp
-            @log.debug 'WMI query returned no results for Win32_ComputerSystem with values'\
-            ' Manufacturer, Model and OEMStringArray.'
-            return
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
           end
 
-          build_fact_list(comp)
-          @fact_list[fact_name]
-        end
+          def read_fact_from_computer_system(fact_name)
+            win = Facter::Util::Windows::Win32Ole.new
+            comp = win.exec_query('SELECT Manufacturer,Model,OEMStringArray FROM Win32_ComputerSystem')
+            unless comp
+              @log.debug 'WMI query returned no results for Win32_ComputerSystem with values'\
+              ' Manufacturer, Model and OEMStringArray.'
+              return
+            end
 
-        def determine_hypervisor_by_model(comp)
-          MODEL_HASH[MODEL_HASH.keys.find { |key| comp.Model =~ /^#{key}/ }]
-        end
+            build_fact_list(comp)
+            @fact_list[fact_name]
+          end
 
-        def determine_hypervisor_by_manufacturer(comp)
-          manufacturer = comp.Manufacturer
-          if comp.Model =~ /^Virtual Machine/ && manufacturer =~ /^Microsoft/
-            'hyperv'
-          elsif manufacturer =~ /^Xen/
-            'xen'
-          elsif manufacturer =~ /^Amazon EC2/
-            'kvm'
-          else
-            'physical'
+          def determine_hypervisor_by_model(comp)
+            MODEL_HASH[MODEL_HASH.keys.find { |key| comp.Model =~ /^#{key}/ }]
+          end
+
+          def determine_hypervisor_by_manufacturer(comp)
+            manufacturer = comp.Manufacturer
+            if comp.Model =~ /^Virtual Machine/ && manufacturer =~ /^Microsoft/
+              'hyperv'
+            elsif manufacturer =~ /^Xen/
+              'xen'
+            elsif manufacturer =~ /^Amazon EC2/
+              'kvm'
+            else
+              'physical'
+            end
           end
-        end
 
-        def build_fact_list(comp)
-          @fact_list[:oem_strings] = []
-          @fact_list[:oem_strings] += comp.to_enum.map(&:OEMStringArray).flatten
+          def build_fact_list(comp)
+            @fact_list[:oem_strings] = []
+            @fact_list[:oem_strings] += comp.to_enum.map(&:OEMStringArray).flatten
 
-          comp = comp.to_enum.first
-          hypervisor = determine_hypervisor_by_model(comp) || determine_hypervisor_by_manufacturer(comp)
+            comp = comp.to_enum.first
+            hypervisor = determine_hypervisor_by_model(comp) || determine_hypervisor_by_manufacturer(comp)
 
-          @fact_list[:virtual] = hypervisor
-          @fact_list[:is_virtual] = hypervisor.include?('physical') ? false : true
+            @fact_list[:virtual] = hypervisor
+            @fact_list[:is_virtual] = hypervisor.include?('physical') ? false : true
+          end
         end
       end
     end

data/lib/facter/resolvers/xen.rb

@@ -56,7 +56,12 @@ module Facter
         end
 
         def find_command
-          return XEN_TOOLSTACK if File.exist?(XEN_TOOLSTACK)
+          num_stacks = 0
+          XEN_COMMANDS.each do |command|
+            num_stacks += 1 if File.exist?(command)
+          end
+
+          return XEN_TOOLSTACK if num_stacks > 1 && File.exist?(XEN_TOOLSTACK)
 
           XEN_COMMANDS.each { |command| return command if File.exist?(command) }
         end

data/lib/facter/templates/man.erb

@@ -13,18 +13,26 @@ Many of the command line options can also be set via the HOCON config file. This
 
 OPTIONS
 -------
-<% @Facter::Cli.class_options.each do |name, option| -%><% next if option.hide%>
+<% Facter::Cli.class_options.each do |name, option| -%><% next if option.hide%>
   * `<%= option.aliases[0] + '`, `' if option.aliases.any? %>--<%= 'no-' if negate_options.include?(name.to_s)%><%= name.to_s.gsub('_','-') %>`:
 
     <%= option.description %>
 
 <% end -%>
 
+<% Facter::Cli.commands.select { |_k, command_class| command_class.instance_of?(Thor::Command) }.each do |_, command| -%>
+  * `<%= command.usage %>`:
+
+    <%= command.description %>
+
+
+<% end -%>
+
 FILES
 -----
 <em>/etc/puppetlabs/facter/facter.conf</em>
 
-A HOCON config file that can be used to specify directories for custom and external facts, set various command line options, and specify facts to block. See example below for details, or visit the GitHub README.
+A HOCON config file that can be used to specify directories for custom and external facts, set various command line options, and specify facts to block. See example below for details, or visit the [GitHub README](https://github.com/puppetlabs/puppetlabs-hocon#overview).
 
 EXAMPLES
 --------
@@ -47,7 +55,7 @@ dmi => {
     version => "6.00"
   }
 }
-[\.\.\.]
+[...]
 ```
 
 Display a single structured fact:
@@ -83,7 +91,7 @@ $ facter processorcount
 Format facts as JSON:
 
 ```
-$ facter \-\-json os.name os.release.major processors.isa
+$ facter --json os.name os.release.major processors.isa
 {
   "os.name": "Ubuntu",
   "os.release.major": "14.04",
@@ -112,7 +120,7 @@ cli : {
     verbose   : false,
     log-level : "info"
 }
-# always loaded, fact-sepcific configuration
+# always loaded, fact-specific configuration
 facts : {
     # for valid blocklist entries, use --list-block-groups
     blocklist : [ "file system", "EC2" ],