Add qemu and swtpm package info to report html

Signed-off-by: Leidong Wang <leidwang@redhat.com>

Author: leidwang

lib/all.rb

@@ -58,6 +58,7 @@ module AutoHCK
   autoload_relative :MultiLogger, 'auxiliary/multi_logger'
   autoload_relative :NotImplementedError, 'exceptions'
   autoload_relative :OpenJsonError, 'exceptions'
+  autoload_relative :PackageManager, 'auxiliary/package_manager'
   autoload_relative :Pgroup, 'auxiliary/pgroup'
   autoload_relative :PhysHCK, 'setupmanagers/physhck/physhck'
   autoload_relative :Playlist, 'engines/hcktest/playlist'

lib/auxiliary/package_manager.rb

@@ -0,0 +1,205 @@
+# typed: true
+# frozen_string_literal: true
+
+# AutoHCK module
+module AutoHCK
+  # PackageManager class for cross-platform package queries
+  class PackageManager
+    extend T::Sig
+
+    class UnsupportedPlatformError < StandardError; end
+
+    SUPPORTED_DISTROS = {
+      'ubuntu' => :debian,
+      'debian' => :debian,
+      'centos' => :rhel,
+      'rhel' => :rhel,
+      'rocky' => :rhel,
+      'almalinux' => :rhel,
+      'fedora' => :fedora,
+      'arch' => :arch,
+      'manjaro' => :arch
+    }.freeze
+
+    sig { void }
+    def initialize
+      @logger = nil
+      @distro_info = detect_distro
+    end
+
+    sig { params(logger: T.untyped).returns(T.untyped) }
+    attr_writer :logger
+
+    sig { params(binary_path: String).returns(T.nilable(String)) }
+    def query_package(binary_path)
+      return nil if binary_path.empty?
+
+      query_method = distro_query_method(@distro_info[:family])
+      return unsupported_platform_warning unless query_method
+
+      send(query_method, binary_path)
+    rescue StandardError => e
+      log_warning("Failed to query package for #{binary_path}: #{e.message}")
+      nil
+    end
+
+    private
+
+    sig { params(family: Symbol).returns(T.nilable(Symbol)) }
+    def distro_query_method(family)
+      {
+        debian: :query_debian_package,
+        rhel: :query_rhel_package,
+        fedora: :query_fedora_package,
+        arch: :query_arch_package
+      }[family]
+    end
+
+    sig { returns(T.nilable(String)) }
+    def unsupported_platform_warning
+      log_warning("Unsupported platform: #{@distro_info[:name]} (#{@distro_info[:family]})")
+      nil
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def detect_distro
+      # Check for common distribution identification files
+      if File.exist?('/etc/os-release')
+        parse_os_release
+      elsif File.exist?('/etc/lsb-release')
+        parse_lsb_release
+      elsif File.exist?('/etc/redhat-release')
+        parse_redhat_release
+      else
+        { name: 'unknown', family: :unknown }
+      end
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def parse_os_release
+      content = File.read('/etc/os-release')
+      id = content[/^ID=(.+)/, 1]&.gsub(/["']/, '')&.downcase
+
+      return { name: 'unknown', family: :unknown } unless id
+
+      return parse_fedora_release(content, id) if id == 'fedora'
+
+      family = SUPPORTED_DISTROS[id] || :unknown
+      { name: id, family: family }
+    end
+
+    sig { params(content: String, id: String).returns(T::Hash[Symbol, T.untyped]) }
+    def parse_fedora_release(content, id)
+      # Check if it's Fedora Silverblue/Kinoite
+      variant = content[/^VARIANT_ID=(.+)/, 1]&.gsub(/["']/, '')&.downcase
+      family = fedora_immutable_variant?(variant) ? :fedora_immutable : :fedora
+      { name: id, family: family, variant: variant }
+    end
+
+    sig { params(variant: T.nilable(String)).returns(T::Boolean) }
+    def fedora_immutable_variant?(variant)
+      return false unless variant
+
+      variant.include?('silverblue') || variant.include?('kinoite')
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def parse_lsb_release
+      content = File.read('/etc/lsb-release')
+      id = content[/^DISTRIB_ID=(.+)/, 1]&.gsub(/["']/, '')&.downcase
+
+      family = id ? SUPPORTED_DISTROS[id] || :unknown : :unknown
+      { name: id || 'unknown', family: family }
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def parse_redhat_release
+      content = File.read('/etc/redhat-release').downcase
+
+      if content.include?('centos')
+        { name: 'centos', family: :rhel }
+      elsif content.include?('red hat')
+        { name: 'rhel', family: :rhel }
+      elsif content.include?('fedora')
+        { name: 'fedora', family: :fedora }
+      else
+        { name: 'unknown', family: :unknown }
+      end
+    end
+
+    sig { params(binary_path: String).returns(T.nilable(String)) }
+    def query_debian_package(binary_path)
+      # Use dpkg -S to find which package owns the file
+      result = `dpkg -S "#{binary_path}" 2>/dev/null`
+      return nil if $CHILD_STATUS.exitstatus != 0 || result.empty?
+
+      # dpkg -S output format: "package: /path/to/file"
+      package = result.split(':').first&.strip
+      return nil unless package
+
+      # Get the full package version
+      version_result = `dpkg -l "#{package}" 2>/dev/null | tail -1`
+      return package if version_result.empty?
+
+      # dpkg -l output format: "ii  package  version  arch  description"
+      parts = version_result.split
+      return package unless parts.length >= 3
+
+      "#{package}_#{parts[2]}_#{parts[3]}"
+    end
+
+    sig { params(binary_path: String).returns(T.nilable(String)) }
+    def query_rhel_package(binary_path)
+      # Use rpm -qf for RHEL/CentOS
+      result = `rpm -qf "#{binary_path}" 2>/dev/null`
+      return nil if $CHILD_STATUS.exitstatus != 0 || result.empty?
+
+      result.strip
+    end
+
+    sig { params(binary_path: String).returns(T.nilable(String)) }
+    def query_fedora_package(binary_path)
+      # For regular Fedora, use rpm -qf
+      # For Fedora Silverblue/immutable, also use rpm -qf (rpm-ostree manages the rpm db)
+      if @distro_info[:family] == :fedora_immutable
+        log_info("Detected Fedora immutable variant (#{@distro_info[:variant]}), using rpm query")
+      end
+
+      result = `rpm -qf "#{binary_path}" 2>/dev/null`
+      return nil if $CHILD_STATUS.exitstatus != 0 || result.empty?
+
+      result.strip
+    end
+
+    sig { params(binary_path: String).returns(T.nilable(String)) }
+    def query_arch_package(binary_path)
+      # Use pacman -Qo for Arch Linux
+      result = `pacman -Qo "#{binary_path}" 2>/dev/null`
+      return nil if $CHILD_STATUS.exitstatus != 0 || result.empty?
+
+      # pacman -Qo output format: "/path/to/file is owned by package version"
+      match = result.match(/is owned by (.+)/)
+      return nil unless match
+
+      T.must(match[1]).strip
+    end
+
+    sig { params(message: String).void }
+    def log_info(message)
+      if @logger
+        @logger.info(message)
+      else
+        puts "INFO: #{message}"
+      end
+    end
+
+    sig { params(message: String).void }
+    def log_warning(message)
+      if @logger
+        @logger.warn(message)
+      else
+        puts "WARNING: #{message}"
+      end
+    end
+  end
+end

lib/engines/hcktest/tests.rb

@@ -398,16 +398,31 @@ def archive_test_results(test, test_result)
       @logger.info('Test results uploaded via the result uploader')
     end
 
+    def build_system_info_data
+      data = { 'guest' => @clients_system_info }
+
+      if @project.setup_manager
+        host_info = {}
+        qemu_version = @project.setup_manager.hypervisor_package_info
+        swtpm_version = @project.setup_manager.hypervisor_dependencies_package_info
+
+        host_info['qemu_version'] = qemu_version unless qemu_version.nil? || qemu_version.empty?
+        host_info['swtpm_version'] = swtpm_version unless swtpm_version.nil? || swtpm_version.empty?
+
+        data['host'] = host_info unless host_info.empty?
+      end
+
+      data
+    end
+
     def report_data
       {
         'tag' => @tag,
         'test_stats' => tests_stats,
         'rejected_test' => @playlist.rejected_test,
         'tests' => @tests,
         'url' => @project.result_uploader.url,
-        'system_info' => {
-          'guest' => @clients_system_info
-        },
+        'system_info' => build_system_info_data,
         'sections' => RESULTS_REPORT_SECTIONS - @project.options.test.reject_report_sections
       }
     end

lib/setupmanagers/physhck/physhck.rb

@@ -49,6 +49,16 @@ def hypervisor_info
       @logger.info('Hypervisor info is currently not supported for physical machines')
     end
 
+    def hypervisor_package_info
+      @logger.info('Hypervisor package info is currently not supported for physical machines')
+      nil
+    end
+
+    def hypervisor_dependencies_package_info
+      @logger.info('swtpm package info is currently not supported for physical machines')
+      nil
+    end
+
     def host_info
       @logger.info('Host info is currently not supported for physical machines')
     end

lib/setupmanagers/qemuhck/qemuhck.rb

@@ -20,6 +20,8 @@ def initialize(project)
       initialize_project project
 
       @clients_vm = {}
+      @package_manager = PackageManager.new
+      @package_manager.logger = @logger
       initialize_studio_vm
       initialize_clients_vm
       create_qemuhck_log_file
@@ -134,13 +136,27 @@ def hypervisor_info
       `#{@studio_vm.config['qemu_bin']} --version`.lines.first.strip
     end
 
+    def hypervisor_package_info
+      binary_path = @studio_vm.config['qemu_bin']
+      @package_manager.query_package(binary_path) || "Unknown package for #{binary_path}"
+    end
+
+    def hypervisor_dependencies_package_info
+      binary_path = `which #{@studio_vm.config['swtpm_bin']} 2>/dev/null`.strip
+      return 'swtpm binary not found' if binary_path.empty?
+
+      @package_manager.query_package(binary_path) || "Unknown package for #{binary_path}"
+    end
+
     def host_info
       `uname -a`.strip
     end
 
     def append_host_info(logs)
       logs << <<~HOST_INFO
         QEMU version: #{hypervisor_info}
+        QEMU package: #{hypervisor_package_info}
+        swtpm package: #{hypervisor_dependencies_package_info}
         System information: #{host_info}
 
       HOST_INFO

lib/templates/report.html.erb

@@ -21,7 +21,7 @@
             </div>
             <% end %>
             <% if sections.include? 'guest_info' %>
-            <div class="col col-8">
+            <div class="col col-4">
                 <p class="text-center">Guest system information</p>
                 <% system_info['guest'].each do |_, guest_info| %>
                     <% guest_info.each do |k, v| %>
@@ -30,6 +30,17 @@
                 <% end %>
             </div>
             <% end %>
+            <% if system_info['host'] %>
+            <div class="col col-4">
+                <p class="text-center">Host system information</p>
+                <% if system_info['host']['qemu_version'] %>
+                <p>QEMU version: <%= system_info['host']['qemu_version'] %></p>
+                <% end %>
+                <% if system_info['host']['swtpm_version'] %>
+                <p>swtpm version: <%= system_info['host']['swtpm_version'] %></p>
+                <% end %>
+            </div>
+            <% end %>
         </div>
         <div class="row pb-3">
             <p>Report generation time: <%= Time.now %></p>