openfact 5.0.0.rc0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class OsRelease < BaseResolver
+        init_resolver
+
+        OS_VERSION_REGEX_PATTERNS = ['Solaris \d+ \d+/\d+ s(\d+)[sx]?_u(\d+)wos_',
+                                     'Solaris (\d+)[.](\d+)', 'Solaris (\d+)'].freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { build_release_facts(fact_name) }
+          end
+
+          def build_release_facts(fact_name)
+            result = Facter::Util::FileHelper.safe_read('/etc/release', nil)
+            return @fact_list[fact_name] = nil if result.nil?
+
+            OS_VERSION_REGEX_PATTERNS.each do |os_version_regex|
+              major, minor = search_for_os_version(/#{os_version_regex}/, result)
+              next unless major || minor
+
+              @fact_list[:major] = major
+              @fact_list[:minor] = minor
+              @fact_list[:full] = major == '10' ? "#{major}_u#{minor}" : "#{major}.#{minor}"
+              break
+            end
+            @fact_list[fact_name]
+          end
+
+          def search_for_os_version(regex_pattern, text)
+            result = text.match(regex_pattern)
+            major, minor = result.captures if result
+            minor = regex_pattern == /Solaris (\d+)/ ? '0' : minor
+            [major, minor] if major && minor
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Processors < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { collect_kstat_info(fact_name) }
+          end
+
+          def collect_kstat_info(fact_name)
+            return unless File.executable?('/usr/bin/kstat')
+
+            kstat_output = Facter::Core::Execution.execute('/usr/bin/kstat -m cpu_info', logger: log)
+            return if kstat_output.empty?
+
+            parse_output(kstat_output.chomp)
+            @fact_list[fact_name]
+          end
+
+          def parse_output(output)
+            @fact_list[:logical_count] = output.scan(/module/).size
+            @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
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Zone < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { build_zone_fact(fact_name) }
+          end
+
+          def build_zone_fact(fact_name)
+            command = '/usr/sbin/zoneadm list -cp'
+            zone_adm_output = Facter::Core::Execution.execute(command, logger: log)
+
+            if zone_adm_output.empty?
+              log.debug("Command #{command} returned an empty result")
+              return
+            end
+            @fact_list[:zone] = create_zone_facts(zone_adm_output)
+
+            @fact_list[fact_name]
+          end
+
+          def create_zone_facts(zones_result)
+            zones_fact = []
+            zones_result.each_line do |zone_line|
+              id, name, status, path, uuid, brand, ip_type = zone_line.split(':')
+              zones_fact << {
+                brand: brand,
+                id: id,
+                iptype: ip_type.chomp,
+                name: name,
+                uuid: uuid,
+                status: status,
+                path: path
+              }
+            end
+            zones_fact
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class ZoneName < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { build_current_zone_name_fact(fact_name) }
+          end
+
+          def build_current_zone_name_fact(fact_name)
+            zone_name_output = Facter::Core::Execution.execute('/bin/zonename', logger: log)
+
+            if zone_name_output.empty?
+              log.debug("Command #{command} returned an empty result")
+              return
+            end
+            @fact_list[:current_zone_name] = zone_name_output.chomp
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/specific_release_file.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SpecificReleaseFile < BaseResolver
+      # :release
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, options)
+          @fact_list.fetch(fact_name) { read_release_file(fact_name, options) }
+        end
+
+        def read_release_file(fact_name, options)
+          release_file = options[:release_file]
+          return unless release_file
+
+          output = Facter::Util::FileHelper.safe_read(release_file, nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          if options[:regex]
+            @fact_list[:release] = output.strip =~ /#{options[:regex]}/ ? Regexp.last_match : nil
+            return @fact_list[fact_name]
+          end
+
+          @fact_list[:release] = output.strip
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/ssh.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    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
+      FILE_PATHS = %w[/etc/ssh /usr/local/etc/ssh /etc /usr/local/etc /etc/opt/ssh].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_list = []
+          FILE_PATHS.each do |file_path|
+            next unless File.directory?(file_path)
+
+            FILE_NAMES.each do |file_name|
+              file_content = Facter::Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
+              next unless file_content
+
+              key_type, key = file_content.split(' ')
+              ssh = Facter::Util::Resolvers::SshHelper.create_ssh(key_type, key)
+              ssh_list << ssh if ssh
+            end
+          end
+          @fact_list[:ssh] = ssh_list
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/suse_release.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SuseRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_suse_release(fact_name) }
+        end
+
+        def read_suse_release(fact_name)
+          output = Facter::Util::FileHelper.safe_read('/etc/SuSE-release', nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          output_strings = output.split(' ')
+
+          @fact_list[:name] = output_strings[0]
+          @fact_list[:version] = output_strings[1]
+          @fact_list[:id] = @fact_list[:name].downcase
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/sw_vers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SwVers < BaseResolver
+      # :productname
+      # :productversion
+      # :productversionextra
+      # :buildversion
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { software_version_system_call(fact_name) }
+        end
+
+        def software_version_system_call(fact_name)
+          output = Facter::Core::Execution.execute('sw_vers', logger: log)
+          release_info = output.delete("\t").split("\n").map { |e| e.split(':') }
+          result = Hash[*release_info.flatten]
+          result.each { |k, v| @fact_list[k.downcase.to_sym] = v }
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/timezone.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    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
+          @fact_list[:timezone] = Time.now.localtime.strftime('%Z')
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/uname.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Uname < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { uname_system_call(fact_name) }
+        end
+
+        def uname_system_call(fact_name)
+          output = Facter::Core::Execution.execute('uname -m &&
+            uname -n &&
+            uname -p &&
+            uname -r &&
+            uname -s &&
+            uname -v', logger: log)
+
+          build_fact_list(output)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(output)
+          uname_results = output.split("\n")
+
+          if !uname_results.empty?
+            @fact_list[:machine],
+            @fact_list[:nodename],
+            @fact_list[:processor],
+            @fact_list[:kernelrelease],
+            @fact_list[:kernelname],
+            @fact_list[:kernelversion] = uname_results.map(&:strip)
+          else
+            log.warn('Request to uname returned no output. Uname related facts are not populated.')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/uptime.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Uptime < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { uptime_system_call(fact_name) }
+        end
+
+        def uptime_system_call(fact_name)
+          seconds = Facter::Util::Facts::UptimeParser.uptime_seconds_unix
+          build_fact_list(seconds)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(seconds)
+          return @fact_list[:uptime] = 'unknown' unless seconds
+
+          @fact_list = Facter::Util::Resolvers::UptimeHelper.create_uptime_hash(seconds)
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/virt_what.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class VirtWhat < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_from_virt_what(fact_name) }
+        end
+
+        def retrieve_from_virt_what(fact_name)
+          output = Facter::Core::Execution.execute('virt-what', logger: log)
+
+          @fact_list[:vm] = determine_xen(output)
+          @fact_list[:vm] ||= determine_other(output)
+          retrieve_vserver unless @fact_list[:vserver]
+
+          @fact_list[fact_name]
+        end
+
+        def determine_xen(output)
+          xen_info = /^xen\n.*/.match(output)
+
+          return unless xen_info
+
+          xen_info = xen_info.to_s
+          return 'xenu' if /xen-domu/.match?(xen_info)
+          return 'xenhvm' if /xen-hvm/.match?(xen_info)
+
+          'xen0' if /xen-dom0/.match?(xen_info)
+        end
+
+        def determine_other(output)
+          values = output.split("\n")
+          other_vm = values.first
+          return unless other_vm
+
+          return 'zlinux' if /ibm_systemz/.match?(other_vm)
+          return retrieve_vserver if /linux_vserver/.match?(other_vm)
+          return (values - ['redhat']).first if values.include?('redhat')
+
+          other_vm
+        end
+
+        def retrieve_vserver
+          proc_status_content = Facter::Util::FileHelper.safe_readlines('/proc/self/status', nil)
+          return unless proc_status_content
+
+          proc_status_content.each do |line|
+            parts = line.split("\s")
+            next unless parts.size.equal?(2)
+
+            next unless /^s_context:|^VxID:/.match?(parts[0])
+            return @fact_list[:vserver] = 'vserver_host' if parts[1] == '0'
+
+            return @fact_list[:vserver] = 'vserver'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/vmware.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Vmware < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { vmware_command(fact_name) }
+        end
+
+        def vmware_command(fact_name)
+          output = Facter::Core::Execution.execute('vmware -v', logger: log)
+          return if output.empty?
+
+          parts = output.split("\s")
+          return unless parts.size.equal?(2)
+
+          @fact_list[:vm] = "#{parts[0].downcase}_#{parts[1].downcase}"
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class AioAgentVersion < BaseResolver
+        REGISTRY_PATH = 'SOFTWARE\\Puppet Labs\\Puppet'
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_version(fact_name) }
+          end
+
+          def read_version(fact_name)
+            ::Win32::Registry::HKEY_LOCAL_MACHINE.open(REGISTRY_PATH) do |reg|
+              build_fact_list(reg)
+            end
+
+            @fact_list[fact_name]
+          rescue Win32::Registry::Error
+            log.debug("The registry path #{REGISTRY_PATH} does not exist")
+          end
+
+          def build_fact_list(reg)
+            puppet_aio_path = read_for_64_bit(reg) || read_for_32_bit(reg)
+
+            return if puppet_aio_path.nil? || puppet_aio_path.empty?
+
+            puppet_aio_version_path = File.join(puppet_aio_path, 'VERSION')
+            aio_agent_version = Facter::Util::FileHelper.safe_read(puppet_aio_version_path, nil)&.chomp
+
+            @fact_list[:aio_agent_version] = aio_agent_version&.match(/^\d+\.\d+\.\d+(\.\d+){0,2}/)&.to_s
+          end
+
+          def read_for_64_bit(reg)
+            reg.read('RememberedInstallDir64')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 64 bit registry')
+            nil
+          end
+
+          def read_for_32_bit(reg)
+            reg.read('RememberedInstallDir')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 32 bit registry')
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DMIBios < BaseResolver
+      init_resolver
+
+      class << self
+        # Manufacturer
+        # SerialNumber
+
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_fact_from_bios(fact_name) }
+        end
+
+        def read_fact_from_bios(fact_name)
+          win = Facter::Util::Windows::Win32Ole.new
+
+          bios = win.return_first('SELECT Manufacturer,SerialNumber from Win32_BIOS')
+          unless bios
+            @log.debug 'WMI query returned no results for Win32_BIOS with values Manufacturer and SerialNumber.'
+            return
+          end
+
+          build_fact_list(bios)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(bios)
+          @fact_list[:manufacturer] = bios.Manufacturer
+          @fact_list[:serial_number] = bios.SerialNumber
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DMIComputerSystem < BaseResolver
+      init_resolver
+
+      class << self
+        # Name
+        # UUID
+
+        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
+          computersystem = win.return_first('SELECT Name,UUID FROM Win32_ComputerSystemProduct')
+          unless computersystem
+            @log.debug 'WMI query returned no results for Win32_ComputerSystemProduct with values Name and UUID.'
+            return
+          end
+
+          build_fact_list(computersystem)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(computersys)
+          @fact_list[:name] = computersys.Name
+          @fact_list[:uuid] = computersys.UUID
+        end
+      end
+    end
+  end
+end