Add version checking to hypervisor interface

Author: sjmiller609

lib/hypervisor/cloudhypervisor/process.go

@@ -40,6 +40,12 @@ func (s *Starter) GetBinaryPath(p *paths.Paths, version string) (string, error)
 	return vmm.GetBinaryPath(p, chVersion)
 }
 
+// GetVersion returns the latest supported Cloud Hypervisor version.
+// Cloud Hypervisor binaries are embedded, so we return the latest known version.
+func (s *Starter) GetVersion(p *paths.Paths) (string, error) {
+	return string(vmm.V49_0), nil
+}
+
 // StartVM launches Cloud Hypervisor, configures the VM, and boots it.
 // Returns the process ID and a Hypervisor client for subsequent operations.
 func (s *Starter) StartVM(ctx context.Context, p *paths.Paths, version string, socketPath string, config hypervisor.VMConfig) (int, hypervisor.Hypervisor, error) {

lib/hypervisor/hypervisor.go

@@ -53,6 +53,11 @@ type VMStarter interface {
 	// GetBinaryPath returns the path to the hypervisor binary, extracting if needed.
 	GetBinaryPath(p *paths.Paths, version string) (string, error)
 
+	// GetVersion returns the version of the hypervisor binary.
+	// For embedded binaries (Cloud Hypervisor), returns the latest supported version.
+	// For system binaries (QEMU), queries the installed binary for its version.
+	GetVersion(p *paths.Paths) (string, error)
+
 	// StartVM launches the hypervisor process and boots the VM.
 	// Returns the process ID and a Hypervisor client for subsequent operations.
 	StartVM(ctx context.Context, p *paths.Paths, version string, socketPath string, config VMConfig) (pid int, hv Hypervisor, err error)

lib/hypervisor/qemu/process.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"syscall"
 	"time"
@@ -63,6 +64,30 @@ func (s *Starter) GetBinaryPath(p *paths.Paths, version string) (string, error)
 	return "", fmt.Errorf("%s not found; install with: %s", binaryName, qemuInstallHint())
 }
 
+// GetVersion returns the version of the installed QEMU binary.
+// Parses the output of "qemu-system-* --version" to extract the version string.
+func (s *Starter) GetVersion(p *paths.Paths) (string, error) {
+	binaryPath, err := s.GetBinaryPath(p, "")
+	if err != nil {
+		return "", err
+	}
+
+	cmd := exec.Command(binaryPath, "--version")
+	output, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("get qemu version: %w", err)
+	}
+
+	// Parse "QEMU emulator version 8.2.0 (Debian ...)" -> "8.2.0"
+	re := regexp.MustCompile(`version (\d+\.\d+(?:\.\d+)?)`)
+	matches := re.FindStringSubmatch(string(output))
+	if len(matches) >= 2 {
+		return matches[1], nil
+	}
+
+	return "", fmt.Errorf("could not parse QEMU version from: %s", string(output))
+}
+
 // StartVM launches QEMU with the VM configuration and returns a Hypervisor client.
 // QEMU receives all configuration via command-line arguments at process start.
 func (s *Starter) StartVM(ctx context.Context, p *paths.Paths, version string, socketPath string, config hypervisor.VMConfig) (int, hypervisor.Hypervisor, error) {

lib/hypervisor/qemu/process_test.go

@@ -0,0 +1,100 @@
+package qemu
+
+import (
+	"os/exec"
+	"regexp"
+	"testing"
+
+	"github.com/onkernel/hypeman/lib/paths"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestGetVersion_Integration is an integration test that verifies GetVersion
+// works correctly with the actual QEMU binary installed on the system.
+func TestGetVersion_Integration(t *testing.T) {
+	// Skip if QEMU is not installed
+	binaryName, err := qemuBinaryName()
+	if err != nil {
+		t.Skipf("Skipping test: %v", err)
+	}
+
+	_, err = exec.LookPath(binaryName)
+	if err != nil {
+		t.Skipf("Skipping test: QEMU binary %s not found in PATH", binaryName)
+	}
+
+	// Create starter and get version
+	starter := NewStarter()
+	tmpDir := t.TempDir()
+	p := paths.New(tmpDir)
+
+	version, err := starter.GetVersion(p)
+	require.NoError(t, err, "GetVersion should not return an error")
+
+	// Verify version is not empty
+	assert.NotEmpty(t, version, "Version should not be empty")
+
+	// Verify version matches expected format (e.g., "8.2.0", "9.0", "7.2.1")
+	versionPattern := regexp.MustCompile(`^\d+\.\d+(\.\d+)?$`)
+	assert.Regexp(t, versionPattern, version, "Version should match pattern X.Y or X.Y.Z")
+
+	t.Logf("Detected QEMU version: %s", version)
+}
+
+// TestGetVersion_ParsesVersionCorrectly tests the version parsing logic
+// with various version string formats.
+func TestGetVersion_ParsesVersionCorrectly(t *testing.T) {
+	tests := []struct {
+		name     string
+		output   string
+		expected string
+		wantErr  bool
+	}{
+		{
+			name:     "debian format",
+			output:   "QEMU emulator version 8.2.0 (Debian 1:8.2.0+dfsg-1)",
+			expected: "8.2.0",
+		},
+		{
+			name:     "simple format",
+			output:   "QEMU emulator version 9.0.0",
+			expected: "9.0.0",
+		},
+		{
+			name:     "two part version",
+			output:   "QEMU emulator version 9.0",
+			expected: "9.0",
+		},
+		{
+			name:     "with git info",
+			output:   "QEMU emulator version 7.2.1 (qemu-7.2.1-1.fc38)",
+			expected: "7.2.1",
+		},
+		{
+			name:    "invalid format",
+			output:  "Some random output",
+			wantErr: true,
+		},
+		{
+			name:    "empty output",
+			output:  "",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Use the same regex as in GetVersion
+			re := regexp.MustCompile(`version (\d+\.\d+(?:\.\d+)?)`)
+			matches := re.FindStringSubmatch(tt.output)
+
+			if tt.wantErr {
+				assert.Less(t, len(matches), 2, "Should not match for invalid input")
+			} else {
+				require.GreaterOrEqual(t, len(matches), 2, "Should find version match")
+				assert.Equal(t, tt.expected, matches[1], "Parsed version should match expected")
+			}
+		})
+	}
+}

lib/instances/create.go

@@ -15,7 +15,6 @@ import (
 	"github.com/onkernel/hypeman/lib/logger"
 	"github.com/onkernel/hypeman/lib/network"
 	"github.com/onkernel/hypeman/lib/system"
-	"github.com/onkernel/hypeman/lib/vmm"
 	"github.com/onkernel/hypeman/lib/volumes"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/trace"
@@ -225,6 +224,13 @@ func (m *manager) createInstance(
 		return nil, fmt.Errorf("get vm starter for %s: %w", hvType, err)
 	}
 
+	// Get hypervisor version
+	hvVersion, err := starter.GetVersion(m.paths)
+	if err != nil {
+		log.WarnContext(ctx, "failed to get hypervisor version", "hypervisor", hvType, "error", err)
+		hvVersion = "unknown"
+	}
+
 	// 10. Validate, resolve, and auto-bind devices (GPU passthrough)
 	// Track devices we've marked as attached for cleanup on error.
 	// The cleanup closure captures this slice by reference, so it will see
@@ -295,7 +301,7 @@ func (m *manager) createInstance(
 		StoppedAt:         nil,
 		KernelVersion:     string(kernelVer),
 		HypervisorType:    hvType,
-		HypervisorVersion: string(vmm.V49_0), // Use latest
+		HypervisorVersion: hvVersion,
 		SocketPath:        m.paths.InstanceSocket(id, starter.SocketName()),
 		DataDir:           m.paths.InstanceDir(id),
 		VsockCID:          vsockCID,