feat: register RHEL VM at startup

package.json

@@ -45,6 +45,12 @@
           "description": "Image Path",
           "when": "rhel-vms.localImage"
         },
+        "rhel-vms.factory.machine.register": {
+          "type": "boolean",
+          "scope": "VmProviderConnectionFactory",
+          "default": true,
+          "description": "Register machine via subscription-manager"
+        },
         "rhel-vms.factory.machine.cpus": {
           "type": "number",
           "format": "cpu",

src/extension.spec.ts

@@ -20,7 +20,7 @@ import { resolve } from 'node:path';
 import * as macadamJSPackage from '@crc-org/macadam.js';
 import * as extensionApi from '@podman-desktop/api';
 import { vol } from 'memfs';
-import { assert, beforeEach, describe, expect, test, vi } from 'vitest';
+import { afterEach, assert, beforeEach, describe, expect, test, vi } from 'vitest';
 
 import * as authentication from './authentication';
 import { ImageCache } from './cache';
@@ -48,6 +48,7 @@ vi.mock('@crc-org/macadam.js', async () => {
   Macadam.prototype.startVm = vi.fn();
   Macadam.prototype.stopVm = vi.fn();
   Macadam.prototype.removeVm = vi.fn();
+  Macadam.prototype.executeCommand = vi.fn();
   return { Macadam };
 });
 vi.mock('./macadam-machine-stream.js', async () => {
@@ -137,6 +138,7 @@ describe('activate', () => {
         );
         await create({
           'rhel-vms.factory.machine.image': 'RHEL 10',
+          'rhel-vms.factory.machine.register': false,
         });
         expect(utils.pullImageFromRedHatRegistry).toHaveBeenCalled();
       });
@@ -148,6 +150,7 @@ describe('activate', () => {
         await create({
           'rhel-vms.factory.machine.image': 'RHEL 10',
           'rhel-vms.factory.machine.force-download': true,
+          'rhel-vms.factory.machine.register': false,
         });
         vol.fromJSON({
           '/path/to/storage/images/rhel10': '',
@@ -165,6 +168,7 @@ describe('activate', () => {
         });
         await create({
           'rhel-vms.factory.machine.image': 'RHEL 10',
+          'rhel-vms.factory.machine.register': false,
         });
         expect(utils.pullImageFromRedHatRegistry).not.toHaveBeenCalled();
       });
@@ -176,6 +180,7 @@ describe('activate', () => {
         await create({
           'rhel-vms.factory.machine.name': 'name1',
           'rhel-vms.factory.machine.image': 'RHEL 10',
+          'rhel-vms.factory.machine.register': false,
         });
         expect(macadamJSPackage.Macadam.prototype.createVm).toHaveBeenCalledWith({
           containerProvider: 'applehv',
@@ -191,6 +196,7 @@ describe('activate', () => {
           'rhel-vms.factory.machine.image': 'local image on disk',
           'rhel-vms.factory.machine.name': 'name1',
           'rhel-vms.factory.machine.image-path': resolve('/', 'path', 'to', 'provided', 'image'),
+          'rhel-vms.factory.machine.register': false,
         });
         expect(macadamJSPackage.Macadam.prototype.createVm).toHaveBeenCalledWith({
           containerProvider: 'applehv',
@@ -221,6 +227,7 @@ describe('activate', () => {
         );
         await create({
           'rhel-vms.factory.machine.image': 'RHEL 10',
+          'rhel-vms.factory.machine.register': false,
         });
         expect(utils.pullImageFromRedHatRegistry).toHaveBeenCalled();
       });
@@ -234,6 +241,7 @@ describe('activate', () => {
         });
         await create({
           'rhel-vms.factory.machine.image': 'RHEL 10',
+          'rhel-vms.factory.machine.register': false,
         });
         expect(utils.pullImageFromRedHatRegistry).not.toHaveBeenCalled();
       });
@@ -245,6 +253,7 @@ describe('activate', () => {
         await create({
           'rhel-vms.factory.machine.name': 'name1',
           'rhel-vms.factory.machine.image': 'RHEL 10',
+          'rhel-vms.factory.machine.register': false,
         });
         expect(macadamJSPackage.Macadam.prototype.createVm).toHaveBeenCalledWith({
           containerProvider: 'wsl',
@@ -260,6 +269,7 @@ describe('activate', () => {
           'rhel-vms.factory.machine.image': 'local image on disk',
           'rhel-vms.factory.machine.name': 'name1',
           'rhel-vms.factory.machine.image-path': resolve('/', 'path', 'to', 'provided', 'image'),
+          'rhel-vms.factory.machine.register': false,
         });
         expect(macadamJSPackage.Macadam.prototype.createVm).toHaveBeenCalledWith({
           containerProvider: 'wsl',
@@ -288,6 +298,7 @@ describe('activate', () => {
         await expect(
           create({
             'rhel-vms.factory.machine.image': 'RHEL 10',
+            'rhel-vms.factory.machine.register': false,
           }),
         ).rejects.toThrowError('provider hyperv is not supported');
       });
@@ -304,6 +315,7 @@ describe('activate', () => {
         await expect(
           create({
             'rhel-vms.factory.machine.image': 'RHEL 10',
+            'rhel-vms.factory.machine.register': false,
           }),
         ).rejects.toThrowError('an init error');
       });
@@ -517,3 +529,104 @@ bla bla
     });
   });
 });
+
+describe('register', () => {
+  let create: (
+    params: {
+      [key: string]: unknown;
+    },
+    logger?: extensionApi.Logger,
+    token?: extensionApi.CancellationToken,
+  ) => Promise<void>;
+
+  const extensionContext: extensionApi.ExtensionContext = {
+    subscriptions: {
+      push: vi.fn(),
+    },
+    storagePath: resolve('/', 'path', 'to', 'storage'),
+  } as unknown as extensionApi.ExtensionContext;
+
+  const provider: extensionApi.Provider = {
+    setVmProviderConnectionFactory: vi.fn(),
+    registerVmProviderConnection: vi.fn(),
+    updateStatus: vi.fn(),
+  } as unknown as extensionApi.Provider;
+
+  const authClient: SubscriptionManagerClientV1 = {
+    images: {
+      downloadImageUsingSha: vi.fn(),
+    },
+  } as unknown as SubscriptionManagerClientV1;
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    vi.mocked(extensionApi.provider.createProvider).mockReturnValue(provider);
+
+    vi.mocked(extensionApi.env).isMac = true;
+    vi.mocked(extensionApi.env).isWindows = false;
+    vi.mocked(authentication.initAuthentication).mockResolvedValue(authClient);
+
+    await activate(extensionContext);
+    expect(provider.setVmProviderConnectionFactory).toHaveBeenCalledOnce();
+    const call = vi.mocked(provider.setVmProviderConnectionFactory).mock.calls[0];
+    assert(!!call[0].create);
+    create = call[0].create;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test('register is true and machine is started and registered', async () => {
+    const authClient: SubscriptionManagerClientV1 = {
+      getOrganizationId: vi.fn().mockReturnValue('123456'),
+    } as unknown as SubscriptionManagerClientV1;
+    vi.mocked(authentication.initAuthentication).mockResolvedValue(authClient);
+    vi.mocked(macadamJSPackage.Macadam.prototype.listVms).mockResolvedValue([
+      {
+        Name: 'name1',
+        Image: '/path/to/image1',
+        CPUs: 1,
+        Memory: '1GB',
+        DiskSize: '1GB',
+        Running: true,
+        Starting: true,
+        Port: 80,
+        RemoteUsername: 'user',
+        IdentityPath: '/path/to/id1',
+        VMType: 'applehv',
+      },
+    ]);
+    vi.mocked(macadamJSPackage.Macadam.prototype.executeCommand).mockResolvedValue({
+      stdout: 'done',
+    } as extensionApi.RunResult);
+    const createPromise = create({
+      'rhel-vms.factory.machine.name': 'name1',
+      'rhel-vms.factory.machine.image': 'RHEL 10',
+      'rhel-vms.factory.machine.register': true,
+    });
+    vi.mocked(macadamJSPackage.Macadam.prototype.listVms).mockResolvedValue([
+      {
+        Name: 'name1',
+        Image: '/path/to/image1',
+        CPUs: 1,
+        Memory: '1GB',
+        DiskSize: '1GB',
+        Running: true,
+        Starting: false,
+        Port: 80,
+        RemoteUsername: 'user',
+        IdentityPath: '/path/to/id1',
+        VMType: 'applehv',
+      },
+    ]);
+    vi.advanceTimersToNextTimer();
+    await createPromise;
+    expect(macadamJSPackage.Macadam.prototype.executeCommand).toHaveBeenCalledWith({
+      name: 'name1',
+      command: 'sudo',
+      args: ['subscription-manager', 'register', '--force', '--activationkey', 'podman-desktop', '--org', '123456'],
+      runOptions: {},
+    });
+  });
+});

src/extension.ts

@@ -444,7 +444,7 @@ async function createProvider(extensionContext: extensionApi.ExtensionContext):
         logger?: extensionApi.Logger,
         token?: extensionApi.CancellationToken,
       ) => {
-        return createVM(imageCache, params, logger, token);
+        return createVM(provider, imageCache, params, logger, token);
       },
       creationDisplayName: 'Virtual machine',
     },
@@ -457,6 +457,7 @@ async function createProvider(extensionContext: extensionApi.ExtensionContext):
 }
 
 async function createVM(
+  provider: extensionApi.Provider,
   imageCache: ImageCache,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   params: { [key: string]: any },
@@ -470,17 +471,17 @@ async function createVM(
     telemetryRecords.OS = 'win';
   }
 
-  let provider: 'wsl' | 'hyperv' | 'applehv' | undefined;
+  let containerProvider: 'wsl' | 'hyperv' | 'applehv' | undefined;
   if (params['rhel-vms.factory.machine.win.provider']) {
-    provider = params['rhel-vms.factory.machine.win.provider'];
-    telemetryRecords.provider = provider;
+    containerProvider = params['rhel-vms.factory.machine.win.provider'];
+    telemetryRecords.provider = containerProvider;
   } else {
     if (extensionApi.env.isWindows) {
-      provider = (await isWSLEnabled()) ? 'wsl' : 'hyperv';
-      telemetryRecords.provider = provider;
+      containerProvider = (await isWSLEnabled()) ? 'wsl' : 'hyperv';
+      telemetryRecords.provider = containerProvider;
     } else if (extensionApi.env.isMac) {
-      provider = 'applehv';
-      telemetryRecords.provider = provider;
+      containerProvider = 'applehv';
+      telemetryRecords.provider = containerProvider;
     }
   }
 
@@ -506,6 +507,12 @@ async function createVM(
     throw new Error('force-download must be a boolean');
   }
 
+  // register
+  const register = params['rhel-vms.factory.machine.register'] ?? true;
+  if (typeof register !== 'boolean') {
+    throw new Error('register must be a boolean');
+  }
+
   if (image) {
     const cachedImagePath = imageCache.getPath(image);
     if (!forceDownload && existsSync(cachedImagePath)) {
@@ -514,7 +521,7 @@ async function createVM(
       logger?.log(`Using image cached in ${cachedImagePath}\n`);
     } else {
       const client = await initAuthentication();
-      const imageSha = getImageSha(provider, image);
+      const imageSha = getImageSha(containerProvider, image);
       logger?.log('Downloading image, please wait...\n');
       await pullImageFromRedHatRegistry(client, imageSha, cachedImagePath, logger, token);
       logger?.log(`Image downloaded\n`);
@@ -530,10 +537,12 @@ async function createVM(
       name: name,
       imagePath: imagePath,
       username: 'core',
-      containerProvider: provider,
+      containerProvider,
       runOptions: { logger, token },
     });
+    logger?.log('VM created\n');
   } catch (error) {
+    logger?.log('VM creation failed\n');
     telemetryRecords.error = error;
     const runError = error as extensionApi.RunError;
 
@@ -547,6 +556,77 @@ async function createVM(
     //in the POC we do not send any telemetry
     //sendTelemetryRecords('macadam.machine.init', telemetryRecords, false);
   }
+
+  if (register) {
+    await startAndRegisterVM(provider, containerProvider, name, logger);
+  }
+}
+
+/* startAndRegisterVM starts a VM and registers it via subscription-manager
+ * Limitation: the machine must be stopped
+ */
+async function startAndRegisterVM(
+  provider: extensionApi.Provider,
+  containerProvider: 'wsl' | 'hyperv' | 'applehv' | undefined,
+  name: string,
+  logger?: extensionApi.Logger,
+): Promise<void> {
+  const list = await macadam.listVms({ containerProvider: containerProvider });
+  const machineInfo = list.find(info => info.Name === name);
+  if (!machineInfo) {
+    throw new Error(`Machine ${name} not found`);
+  }
+
+  const startedPromise = new Promise<void>((resolve, reject) => {
+    const listener = (image: string, status: extensionApi.ProviderConnectionStatus): void => {
+      if (image === machineInfo.Image && status === 'started') {
+        listeners.delete(listener);
+        clearTimeout(timeoutId);
+        resolve();
+      }
+    };
+
+    const timeoutId = setTimeout(() => {
+      listeners.delete(listener);
+      reject(new Error(`Machine ${name} failed to start within timeout`));
+      logger?.log(`VM ${name} failed to start within timeout\n`);
+    }, 60000); // 60 second timeout
+
+    listeners.add(listener);
+  });
+
+  const startPromise = startMachine(provider, {
+    name,
+    image: machineInfo.Image,
+    cpus: machineInfo.CPUs,
+    memory: Number(machineInfo.Memory),
+    diskSize: Number(machineInfo.DiskSize),
+    port: machineInfo.Port,
+    remoteUsername: machineInfo.RemoteUsername,
+    identityPath: machineInfo.IdentityPath,
+    vmType: machineInfo.VMType,
+  });
+  try {
+    await Promise.all([startPromise, startedPromise]);
+    logger?.log('VM started\n');
+  } catch (error) {
+    logger?.log(`VM start failed, the VM cannot be registered: ${String(error)}\n`);
+    throw error;
+  }
+
+  const currentSession = await initAuthentication();
+  const orgId = currentSession.getOrganizationId();
+  logger?.log('Registering VM ...\n');
+  const result = await macadam.executeCommand({
+    name,
+    command: 'sudo',
+    args: ['subscription-manager', 'register', '--force', '--activationkey', 'podman-desktop', '--org', orgId],
+    runOptions: { logger },
+  });
+  if (result.stderr) {
+    throw new Error(result.stderr);
+  }
+  logger?.log('VM registered\n');
 }
 
 function updateWSLHyperVEnabledContextValue(value: boolean): void {