Show cfnlint initialization failures as log message (#220)

Author: kddejong

src/services/cfnLint/CfnLintErrors.ts

@@ -0,0 +1,6 @@
+export class WorkerNotInitializedError extends Error {
+    constructor(message: string = 'Worker not initialized') {
+        super(message);
+        this.name = 'WorkerNotInitializedError';
+    }
+}

src/services/cfnLint/CfnLintService.ts

@@ -16,6 +16,7 @@ import { Delayer } from '../../utils/Delayer';
 import { extractErrorMessage } from '../../utils/Errors';
 import { byteSize } from '../../utils/String';
 import { DiagnosticCoordinator } from '../DiagnosticCoordinator';
+import { WorkerNotInitializedError } from './CfnLintErrors';
 import { PyodideWorkerManager } from './PyodideWorkerManager';
 
 export enum LintTrigger {
@@ -239,9 +240,16 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
      * Publish error diagnostics when linting fails
      *
      * @param uri The document URI
-     * @param errorMessage The error message
+     * @param error The error that occurred
      */
-    private publishErrorDiagnostics(uri: string, errorMessage: string): void {
+    private publishErrorDiagnostics(uri: string, error: unknown): void {
+        // Don't publish diagnostics for worker initialization errors, just log them
+        if (error instanceof WorkerNotInitializedError) {
+            this.log.warn('cfn-lint worker not initialized');
+            return;
+        }
+
+        const errorMessage = extractErrorMessage(error);
         this.publishDiagnostics(uri, [
             {
                 severity: 1, // Error severity
@@ -285,9 +293,8 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
             }
         } catch (error) {
             this.status = STATUS.Uninitialized;
-            const errorMessage = extractErrorMessage(error);
             this.logError(`linting ${fileType} by string`, error);
-            this.publishErrorDiagnostics(uri, errorMessage);
+            this.publishErrorDiagnostics(uri, error);
         } finally {
             this.telemetry.histogram(
                 'lint.standaloneFile.duration',
@@ -369,9 +376,8 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
             }
         } catch (error) {
             this.status = STATUS.Uninitialized;
-            const errorMessage = extractErrorMessage(error);
             this.logError(`linting ${fileType} by file`, error);
-            this.publishErrorDiagnostics(uri, errorMessage);
+            this.publishErrorDiagnostics(uri, error);
         } finally {
             this.telemetry.histogram(
                 'lint.workspaceFile.duration',

src/services/cfnLint/PyodideWorkerManager.ts

@@ -5,6 +5,7 @@ import { CloudFormationFileType } from '../../document/Document';
 import { CfnLintInitializationSettings } from '../../settings/Settings';
 import { LoggerFactory } from '../../telemetry/LoggerFactory';
 import { retryWithExponentialBackoff } from '../../utils/Retry';
+import { WorkerNotInitializedError } from './CfnLintErrors';
 
 interface WorkerTask {
     id: string;
@@ -189,7 +190,7 @@ export class PyodideWorkerManager {
         }
 
         if (!this.worker) {
-            throw new Error('Worker not initialized');
+            throw new WorkerNotInitializedError();
         }
 
         return await new Promise<T>((resolve, reject) => {
@@ -208,7 +209,7 @@ export class PyodideWorkerManager {
             if (this.worker) {
                 this.worker.postMessage({ id: taskId, action, payload });
             } else {
-                reject(new Error('Worker not initialized'));
+                reject(new WorkerNotInitializedError());
             }
         });
     }

tst/unit/services/cfnLint/CfnLintService.test.ts

@@ -6,6 +6,7 @@ import { describe, expect, beforeEach, afterEach, vi, Mock, test } from 'vitest'
 import { WorkspaceFolder, DiagnosticSeverity } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import { CloudFormationFileType, Document } from '../../../../src/document/Document';
+import { WorkerNotInitializedError } from '../../../../src/services/cfnLint/CfnLintErrors';
 import { CfnLintService, LintTrigger, sleep } from '../../../../src/services/cfnLint/CfnLintService';
 import { PyodideWorkerManager } from '../../../../src/services/cfnLint/PyodideWorkerManager';
 import { SettingsState } from '../../../../src/settings/Settings';
@@ -501,6 +502,16 @@ describe('CfnLintService', () => {
             expect(diagnosticsArg[2][0].message).toContain('Python execution failed');
         });
 
+        test('should log but not publish diagnostic for Worker not initialized error in lint', async () => {
+            mockComponents.workspace.getWorkspaceFolder.returns(undefined);
+            mockWorkerManager.lintTemplate.rejects(new WorkerNotInitializedError());
+
+            await service.lint(mockTemplate, mockUri);
+
+            // Should not publish any diagnostics for worker initialization errors
+            expect(mockComponents.diagnosticCoordinator.publishDiagnostics.called).toBe(false);
+        });
+
         test('should handle waitForInitialization failure', async () => {
             // Create a spy on waitForInitialization to make it fail
             const waitSpy = vi
@@ -858,6 +869,17 @@ describe('CfnLintService', () => {
                 expect(diagnosticsArg[2][0].message).toBe('CFN Lint Error: Python execution failed');
             });
 
+            test('should log but not publish diagnostic for Worker not initialized error', async () => {
+                const workerManager = (service as any).workerManager;
+                // Use sinon's rejects method to simulate worker not initialized error
+                workerManager.lintTemplate.rejects(new WorkerNotInitializedError());
+
+                await (service as any).lintStandaloneFile(mockTemplate, mockUri, CloudFormationFileType.Template);
+
+                // Should not publish any diagnostics for worker initialization errors
+                expect(mockComponents.diagnosticCoordinator.publishDiagnostics.called).toBe(false);
+            });
+
             test('should throw if service is not initialized', async () => {
                 // Set the main service to uninitialized state
                 (service as any).status = 0; // STATUS.Uninitialized