openfact 5.0.0.rc0

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Memory < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { validate_info(fact_name) }
+        end
+
+        def read_performance_information
+          require_relative '../../../facter/resolvers/windows/ffi/memory_ffi'
+
+          state_ptr = FFI::MemoryPointer.new(PerformanceInformation.size)
+          if MemoryFFI::GetPerformanceInfo(state_ptr, state_ptr.size) == FFI::WIN32FALSE
+            @log.debug 'Resolving memory facts failed'
+            return
+          end
+
+          # we need to enlarge the scope of this pointer so that Ruby GC will not free the memory.
+          # If the pointer if freed, Lifreq structures will contain garbage from memory.
+          @long_living_pointer = state_ptr
+
+          PerformanceInformation.new(state_ptr)
+        rescue LoadError => e
+          @log.debug("Could not resolve memory facts: #{e}")
+        end
+
+        def calculate_memory
+          state = read_performance_information
+          return unless state
+
+          total_bytes = state[:PhysicalTotal] * state[:PageSize]
+          available_bytes = state[:PhysicalAvailable] * state[:PageSize]
+          if total_bytes.zero? || available_bytes.zero?
+            @log.debug 'Available or Total bytes are zero could not proceed further'
+            return
+          end
+
+          { total_bytes: total_bytes, available_bytes: available_bytes, used_bytes: total_bytes - available_bytes }
+        end
+
+        def validate_info(fact_name)
+          result = calculate_memory
+          return unless result
+
+          build_facts_list(result)
+          @fact_list[fact_name]
+        end
+
+        def build_facts_list(result)
+          @fact_list[:total_bytes] = result[:total_bytes]
+          @fact_list[:available_bytes] = result[:available_bytes]
+          @fact_list[:used_bytes] = result[:used_bytes]
+          @fact_list[:capacity] = format(
+            '%<capacity>.2f%%', capacity: (result[:used_bytes] / result[:total_bytes].to_f * 100)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'win32/registry'
+
+module Facter
+  module Resolvers
+    class NetKVM < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @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('SYSTEM\\CurrentControlSet\\Services')
+          build_fact_list(reg)
+          reg.close
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(reg)
+          # rubocop:disable Performance/InefficientHashSearch
+          @fact_list[:kvm] = reg.keys.include?('netkvm')
+          # rubocop:enable Performance/InefficientHashSearch
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class Networking < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_network_information(fact_name) }
+          end
+
+          def read_network_information(fact_name)
+            require_relative '../../../facter/resolvers/windows/ffi/networking_ffi'
+
+            size_ptr = FFI::MemoryPointer.new(NetworkingFFI::BUFFER_LENGTH)
+            adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
+            flags = NetworkingFFI::GAA_FLAG_SKIP_ANYCAST |
+                    NetworkingFFI::GAA_FLAG_SKIP_MULTICAST | NetworkingFFI::GAA_FLAG_SKIP_DNS_SERVER
+
+            return unless (adapter_addresses = get_adapter_addresses(size_ptr, adapter_addresses, flags))
+
+            retrieve_domain_from_registry
+
+            iterate_list(adapter_addresses)
+
+            Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+
+            @fact_list[fact_name]
+          rescue LoadError => e
+            @log.debug("The ffi gem has not been installed: #{e}")
+          end
+
+          def get_adapter_addresses(size_ptr, adapter_addresses, flags)
+            error = nil
+            3.times do
+              error = NetworkingFFI::GetAdaptersAddresses(NetworkingFFI::AF_UNSPEC, flags,
+                                                          FFI::Pointer::NULL, adapter_addresses, size_ptr)
+              break if error == NetworkingFFI::ERROR_SUCCES
+
+              if error == NetworkingFFI::ERROR_BUFFER_OVERFLOW
+                adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
+              else
+                @log.debug 'Unable to retrieve networking facts!'
+                return nil
+              end
+            end
+            return nil unless error.zero?
+
+            adapter_addresses
+          end
+
+          def adapter_down?(adapter)
+            adapter[:OperStatus] != NetworkingFFI::IF_OPER_STATUS_UP ||
+              ![NetworkingFFI::IF_TYPE_ETHERNET_CSMACD, NetworkingFFI::IF_TYPE_IEEE80211].include?(adapter[:IfType])
+          end
+
+          def retrieve_dhcp_server(adapter)
+            if !(adapter[:Flags] & NetworkingFFI::IP_ADAPTER_DHCP_ENABLED).zero? &&
+               adapter[:Union][:Struct][:Length] >= IpAdapterAddressesLh.size
+              NetworkUtils.address_to_string(adapter[:Dhcpv4Server])
+            end
+          end
+
+          def iterate_list(adapter_addresses)
+            net_interface = {}
+            IpAdapterAddressesLh.read_list(adapter_addresses) do |adapter_address|
+              if adapter_down?(adapter_address)
+                adapter_address = IpAdapterAddressesLh.new(adapter_address[:Next])
+                next
+              end
+              if !@fact_list[:domain] || @fact_list[:domain].empty?
+                @fact_list[:domain] = adapter_address[:DnsSuffix]
+                                      .read_wide_string_without_length(replace_invalid_chars: true)
+              end
+              name = adapter_address[:FriendlyName].read_wide_string_without_length(replace_invalid_chars: true)
+              net_interface[name] = build_interface_info(adapter_address, name)
+            end
+
+            @fact_list[:interfaces] = net_interface unless net_interface.empty?
+          end
+
+          def build_interface_info(adapter_address, name)
+            hash = {}
+
+            hash[:dhcp] = retrieve_dhcp_server(adapter_address)
+            hash[:mtu] = adapter_address[:Mtu]
+
+            bindings = find_ip_addresses(adapter_address[:FirstUnicastAddress], name)
+            hash[:bindings] = bindings[:ipv4] unless bindings[:ipv4].empty?
+            hash[:bindings6] = bindings[:ipv6] unless bindings[:ipv6].empty?
+            hash[:mac] = NetworkUtils.find_mac_address(adapter_address)
+            hash
+          end
+
+          def find_ip_addresses(unicast_addresses, name)
+            bindings = {}
+            bindings[:ipv6] = []
+            bindings[:ipv4] = []
+
+            IpAdapterUnicastAddressLH.read_list(unicast_addresses) do |unicast|
+              addr = NetworkUtils.address_to_string(unicast[:Address])
+              unless addr
+                unicast = IpAdapterUnicastAddressLH.new(unicast[:Next])
+                next
+              end
+
+              sock_addr = SockAddr.new(unicast[:Address][:lpSockaddr])
+              add_ip_data(addr, unicast, sock_addr, bindings)
+              find_primary_interface(sock_addr, name, addr)
+            end
+            bindings
+          end
+
+          def add_ip_data(addr, unicast, sock_addr, bindings)
+            result = find_bindings(sock_addr, unicast, addr)
+            return unless result
+
+            bindings[:ipv6] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET6
+            bindings[:ipv4] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET
+          end
+
+          def find_bindings(sock_addr, unicast, addr)
+            return unless [NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family])
+
+            Facter::Util::Resolvers::Networking.build_binding(addr, unicast[:OnLinkPrefixLength])
+          end
+
+          def find_primary_interface(sock_addr, name, addr)
+            if !@fact_list[:primary_interface] &&
+               [NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family]) &&
+               !::Facter::Util::Resolvers::Networking.ignored_ip_address(addr)
+              @fact_list[:primary_interface] = name.to_s
+            end
+          end
+
+          def retrieve_domain_from_registry
+            ::Win32::Registry::HKEY_LOCAL_MACHINE.open(
+              'SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters'
+            ) do |key|
+              domain = key['Domain']
+              @fact_list[:domain] = domain if domain
+            end
+          rescue Win32::Registry::Error
+            @log.debug('Could not read TCPIP Parameters from registry')
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Processors < BaseResolver
+      init_resolver
+
+      class << self
+        # Count
+        # Isa
+        # Models
+        # PhysicalCount
+
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_fact_from_win32_processor(fact_name) }
+        end
+
+        def read_fact_from_win32_processor(fact_name)
+          win = Facter::Util::Windows::Win32Ole.new
+          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)
+          cores_threads = calculate_cores_threads(proc, result)
+          build_fact_list(result, cores_threads)
+          @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_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)
+          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 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
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'win32/registry'
+
+module Facter
+  module Resolvers
+    class ProductRelease < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @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, _type, value|
+            case name
+            when 'EditionID'
+              @fact_list[:edition_id] = value
+            when 'InstallationType'
+              @fact_list[:installation_type] = value
+            when 'ProductName'
+              @fact_list[:product_name] = value
+            when 'DisplayVersion'
+              @fact_list[:release_id] = value
+              @fact_list[:display_version] = value
+            when 'ReleaseId'
+              @fact_list[:release_id] = value unless @fact_list[:release_id]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class Ssh < BaseResolver
+        init_resolver
+
+        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, _options)
+            @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 = Facter::Util::FileHelper.safe_read(File.join(ssh_dir, file_name))
+              next if output.empty?
+
+              key_type, key = output.split(' ')
+              ssh_list << Facter::Util::Resolvers::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/facter/resolvers/windows/system32.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class System32 < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_windows_binaries_path }
+        end
+
+        def retrieve_windows_binaries_path
+          require_relative '../../../facter/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)
+        rescue LoadError => e
+          @log.debug("Could not retrieve: #{e}")
+        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/facter/resolvers/windows/timezone.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class Timezone < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { determine_timezone }
+          end
+
+          def determine_timezone
+            timezone = Time.now.zone
+            @fact_list[:timezone] = timezone.force_encoding("CP#{codepage}").encode('UTF-8', invalid: :replace)
+          rescue ArgumentError
+            @fact_list[:timezone] = timezone
+          end
+
+          def codepage
+            result = codepage_from_api
+            result&.empty? ? codepage_from_registry : result
+          end
+
+          def codepage_from_registry
+            require 'win32/registry'
+            ::Win32::Registry::HKEY_LOCAL_MACHINE.open('SYSTEM\CurrentControlSet\Control\Nls\CodePage')['ACP']
+          end
+
+          def codepage_from_api
+            require_relative '../../../facter/resolvers/windows/ffi/winnls_ffi'
+            WinnlsFFI.GetACP.to_s
+          rescue LoadError => e
+            log.debug("Could not retrieve codepage: #{e}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Facter
+  module Resolvers
+    module Windows
+      class Uptime < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { calculate_system_uptime(fact_name) }
+          end
+
+          def subtract_system_uptime_from_ole
+            win = Facter::Util::Windows::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 = subtract_system_uptime_from_ole&.to_i
+            if !seconds || seconds.negative?
+              @log.debug 'Unable to determine system uptime!'
+              return
+            end
+
+            @fact_list = Facter::Util::Resolvers::UptimeHelper.create_uptime_hash(seconds)
+            @fact_list[fact_name]
+          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/facter/resolvers/windows/virtualization.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class Virtualization < BaseResolver
+        init_resolver
+
+        class << self
+          # Virtual
+          # Is_Virtual
+
+          MODEL_HASH = {
+            'VirtualBox' => 'virtualbox',
+            'VMware' => 'vmware',
+            'KVM' => 'kvm',
+            'Bochs' => 'bochs',
+            'Google' => 'gce',
+            'OpenStack' => 'openstack',
+            'AHV' => 'ahv'
+          }.freeze
+
+          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
+            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 /^Xen/.match?(manufacturer)
+              'xen'
+            elsif /^Amazon EC2/.match?(manufacturer)
+              '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
+end