Add hypervisorVersion to report running hypervisor version

Calls ConnectGetVersion() to get the hypervisor version (e.g., CH
50.0.0) and reports it in status.HypervisorVersion, separate from
libVirtVersion.

This complements PR #53 which fixed libVirtVersion to report the actual
libvirt library version using ConnectGetLibVersion().

Author: anokfireball

internal/libvirt/libvirt.go

@@ -39,11 +39,12 @@ import (
 )
 
 type LibVirt struct {
-	virt          *libvirt.Libvirt
-	client        client.Client
-	migrationJobs map[string]context.CancelFunc
-	migrationLock sync.Mutex
-	version       string
+	virt              *libvirt.Libvirt
+	client            client.Client
+	migrationJobs     map[string]context.CancelFunc
+	migrationLock     sync.Mutex
+	version           string
+	hypervisorVersion string
 
 	// Event channels for domains by their libvirt event id.
 	domEventChs     map[libvirt.DomainEventID]<-chan any
@@ -81,14 +82,25 @@ func NewLibVirt(k client.Client) *LibVirt {
 		make(map[string]context.CancelFunc),
 		sync.Mutex{},
 		"N/A",
-		make(map[libvirt.DomainEventID]<-chan any), sync.Mutex{},
-		make(map[libvirt.DomainEventID]map[string]func(context.Context, any)), sync.Mutex{},
+		"N/A",
+		make(map[libvirt.DomainEventID]<-chan any),
+		sync.Mutex{},
+		make(map[libvirt.DomainEventID]map[string]func(context.Context, any)),
+		sync.Mutex{},
 		capabilities.NewClient(),
 		domcapabilities.NewClient(),
 		dominfo.NewClient(),
 	}
 }
 
+// formatLibvirtVersion converts a libvirt version integer to a semver string.
+// Libvirt versions are encoded as major*1000000 + minor*1000 + release.
+// For example, version 8001002 becomes "8.1.2".
+func formatLibvirtVersion(version uint64) string {
+	major, minor, release := version/1000000, (version/1000)%1000, version%1000
+	return fmt.Sprintf("%d.%d.%d", major, minor, release)
+}
+
 func (l *LibVirt) Connect() error {
 	// Check if already connected
 	if l.virt.IsConnected() {
@@ -104,12 +116,18 @@ func (l *LibVirt) Connect() error {
 		return err
 	}
 
-	// Update the version
+	// Update the libvirt library version
 	if version, err := l.virt.ConnectGetLibVersion(); err != nil {
 		logger.Log.Error(err, "unable to fetch libvirt version")
 	} else {
-		major, minor, release := version/1000000, (version/1000)%1000, version%1000
-		l.version = fmt.Sprintf("%d.%d.%d", major, minor, release)
+		l.version = formatLibvirtVersion(version)
+	}
+
+	// Update the hypervisor version
+	if hvVersion, err := l.virt.ConnectGetVersion(); err != nil {
+		logger.Log.Error(err, "unable to fetch hypervisor version")
+	} else {
+		l.hypervisorVersion = formatLibvirtVersion(hvVersion)
 	}
 
 	l.WatchDomainChanges(
@@ -222,7 +240,6 @@ func (l *LibVirt) WatchDomainChanges(
 	handlerId string,
 	handler func(context.Context, any),
 ) {
-
 	// Register the handler so that it is called when an event with the provided
 	// eventId is received.
 	l.domEventChangeHandlersLock.Lock()
@@ -268,10 +285,11 @@ func (l *LibVirt) Process(hv v1.Hypervisor) (v1.Hypervisor, error) {
 	return hv, nil
 }
 
-// Add the libvirt version to the hypervisor instance.
+// Add the libvirt and hypervisor versions to the hypervisor instance.
 func (l *LibVirt) addVersion(old v1.Hypervisor) (v1.Hypervisor, error) {
 	newHv := *old.DeepCopy()
 	newHv.Status.LibVirtVersion = l.version
+	newHv.Status.HypervisorVersion = l.hypervisorVersion
 	return newHv, nil
 }
 

internal/libvirt/libvirt_test.go

@@ -108,9 +108,83 @@ func (m *mockEventloopRunnable) close() {
 	}
 }
 
+func TestFormatLibvirtVersion(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    uint64
+		expected string
+	}{
+		{
+			name:     "libvirt 8.0.0",
+			input:    8000000,
+			expected: "8.0.0",
+		},
+		{
+			name:     "libvirt 8.1.2",
+			input:    8001002,
+			expected: "8.1.2",
+		},
+		{
+			name:     "hypervisor 50.0.0",
+			input:    50000000,
+			expected: "50.0.0",
+		},
+		{
+			name:     "version with all components",
+			input:    10009003,
+			expected: "10.9.3",
+		},
+		{
+			name:     "zero version",
+			input:    0,
+			expected: "0.0.0",
+		},
+		{
+			name:     "large major version",
+			input:    999000000,
+			expected: "999.0.0",
+		},
+		{
+			name:     "large minor version",
+			input:    1999000,
+			expected: "1.999.0",
+		},
+		{
+			name:     "large release version",
+			input:    1000999,
+			expected: "1.0.999",
+		},
+		{
+			name:     "all max components",
+			input:    999999999,
+			expected: "999.999.999",
+		},
+		{
+			name:     "real world: libvirt 10.0.0",
+			input:    10000000,
+			expected: "10.0.0",
+		},
+		{
+			name:     "real world: QEMU 8.2.1",
+			input:    8002001,
+			expected: "8.2.1",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := formatLibvirtVersion(tc.input)
+			if result != tc.expected {
+				t.Errorf("formatLibvirtVersion(%d) = %s, want %s", tc.input, result, tc.expected)
+			}
+		})
+	}
+}
+
 func TestAddVersion(t *testing.T) {
 	l := &LibVirt{
-		version: "8.0.0",
+		version:           "8.0.0",
+		hypervisorVersion: "50.0.0",
 	}
 
 	hv := v1.Hypervisor{}
@@ -123,11 +197,16 @@ func TestAddVersion(t *testing.T) {
 	if result.Status.LibVirtVersion != "8.0.0" {
 		t.Errorf("Expected LibVirtVersion '8.0.0', got '%s'", result.Status.LibVirtVersion)
 	}
+
+	if result.Status.HypervisorVersion != "50.0.0" {
+		t.Errorf("Expected HypervisorVersion '50.0.0', got '%s'", result.Status.HypervisorVersion)
+	}
 }
 
 func TestAddVersion_PreservesOtherFields(t *testing.T) {
 	l := &LibVirt{
-		version: "8.0.0",
+		version:           "8.0.0",
+		hypervisorVersion: "50.0.0",
 	}
 
 	hv := v1.Hypervisor{
@@ -775,6 +854,7 @@ func TestProcess_Success(t *testing.T) {
 func TestProcess_PreservesOriginalOnError(t *testing.T) {
 	l := &LibVirt{
 		version:                  "8.0.0",
+		hypervisorVersion:        "50.0.0",
 		capabilitiesClient:       &mockCapabilitiesClient{err: &testError{"capability error"}},
 		domainCapabilitiesClient: &mockDomCapabilitiesClient{},
 		domainInfoClient:         &mockDomInfoClient{},