facter 4.0.23

data/lib/resolvers/windows/processors_resolver.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Processors < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list = {}
+      class << self
+        # Count
+        # Isa
+        # Models
+        # PhysicalCount
+
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_win32_processor(fact_name) }
+        end
+
+        def read_fact_from_win32_processor(fact_name)
+          win = Win32Ole.new
+          proc = win.exec_query('SELECT Name,Architecture,NumberOfLogicalProcessors FROM Win32_Processor')
+          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)
+          @fact_list[fact_name]
+        end
+
+        def iterate_proc(result)
+          models = []
+          isa = nil
+          logical_count = 0
+          result.each do |proc|
+            models << proc.Name
+            logical_count += proc.NumberOfLogicalProcessors if proc.NumberOfLogicalProcessors
+            isa ||= find_isa(proc.Architecture)
+          end
+
+          { models: models, isa: isa, logical_count: logical_count.zero? ? models.count : logical_count }
+        end
+
+        def find_isa(arch)
+          architecture_hash =
+            { 0 => 'x86', 1 => 'MIPS', 2 => 'Alpha', 3 => 'PowerPC', 5 => 'ARM', 6 => 'Itanium', 9 => 'x64' }
+          isa = architecture_hash[arch]
+          return isa if isa
+
+          log.debug 'Unable to determine processor type: unknown architecture'
+        end
+
+        def build_fact_list(result)
+          @fact_list[:count] = result[:logical_count]
+          @fact_list[:isa] = result[:isa]
+          @fact_list[:models] = result[:models]
+          @fact_list[:physicalcount] = result[:models].size
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/product_release_resolver.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'win32/registry'
+
+module Facter
+  module Resolvers
+    class ProductRelease < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_registry(fact_name) }
+        end
+
+        def read_fact_from_registry(fact_name)
+          reg = ::Win32::Registry::HKEY_LOCAL_MACHINE.open('SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion')
+          build_fact_list(reg)
+          reg.close
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(reg)
+          reg.each do |name, _value|
+            @fact_list[:edition_id] = reg[name] if name == 'EditionID'
+            @fact_list[:installation_type] = reg[name] if name == 'InstallationType'
+            @fact_list[:product_name] = reg[name] if name == 'ProductName'
+            @fact_list[:release_id] = reg[name] if name == 'ReleaseId'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/ssh.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class Ssh < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        FILE_NAMES = %w[ssh_host_rsa_key.pub ssh_host_dsa_key.pub
+                        ssh_host_ecdsa_key.pub ssh_host_ed25519_key.pub].freeze
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+          end
+
+          def retrieve_info(fact_name)
+            ssh_dir = determine_ssh_dir
+            return unless ssh_dir && File.directory?(ssh_dir)
+
+            ssh_list = []
+
+            FILE_NAMES.each do |file_name|
+              output = Util::FileHelper.safe_read(File.join(ssh_dir, file_name))
+              next if output.empty?
+
+              key_type, key = output.split(' ')
+              ssh_list << ::Resolvers::Utils::SshHelper.create_ssh(key_type, key)
+            end
+            @fact_list[:ssh] = ssh_list.empty? ? nil : ssh_list
+            @fact_list[fact_name]
+          end
+
+          def determine_ssh_dir
+            progdata_dir = ENV['programdata']
+
+            return if !progdata_dir || progdata_dir.empty?
+
+            File.join(progdata_dir, 'ssh')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/system32_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class System32 < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_windows_binaries_path }
+        end
+
+        def retrieve_windows_binaries_path
+          require "#{ROOT_DIR}/lib/resolvers/windows/ffi/system32_ffi"
+
+          windows_path = ENV['SystemRoot']
+
+          if !windows_path || windows_path.empty?
+            @log.debug 'Unable to find correct value for SystemRoot enviroment variable'
+            return nil
+          end
+
+          bool_ptr = FFI::MemoryPointer.new(:win32_bool, 1)
+          if System32FFI::IsWow64Process(System32FFI::GetCurrentProcess(), bool_ptr) == FFI::WIN32FALSE
+            @log.debug 'IsWow64Process failed'
+            return
+          end
+
+          @fact_list[:system32] = construct_path(bool_ptr, windows_path)
+        end
+
+        def construct_path(bool_ptr, windows)
+          if bool_ptr.read_win32_bool
+            "#{windows}\\sysnative"
+          else
+            "#{windows}\\system32"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/uptime_resolver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Facter
+  module Resolvers
+    module Windows
+      class Uptime < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { calculate_system_uptime(fact_name) }
+          end
+
+          def substract_system_uptime_from_ole
+            win = Win32Ole.new
+            opsystem = win.return_first('SELECT LocalDateTime,LastBootUpTime FROM Win32_OperatingSystem')
+            unless opsystem
+              @log.debug 'WMI query returned no results'\
+          'for Win32_OperatingSystem with values LocalDateTime and LastBootUpTime.'
+              return
+            end
+
+            local_time = opsystem.LocalDateTime
+            last_bootup = opsystem.LastBootUpTime
+
+            return DateTime.parse(local_time).to_time - DateTime.parse(last_bootup).to_time if local_time && last_bootup
+
+            nil
+          end
+
+          def calculate_system_uptime(fact_name)
+            seconds = substract_system_uptime_from_ole.to_i if substract_system_uptime_from_ole
+            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[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]
+            @fact_list[:seconds] = system_uptime[:seconds]
+            @fact_list[:uptime] = system_uptime[:uptime]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/utils/win32ole.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'win32ole'
+
+class Win32Ole
+  RPC_C_IMP_LEVEL_IMPERSONATE = 3
+
+  def initialize
+    locator = WIN32OLE.new('WbemScripting.SWbemLocator')
+    @conn = locator.ConnectServer('.', 'root\\cimv2')
+    @conn.Security_.ImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE
+  end
+
+  def return_first(query)
+    result = exec_query(query)
+    return result.to_enum.first if result
+
+    nil
+  end
+
+  def exec_query(query)
+    @conn.execquery(query)
+  end
+end

data/lib/resolvers/windows/virtualization_resolver.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Virtualization < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        # Virtual
+        # Is_Virtual
+
+        MODEL_HASH = { 'VirtualBox' => 'virtualbox', 'VMware' => 'vmware', 'KVM' => 'kvm',
+                       'Bochs' => 'bochs', 'Google' => 'gce', 'OpenStack' => 'openstack' }.freeze
+
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
+        end
+
+        def read_fact_from_computer_system(fact_name)
+          win = 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
+
+          build_fact_list(comp)
+          @fact_list[fact_name]
+        end
+
+        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
+
+        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)
+
+          @fact_list[:virtual] = hypervisor
+          @fact_list[:is_virtual] = hypervisor.include?('physical') ? false : true
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/win_os_description_resolver.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class WinOsDescription < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_from_ole(fact_name) }
+        end
+
+        def read_from_ole(fact_name)
+          win = Win32Ole.new
+          op_sys = win.return_first('SELECT ProductType,OtherTypeDescription FROM Win32_OperatingSystem')
+          unless op_sys
+            @log.debug 'WMI query returned no results for Win32_OperatingSystem'\
+                       'with values ProductType and OtherTypeDescription.'
+            return
+          end
+          @fact_list[:consumerrel] = (op_sys.ProductType == 1)
+          @fact_list[:description] = op_sys.OtherTypeDescription
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/wpar_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Wpar < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_wpar(fact_name) }
+        end
+
+        def read_wpar(fact_name)
+          output = Facter::Core::Execution.execute('/usr/bin/lparstat -W', logger: log)
+
+          return if output.empty?
+
+          output.each_line do |line|
+            populate_wpar_data(line.split(':').map(&:strip))
+          end
+          @fact_list[fact_name]
+        end
+
+        def populate_wpar_data(key_value)
+          @fact_list[:wpar_key]              = key_value[1].to_i if key_value[0] == 'WPAR Key'
+          @fact_list[:wpar_configured_id]    = key_value[1].to_i if key_value[0] == 'WPAR Configured ID'
+        end
+      end
+    end
+  end
+end

data/lib/util/api_debugger.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ApiDebugger
+  def self.prepended(receiver) # rubocop:disable Metrics/AbcSize
+    exclude, print_caller = parse_options(ENV['API_DEBUG'])
+
+    receiver_methods = receiver.instance_methods - Object.methods
+    receiver_methods.each do |meth|
+      ApiDebugger.class_eval do
+        define_method(meth) do |*args|
+          method_call = super(*args)
+
+          unless exclude.include?(meth)
+            puts '#' * 80
+            puts "Method call: #{meth}"
+            puts "Called with: #{args.inspect}"
+            if print_caller.include?(meth)
+              puts '-' * 80
+              puts caller
+            end
+            puts '#' * 80
+          end
+          method_call
+        end
+      end
+    end
+  end
+
+  def self.parse_options(options)
+    exclude = []
+    print_caller = []
+
+    options.split(',').each do |option|
+      if option.start_with?('-')
+        exclude << option[1..-1].to_sym
+      elsif option.start_with?('+')
+        print_caller << option[1..-1].to_sym
+      end
+    end
+
+    [exclude, print_caller]
+  end
+end