fix: handle error so that it is shown in both page and task manager

src/crc-setup.ts

@@ -25,12 +25,12 @@ export async function needSetup(): Promise<boolean> {
     await execPromise(getCrcCli(), ['setup', '--check-only']);
     return false;
   } catch (e) {
+    console.log(e);
     return true;
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function setUpCrc(logger: extensionApi.Logger, askForPreset = false): Promise<boolean> {
+export async function setUpCrc(askForPreset = false): Promise<boolean> {
   if (askForPreset) {
     const preset = await extensionApi.window.showInformationMessage(
       'Which preset bundle would you like to use with OpenShift Local. MicroShift, provides a lightweight and optimized environment with a limited set of services. OpenShift, provides a single node OpenShift cluster with a fuller set of services, including a web console (requires more resources).',

src/crc-start.spec.ts

@@ -24,6 +24,7 @@ import { startCrc } from './crc-start.js';
 import * as logProvider from './log-provider.js';
 import * as daemon from './daemon-commander.js';
 import type { StartInfo } from './types.js';
+import { getLoggerCallback } from './util.js';
 
 vi.mock('@podman-desktop/api', async () => {
   return {
@@ -44,7 +45,7 @@ test('setUpCRC is skipped if already setup, it just perform the daemon start com
     {
       updateStatus: vi.fn(),
     } as unknown as extensionApi.Provider,
-    {} as extensionApi.Logger,
+    getLoggerCallback(),
     { logUsage: vi.fn() } as unknown as extensionApi.TelemetryLogger,
   );
   expect(setUpMock).not.toBeCalled();
@@ -65,7 +66,7 @@ test('set up CRC and then start the daemon', async () => {
     {
       updateStatus: vi.fn(),
     } as unknown as extensionApi.Provider,
-    {} as extensionApi.Logger,
+    getLoggerCallback(),
     { logUsage: vi.fn() } as unknown as extensionApi.TelemetryLogger,
   );
   expect(setUpMock).toBeCalled();

src/crc-start.ts

@@ -37,7 +37,7 @@ const missingPullSecret = 'Failed to ask for pull secret';
 
 export async function startCrc(
   provider: extensionApi.Provider,
-  logger: extensionApi.Logger,
+  loggerCallback: (data: string) => void,
   telemetryLogger: extensionApi.TelemetryLogger,
 ): Promise<boolean> {
   telemetryLogger.logUsage('crc.start', {
@@ -49,16 +49,15 @@ export async function startCrc(
     if (isNeedSetup) {
       try {
         crcStatus.setSetupRunning(true);
-        await setUpCrc(logger);
+        await setUpCrc();
       } catch (error) {
-        logger.error(error);
         provider.updateStatus('stopped');
-        return;
+        throw error;
       } finally {
         crcStatus.setSetupRunning(false);
       }
     }
-    await crcLogProvider.startSendingLogs(logger);
+    await crcLogProvider.startSendingLogs(loggerCallback);
     const result = await commander.start();
     if (result.Status === 'Running') {
       provider.updateStatus('started');
@@ -72,26 +71,26 @@ export async function startCrc(
       // check that crc missing pull secret
       if (err.message.startsWith(missingPullSecret)) {
         // ask user to provide pull secret
-        if (await askAndStorePullSecret(logger)) {
+        if (await askAndStorePullSecret()) {
           // if pull secret provided try to start again
-          return startCrc(provider, logger, telemetryLogger);
+          return startCrc(provider, loggerCallback, telemetryLogger);
         } else {
-          throw new Error('Could not start without pullsecret!');
+          throw new Error(`${productName} start error: VM cannot be started without the pullsecret`);
         }
       } else if (err.name === 'RequestError' && err.code === 'ECONNRESET') {
         // look like crc start normally, but we receive empty response from socket, so 'got' generate an error
         provider.updateStatus('started');
         return true;
       }
     }
-    await extensionApi.window.showErrorMessage(`${productName} start error: ${err}`);
     console.error(err);
     provider.updateStatus('stopped');
+    throw new Error(`${productName} start error: ${err}`);
   }
   return false;
 }
 
-async function askAndStorePullSecret(logger: extensionApi.Logger): Promise<boolean> {
+async function askAndStorePullSecret(): Promise<boolean> {
   let pullSecret: string;
   const authSession: extensionApi.AuthenticationSession | undefined = await extensionApi.authentication.getSession(
     'redhat.authentication-provider',
@@ -147,7 +146,6 @@ async function askAndStorePullSecret(logger: extensionApi.Logger): Promise<boole
     return true;
   } catch (error) {
     console.error(error);
-    logger.error(error);
   }
   return false;
 }

src/crc-status.ts

@@ -44,7 +44,7 @@ export class CrcStatus {
       try {
         // we don't need to update status while setup is going
         if (this.isSetupGoing) {
-          this._status = createStatus('Starting', this._status.Preset);
+          this._status = createStatus('Stopped', this._status.Preset);
           return;
         }
         const oldStatus = this._status;
@@ -93,7 +93,7 @@ export class CrcStatus {
   setSetupRunning(setup: boolean): void {
     if (setup) {
       this.isSetupGoing = true;
-      this._status = createStatus('Starting', this._status.Preset);
+      this._status = createStatus('Stopped', this._status.Preset);
     } else {
       this.isSetupGoing = false;
     }

src/daemon-commander.ts

@@ -129,6 +129,7 @@ export class DaemonCommander {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const response = await (got as any).post(url, {
       body: value,
+      enableUnixSockets: true,
       throwHttpErrors: false,
       retry: {
         limit: 0,

src/extension.ts

@@ -21,7 +21,7 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
 import { commander, isDaemonRunning } from './daemon-commander.js';
-import { defaultPreset, getPresetLabel, isWindows, productName, providerId } from './util.js';
+import { defaultPreset, getLoggerCallback, getPresetLabel, isWindows, productName, providerId } from './util.js';
 import type { CrcVersion } from './crc-cli.js';
 import { getPreset } from './crc-cli.js';
 import { getCrcVersion } from './crc-cli.js';
@@ -30,17 +30,16 @@ import { CrcInstall } from './install/crc-install.js';
 
 import { crcStatus } from './crc-status.js';
 import { startCrc } from './crc-start.js';
-import { needSetup, setUpCrc } from './crc-setup.js';
 import { deleteCrc, registerDeleteCommand } from './crc-delete.js';
 import { presetChangedEvent, saveConfig, syncPreferences } from './preferences.js';
 import { stopCrc } from './crc-stop.js';
 import { registerOpenTerminalCommand } from './dev-terminal.js';
 import { commandManager } from './command.js';
 import { registerOpenConsoleCommand } from './crc-console.js';
 import { registerLogInCommands } from './login-commands.js';
-import { defaultLogger } from './logger.js';
 import { pushImageToCrcCluster } from './image-handler.js';
 import type { Preset } from './types.js';
+import { needSetup, setUpCrc } from './crc-setup.js';
 
 const CRC_PUSH_IMAGE_TO_CLUSTER = 'crc.image.push.to.cluster';
 const CRC_PRESET_KEY = 'crc.crcPreset';
@@ -219,15 +218,19 @@ function registerProviderConnectionFactory(
   extensionContext: extensionApi.ExtensionContext,
   telemetryLogger: extensionApi.TelemetryLogger,
 ): void {
+  let justInitialized = false;
   connectionFactoryDisposable = provider.setKubernetesProviderConnectionFactory(
     {
       initialize: async () => {
-        await createCrcVm(provider, extensionContext, telemetryLogger, defaultLogger);
+        await initializeCrc(provider, extensionContext, telemetryLogger);
+        justInitialized = true;
       },
       create: async (params, logger) => {
         await presetChanged(provider, extensionContext, telemetryLogger);
         await saveConfig(params);
-        if (params['crc.factory.start.now']) {
+        if (params['crc.factory.start.now'] || justInitialized) {
+          justInitialized = false;
+          await connectToCrc();
           await createCrcVm(provider, extensionContext, telemetryLogger, logger);
         }
       },
@@ -248,18 +251,11 @@ async function createCrcVm(
   logger: extensionApi.Logger,
 ): Promise<void> {
   // we already have an instance
-  if (crcStatus.status.CrcStatus !== 'No Cluster' && !isNeedSetup()) {
+  if (crcStatus.status.CrcStatus !== 'No Cluster') {
     return;
   }
 
-  if (isNeedSetup()) {
-    const initResult = await initializeCrc(provider, extensionContext, telemetryLogger, logger);
-    if (!initResult) {
-      throw new Error(`${productName} not initialized.`);
-    }
-  }
-
-  const hasStarted = await startCrc(provider, logger, telemetryLogger);
+  const hasStarted = await startCrc(provider, getLoggerCallback(undefined, logger), telemetryLogger);
   if (!connectionDisposable && hasStarted) {
     addCommands(telemetryLogger);
     await presetChanged(provider, extensionContext, telemetryLogger);
@@ -270,29 +266,43 @@ async function initializeCrc(
   provider: extensionApi.Provider,
   extensionContext: extensionApi.ExtensionContext,
   telemetryLogger: extensionApi.TelemetryLogger,
-  logger: extensionApi.Logger,
-): Promise<boolean> {
-  const hasSetupFinished = await setUpCrc(logger, true);
-  if (hasSetupFinished) {
-    await needSetup();
-    await connectToCrc();
-    await presetChanged(provider, extensionContext, telemetryLogger);
-    addCommands(telemetryLogger);
-    await syncPreferences(provider, extensionContext, telemetryLogger);
+): Promise<void> {
+  const hasToBeSetup = await needSetup();
+  if (hasToBeSetup) {
+    crcStatus.setSetupRunning(true);
+    let hasSetupFinished = false;
+    try {
+      hasSetupFinished = await setUpCrc(true);
+    } catch (e) {
+      console.log(String(e));
+    } finally {
+      crcStatus.setSetupRunning(false);
+    }
+    if (!hasSetupFinished) {
+      throw new Error(`Failed at initializing ${productName}`);
+    }
   }
-  return hasSetupFinished;
+
+  addCommands(telemetryLogger);
+  await syncPreferences(provider, extensionContext, telemetryLogger);
+  await presetChanged(provider, extensionContext, telemetryLogger);
+  provider.updateStatus('configured');
 }
 
 function addCommands(telemetryLogger: extensionApi.TelemetryLogger): void {
-  registerOpenTerminalCommand();
-  registerOpenConsoleCommand();
-  registerLogInCommands();
-  registerDeleteCommand();
-
-  commandManager.addCommand(CRC_PUSH_IMAGE_TO_CLUSTER, image => {
-    telemetryLogger.logUsage('pushImage');
-    return pushImageToCrcCluster(image);
-  });
+  try {
+    registerOpenTerminalCommand();
+    registerOpenConsoleCommand();
+    registerLogInCommands();
+    registerDeleteCommand();
+
+    commandManager.addCommand(CRC_PUSH_IMAGE_TO_CLUSTER, image => {
+      telemetryLogger.logUsage('pushImage');
+      pushImageToCrcCluster(image).catch((e: unknown) => console.error(String(e)));
+    });
+  } catch (e) {
+    // do nothing
+  }
 }
 
 function deleteCommands(): void {
@@ -338,24 +348,28 @@ function registerOpenShiftLocalCluster(
   extensionContext: extensionApi.ExtensionContext,
   telemetryLogger: extensionApi.TelemetryLogger,
 ): void {
-  const status = () => crcStatus.getConnectionStatus();
   const apiURL = 'https://api.crc.testing:6443';
   const kubernetesProviderConnection: extensionApi.KubernetesProviderConnection = {
     name,
     endpoint: {
       apiURL,
     },
-    status,
+    status: () => crcStatus.getConnectionStatus(),
   };
 
   connectionDisposable = provider.registerKubernetesProviderConnection(kubernetesProviderConnection);
   kubernetesProviderConnection.lifecycle = {
     delete: () => {
       return handleDelete(provider, extensionContext, telemetryLogger);
     },
-    start: async ctx => {
+    start: async (ctx, logger) => {
       provider.updateStatus('starting');
-      await startCrc(provider, ctx.log, telemetryLogger);
+      try {
+        await startCrc(provider, getLoggerCallback(ctx, logger), telemetryLogger);
+      } catch (e) {
+        logger.error(e);
+        throw e;
+      }
     },
     stop: () => {
       provider.updateStatus('stopping');

src/install/crc-install.ts

@@ -136,7 +136,7 @@ export class CrcInstall {
         provider.updateVersion(newInstalledCrc.version);
         let setupResult = false;
         if (await needSetup()) {
-          setupResult = await setUpCrc(logger, true);
+          setupResult = await setUpCrc(true);
         }
         installFinishedFn(setupResult, newInstalledCrc);
       }

src/log-provider.ts

@@ -16,22 +16,21 @@
  * SPDX-License-Identifier: Apache-2.0
  ***********************************************************************/
 
-import type { Logger } from '@podman-desktop/api';
 import type { DaemonCommander } from './daemon-commander.js';
 import { commander } from './daemon-commander.js';
 
 export class LogProvider {
   private timeout: NodeJS.Timeout;
   constructor(private readonly commander: DaemonCommander) {}
 
-  async startSendingLogs(logger: Logger): Promise<void> {
+  async startSendingLogs(loggerCallback: (data: string) => void): Promise<void> {
     let lastLogLine = 0;
     this.timeout = setInterval(async () => {
       try {
         const logs = await this.commander.logs();
         const logsDiff: string[] = logs.Messages.slice(lastLogLine, logs.Messages.length - 1);
         lastLogLine = logs.Messages.length;
-        logger.log(logsDiff.join('\n'));
+        loggerCallback(logsDiff.join('\n'));
       } catch (e) {
         console.log('Logs tick: ' + e);
       }

src/preferences.ts

@@ -19,7 +19,7 @@
 import * as extensionApi from '@podman-desktop/api';
 import type { Configuration, Preset } from './types.js';
 import { commander } from './daemon-commander.js';
-import { isEmpty, productName } from './util.js';
+import { getLoggerCallback, isEmpty, productName } from './util.js';
 import { crcStatus } from './crc-status.js';
 import { stopCrc } from './crc-stop.js';
 import { deleteCrc } from './crc-delete.js';
@@ -337,7 +337,7 @@ async function handleRecreate(
   } else if (result === 'Delete and Restart') {
     await stopCrc(telemetryLogger);
     await deleteCrc();
-    await startCrc(provider, defaultLogger, telemetryLogger);
+    await startCrc(provider, getLoggerCallback(undefined, defaultLogger), telemetryLogger);
     return true;
   } else if (result === 'Delete') {
     await deleteCrc();

src/util.spec.ts

@@ -0,0 +1,43 @@
+/**********************************************************************
+ * Copyright (C) 2024 Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+import type * as extensionApi from '@podman-desktop/api';
+import { expect, test, vi } from 'vitest';
+import { getLoggerCallback } from './util';
+
+test('check logger passed to getLoggerCallback is actually called with data', async () => {
+  const logMock = vi.fn();
+  const logger = {
+    log: logMock,
+  } as unknown as extensionApi.Logger;
+  const callback = getLoggerCallback(undefined, logger);
+  callback('data');
+  expect(logMock).toBeCalledWith('data');
+});
+
+test('check logger passed to getLoggerCallback is actually called with data', async () => {
+  const logMock = vi.fn();
+  const context = {
+    log: {
+      log: logMock,
+    },
+  } as unknown as extensionApi.LifecycleContext;
+  const callback = getLoggerCallback(context);
+  callback('data2');
+  expect(logMock).toBeCalledWith('data2');
+});