Use system status handler

chrisqm-dev · chrisqm-dev · commit bdd25b869cd2 · 2026-04-27T14:34:42.000-04:00
diff --git a/.github/workflows/post-beta-long-running.yml b/.github/workflows/post-beta-long-running.yml
@@ -0,0 +1,88 @@
+name: Post-Beta Long Running Tests
+run-name: Long Running Tests for ${{ github.event.release.tag_name }}
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  check-beta-release:
+    runs-on: ubuntu-latest
+    outputs:
+      is-beta: ${{ steps.check.outputs.is-beta }}
+    steps:
+      - name: Check if beta release
+        id: check
+        run: |
+          TAG="${{ github.event.release.tag_name }}"
+          if [[ "$TAG" =~ -beta$ ]]; then
+            echo "is-beta=true" >> $GITHUB_OUTPUT
+          else
+            echo "is-beta=false" >> $GITHUB_OUTPUT
+          fi
+
+  long-running-tests:
+    needs: check-beta-release
+    if: needs.check-beta-release.outputs.is-beta == 'true'
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        node-version: [18, 20, 22]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 360
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.release.tag_name }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Download release standalone
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          TAG="${{ github.event.release.tag_name }}"
+          case "${{ matrix.os }}" in
+            ubuntu-latest) PLATFORM="linux" ;;
+            windows-latest) PLATFORM="win32" ;;
+            macos-latest) PLATFORM="darwin" ;;
+          esac
+          PATTERN="*${PLATFORM}*x64*node${{ matrix.node-version }}*.zip"
+          gh release download "$TAG" --pattern "$PATTERN"
+
+      - name: Extract standalone bundle
+        run: |
+          if [[ "${{ matrix.os }}" == "windows-latest" ]]; then
+            unzip *.zip
+          else
+            unzip *.zip
+            chmod +x cfn-lsp-server-standalone.js
+          fi
+
+      - name: Test standalone bundle
+        run: node cfn-lsp-server-standalone.js --version
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run long-running stability tests
+        env:
+          STABILITY_TEST_DURATION: 4h
+          STANDALONE_PATH: ./cfn-lsp-server-standalone.js
+        run: npm run test:stability
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: long-running-test-results-${{ matrix.os }}
+          path: |
+            test-results.json
+            test-logs.txt
+          if-no-files-found: ignore
diff --git a/tools/lspClient/LspClient.ts b/tools/lspClient/LspClient.ts
@@ -11,9 +11,10 @@ import {
 } from 'vscode-languageserver-protocol/node';
 import { randomBytes } from 'crypto';
 import { CompactEncrypt } from 'jose';
-import { LspClientConfig, LspConnection, InitializationFlags } from './LspConnection';
+import { LspClientConfig, LspConnection } from './LspConnection';
 import { ExtendedInitializeParams } from '../../src/server/InitParams';
 import { IamCredentials } from '../../src/auth/AwsLspAuthTypes';
+import { GetSystemStatusResponse } from '../../src/protocol/LspSystemHandlers';
 import { WaitFor } from '../../tst/utils/Utils';
 
 /**
@@ -23,16 +24,11 @@ import { WaitFor } from '../../tst/utils/Utils';
 export class LspClient implements LspConnection {
     protected serverProcess?: ChildProcess;
     protected connection?: MessageConnection;
-    protected initialization: InitializationFlags = {
-        cfnLint: false,
-        cfnGuard: false,
-    };
 
     public readonly createdAt: number;
     private readonly encryptionKey: Buffer;
     protected isShutdown = false;
     protected workspaceConfig: Record<string, unknown>[] = [{}];
-    protected availableRegions = new Set<string>();
 
     constructor(protected config: LspClientConfig) {
         this.createdAt = performance.now();
@@ -105,21 +101,7 @@ export class LspClient implements LspConnection {
     private readonly onServerOutput = (data: Buffer) => {
         const output = data.toString().trim();
 
-        // external service initialization detection
-        if (output.includes('cfn-lint version')) {
-            this.initialization.cfnLint = true;
-        }
-        if (output.includes('Loading rules from')) {
-            this.initialization.cfnGuard = true;
-        }
-
-        // Region-specific schema loading
-        const regionSchemaMatch = output.match(/public schemas downloaded for ([a-z0-9-]+)/);
-        if (regionSchemaMatch) {
-            this.availableRegions.add(regionSchemaMatch[1]);
-        }
-
-        // Log filtering
+        // Log filtering - keep for debugging
         const suppressLevels = this.config.suppressLogLevels ?? ['INFO', 'DEBUG'];
         const shouldSuppress = suppressLevels.some((level) => output.includes(`${level}:`));
 
@@ -268,11 +250,15 @@ export class LspClient implements LspConnection {
     }
 
     async waitForExternalServiceInitialization(): Promise<void> {
-        console.log('Waiting for lint and guard initialization');
+        console.log('Waiting for lint and guard initialization via SystemHandler...');
 
         await WaitFor.waitFor(
-            () => {
-                if (!this.initialization.cfnLint || !this.initialization.cfnGuard) {
+            async () => {
+                const status = await this.getSystemStatus();
+                console.log(
+                    `Service status: cfnLint=${status.cfnLintReady.ready}, cfnGuard=${status.cfnGuardReady.ready}`,
+                );
+                if (!status.cfnLintReady.ready || !status.cfnGuardReady.ready) {
                     throw new Error('Lint and Guard services not initialized');
                 }
                 console.log('Lint and Guard services are initialized');
@@ -282,10 +268,6 @@ export class LspClient implements LspConnection {
         );
     }
 
-    getAvailableRegions(): ReadonlySet<string> {
-        return this.availableRegions;
-    }
-
     async updateCredentials(credentials: IamCredentials): Promise<void> {
         const payload = new TextEncoder().encode(JSON.stringify({ data: credentials }));
         const jwt = await new CompactEncrypt(payload)
@@ -298,6 +280,10 @@ export class LspClient implements LspConnection {
         });
     }
 
+    async getSystemStatus(): Promise<GetSystemStatusResponse> {
+        return await this.sendRequest('aws/system/status', {});
+    }
+
     async shutdown(): Promise<void> {
         if (this.isShutdown) return;
         this.isShutdown = true;
diff --git a/tools/lspClient/LspConnection.ts b/tools/lspClient/LspConnection.ts
@@ -21,8 +21,3 @@ export type LspClientConfig = {
     env?: NodeJS.ProcessEnv;
     suppressLogLevels?: string[];
 };
-
-export type InitializationFlags = {
-    cfnLint: boolean;
-    cfnGuard: boolean;
-};
diff --git a/tools/stability/TestOrchestrator.ts b/tools/stability/TestOrchestrator.ts
@@ -18,7 +18,9 @@ export class TestOrchestrator {
 
     private readonly templates = TEMPLATE_CONFIGS;
 
-    private readonly testRegions = Object.values(AwsRegion);
+    private readonly testRegions = Object.values(AwsRegion).filter(
+        (region) => region !== AwsRegion.ME_SOUTH_1 && region !== AwsRegion.ME_CENTRAL_1,
+    );
 
     async initialize(): Promise<void> {
         console.log('Starting CloudFormation Language Server Long-Running Tests');
@@ -58,7 +60,24 @@ export class TestOrchestrator {
 
         console.log(`Loaded ${this.templates.length} templates`);
 
-        await this.client.waitForExternalServiceInitialization();
+        // Wait for all system components to be ready
+        console.log('Waiting for system components to be ready...');
+        await WaitFor.waitFor(
+            async () => {
+                const status = await this.client.getSystemStatus();
+                if (
+                    !status.settingsReady.ready ||
+                    !status.schemasReady.ready ||
+                    !status.cfnLintReady.ready ||
+                    !status.cfnGuardReady.ready
+                ) {
+                    throw new Error('System not ready');
+                }
+            },
+            30_000,
+            1000,
+        );
+        console.log('All system components ready');
 
         await this.loadAllRegionSchemas();
 
@@ -140,42 +159,32 @@ export class TestOrchestrator {
     }
 
     private async loadAllRegionSchemas(): Promise<void> {
-        // Check what regions are already available from LspClient
-        const alreadyAvailable = [...this.client.getAvailableRegions()];
-        const unavailableRegions = this.testRegions.filter((region) => !this.client.getAvailableRegions().has(region));
-
-        console.log(`Schema status: ${alreadyAvailable.length} available, ${unavailableRegions.length} unavailable`);
-        console.log(`Available region schemas: ${alreadyAvailable.join(', ')}`);
-
-        if (unavailableRegions.length > 0) {
-            console.log(`Loading the following region schemas: ${unavailableRegions.join(', ')}`);
-        }
+        console.log('Loading schemas for all regions...');
 
-        for (const region of unavailableRegions) {
+        for (const region of this.testRegions) {
             await this.switchToRegion(region);
-            await this.waitForRegionSchemas(region);
+
+            // Wait for schemas to be ready after region switch
+            try {
+                await WaitFor.waitFor(
+                    async () => {
+                        const status = await this.client.getSystemStatus();
+                        if (!status.schemasReady.ready) {
+                            throw new Error(`Schemas not ready for region ${region}`);
+                        }
+                    },
+                    30_000,
+                    200,
+                );
+            } catch (error) {
+                console.warn(`Failed to load schemas for region ${region}, continuing anyway:`, error);
+            }
         }
 
         console.log('Regional schema loading complete');
     }
 
-    private async waitForRegionSchemas(region: string): Promise<void> {
-        try {
-            await WaitFor.waitFor(
-                () => {
-                    if (!this.client.getAvailableRegions().has(region)) {
-                        throw new Error(`Region ${region} schemas not loaded yet`);
-                    }
-                },
-                30_000, // 30 second timeout
-                500, // Check every 500ms
-            );
-        } catch {
-            console.warn(`Timeout waiting for ${region} schemas, proceeding anyway`);
-        }
-    }
-
-    private async switchToRegion(region: string): Promise<void> {
+    private async switchToRegion(region: AwsRegion): Promise<void> {
         // Store the new configuration
         await this.client.changeConfiguration({
             settings: {
@@ -186,6 +195,23 @@ export class TestOrchestrator {
                 },
             },
         });
+
+        // Wait for settings to be applied with correct region
+        await WaitFor.waitFor(
+            async () => {
+                const status = await this.client.getSystemStatus();
+                if (!status.settingsReady.ready) {
+                    throw new Error('Settings not ready after region change');
+                }
+                if (status.currentSettings.profile.region !== region) {
+                    throw new Error(
+                        `Region not applied: expected ${region}, got ${status.currentSettings.profile.region}`,
+                    );
+                }
+            },
+            5000,
+            100,
+        ); // Reduced timeout and faster polling
     }
 
     private async validateLsp(uri: string): Promise<void> {
