Create new feature flag and make schemas offline for e2e tests (#258)

Create hardware feature flag and make schemas offline for e2e test

Author: satyakigh

src/featureFlag/FeatureFlagProvider.ts

@@ -16,7 +16,10 @@ export class FeatureFlagProvider implements Closeable {
 
     private readonly timeout: NodeJS.Timeout;
 
-    constructor(private readonly localFile = join(__dirname, 'assets', 'featureFlag', `${AwsEnv.toLowerCase()}.json`)) {
+    constructor(
+        private readonly getLatestFeatureFlags: (env: string) => Promise<unknown>,
+        private readonly localFile = join(__dirname, 'assets', 'featureFlag', `${AwsEnv.toLowerCase()}.json`),
+    ) {
         this.config = JSON.parse(readFileSync(localFile, 'utf8'));
 
         this.supplier = new FeatureFlagSupplier(() => {
@@ -49,18 +52,16 @@ export class FeatureFlagProvider implements Closeable {
     }
 
     private async refresh() {
-        const newConfig = await this.getFromOnline(AwsEnv);
+        const newConfig = await this.getFeatureFlags(AwsEnv);
         this.config = newConfig;
         writeFileSync(this.localFile, JSON.stringify(newConfig, undefined, 2));
 
         this.log();
     }
 
-    @Measure({ name: 'getFromOnline' })
-    private async getFromOnline(env: string): Promise<unknown> {
-        return await downloadJson(
-            `https://raw.githubusercontent.com/aws-cloudformation/cloudformation-languageserver/refs/head/main/assets/featureFlag/${env.toLowerCase()}.json`,
-        );
+    @Measure({ name: 'getFeatureFlags' })
+    private async getFeatureFlags(env: string): Promise<unknown> {
+        return await this.getLatestFeatureFlags(env);
     }
 
     private log() {
@@ -79,3 +80,9 @@ export class FeatureFlagProvider implements Closeable {
         clearInterval(this.timeout);
     }
 }
+
+export function getFromGitHub(env: string): Promise<unknown> {
+    return downloadJson(
+        `https://raw.githubusercontent.com/aws-cloudformation/cloudformation-languageserver/refs/heads/main/assets/featureFlag/${env.toLowerCase()}.json`,
+    );
+}

src/featureFlag/HardwareFeatureFlag.ts

@@ -0,0 +1,55 @@
+import { arch, platform, release, version } from 'os';
+import { FeatureFlag } from './FeatureFlagI';
+
+type HardwareMatch = {
+    arch?: string | string[];
+    platform?: string | string[];
+    release?: string | string[];
+    version?: string | string[];
+    nodeVersion?: string | string[];
+    processArch?: string | string[];
+    processPlatform?: string | string[];
+};
+
+export class HardwareFeatureFlag implements FeatureFlag {
+    private readonly enabled: boolean;
+
+    constructor(
+        private readonly featureName: string,
+        private readonly match: HardwareMatch,
+        private readonly partial: boolean = false,
+    ) {
+        const checks = [
+            this.matchProperty(arch(), this.match.arch),
+            this.matchProperty(platform(), this.match.platform),
+            this.matchProperty(release(), this.match.release),
+            this.matchProperty(version(), this.match.version),
+            this.matchProperty(process.version, this.match.nodeVersion),
+            this.matchProperty(process.arch, this.match.processArch),
+            this.matchProperty(process.platform, this.match.processPlatform),
+        ];
+
+        this.enabled = checks.every(Boolean);
+    }
+
+    private matchProperty(actual: string, expected?: string | string[]): boolean {
+        if (expected === undefined) {
+            return true;
+        }
+
+        const patterns = Array.isArray(expected) ? expected : [expected];
+
+        return patterns.some((pattern) => {
+            return this.partial ? actual.includes(pattern) : actual === pattern;
+        });
+    }
+
+    isEnabled(): boolean {
+        return this.enabled;
+    }
+
+    describe(): string {
+        const matchStr = JSON.stringify(this.match);
+        return `HardwareFeatureFlag(feature=${this.featureName}, match=${matchStr}, partial=${this.partial}, enabled=${this.enabled})`;
+    }
+}

src/schema/GetSamSchemaTask.ts

@@ -4,20 +4,19 @@ import { Measure } from '../telemetry/TelemetryDecorator';
 import { downloadJson } from '../utils/RemoteDownload';
 import { GetSchemaTask } from './GetSchemaTask';
 import { SamSchemas, SamSchemasType, SamStoreKey } from './SamSchemas';
-import { SamSchemaTransformer, SamSchema } from './SamSchemaTransformer';
+import { CloudFormationResourceSchema, SamSchema, SamSchemaTransformer } from './SamSchemaTransformer';
 
 const logger = LoggerFactory.getLogger('GetSamSchemaTask');
 
 export class GetSamSchemaTask extends GetSchemaTask {
-    private static readonly SAM_SCHEMA_URL =
-        'https://raw.githubusercontent.com/aws/serverless-application-model/refs/heads/develop/samtranslator/schema/schema.json';
+    constructor(private readonly getSamSchemas: () => Promise<Map<string, CloudFormationResourceSchema>>) {
+        super();
+    }
 
     @Measure({ name: 'getSchemas' })
     override async runImpl(dataStore: DataStore): Promise<void> {
         try {
-            const samSchema = await downloadJson<Record<string, unknown>>(GetSamSchemaTask.SAM_SCHEMA_URL);
-
-            const resourceSchemas = SamSchemaTransformer.transformSamSchema(samSchema as unknown as SamSchema);
+            const resourceSchemas = await this.getSamSchemas();
 
             // Convert to SamSchemasType format
             const schemas = [...resourceSchemas.entries()].map(([resourceType, schema]) => ({
@@ -42,3 +41,11 @@ export class GetSamSchemaTask extends GetSchemaTask {
         }
     }
 }
+
+export async function getSamSchemas(): Promise<Map<string, CloudFormationResourceSchema>> {
+    const SAM_SCHEMA_URL =
+        'https://raw.githubusercontent.com/aws/serverless-application-model/refs/heads/develop/samtranslator/schema/schema.json';
+
+    const samSchema = await downloadJson<SamSchema>(SAM_SCHEMA_URL);
+    return SamSchemaTransformer.transformSamSchema(samSchema);
+}

src/schema/GetSchemaTask.ts

@@ -100,11 +100,14 @@ export class GetPrivateSchemasTask extends GetSchemaTask {
     }
 }
 
-export function getRemotePublicSchemas(region: AwsRegion) {
+export function getRemotePublicSchemas(region: AwsRegion): Promise<SchemaFileType[]> {
     return unZipFile(downloadFile(cfnResourceSchemaLink(region)));
 }
 
-export function getRemotePrivateSchemas(awsCredentials: AwsCredentials, cfnService: CfnService) {
+export function getRemotePrivateSchemas(
+    awsCredentials: AwsCredentials,
+    cfnService: CfnService,
+): Promise<DescribeTypeOutput[]> {
     if (awsCredentials.credentialsAvailable()) {
         return cfnService.getAllPrivateResourceSchemas();
     }

src/schema/GetSchemaTaskManager.ts

@@ -7,6 +7,7 @@ import { AwsRegion } from '../utils/Region';
 import { GetSamSchemaTask } from './GetSamSchemaTask';
 import { GetPrivateSchemasTask, GetPublicSchemaTask } from './GetSchemaTask';
 import { SchemaFileType } from './RegionalSchemas';
+import { CloudFormationResourceSchema } from './SamSchemaTransformer';
 import { SchemaStore } from './SchemaStore';
 
 const TenSeconds = 10 * 1000;
@@ -27,12 +28,13 @@ export class GetSchemaTaskManager implements SettingsConfigurable, Closeable {
     constructor(
         private readonly schemas: SchemaStore,
         private readonly getPublicSchemas: (region: AwsRegion) => Promise<SchemaFileType[]>,
-        private readonly getPrivateResources: () => Promise<DescribeTypeOutput[]>,
+        getPrivateResources: () => Promise<DescribeTypeOutput[]>,
+        getSamSchemas: () => Promise<Map<string, CloudFormationResourceSchema>>,
         private profile: string = DefaultSettings.profile.profile,
         private readonly onSchemaUpdate: (region?: string, profile?: string) => void,
     ) {
-        this.privateTask = new GetPrivateSchemasTask(this.getPrivateResources, () => this.profile);
-        this.samTask = new GetSamSchemaTask();
+        this.privateTask = new GetPrivateSchemasTask(getPrivateResources, () => this.profile);
+        this.samTask = new GetSamSchemaTask(getSamSchemas);
 
         this.timeout = setTimeout(() => {
             // Wait before trying to call CFN APIs so that credentials have time to update

src/schema/SamSchemaTransformer.ts

@@ -11,7 +11,7 @@ export interface SamSchema {
     };
 }
 
-interface CloudFormationResourceSchema {
+export type CloudFormationResourceSchema = {
     typeName: string;
     description: string;
     documentationUrl?: string;
@@ -24,7 +24,7 @@ interface CloudFormationResourceSchema {
     createOnlyProperties?: string[];
     primaryIdentifier?: string[];
     attributes?: Record<string, unknown>;
-}
+};
 
 export const SamSchemaTransformer = {
     transformSamSchema(samSchema: SamSchema): Map<string, CloudFormationResourceSchema> {

src/schema/SamSchemas.ts

@@ -1,8 +1,9 @@
+import { SchemaFileType } from './RegionalSchemas';
 import { ResourceSchema } from './ResourceSchema';
 
 export type SamSchemasType = {
     version: string;
-    schemas: { name: string; content: string; createdMs: number }[];
+    schemas: SchemaFileType[];
     firstCreatedMs: number;
     lastModifiedMs: number;
 };

src/schema/SchemaRetriever.ts

@@ -12,6 +12,7 @@ import { GetSchemaTaskManager } from './GetSchemaTaskManager';
 import { PrivateSchemasType } from './PrivateSchemas';
 import { RegionalSchemasType, SchemaFileType } from './RegionalSchemas';
 import { SamSchemasType, SamStoreKey } from './SamSchemas';
+import { CloudFormationResourceSchema } from './SamSchemaTransformer';
 import { SchemaStore } from './SchemaStore';
 
 const StaleDaysThreshold = 7;
@@ -29,12 +30,14 @@ export class SchemaRetriever implements SettingsConfigurable, Closeable {
     constructor(
         private readonly schemaStore: SchemaStore,
         private readonly getPublicSchemas: (region: AwsRegion) => Promise<SchemaFileType[]>,
-        private readonly getPrivateResources: () => Promise<DescribeTypeOutput[]>,
+        getPrivateResources: () => Promise<DescribeTypeOutput[]>,
+        getSamSchemas: () => Promise<Map<string, CloudFormationResourceSchema>>,
     ) {
         this.schemaTaskManager = new GetSchemaTaskManager(
             this.schemaStore,
             this.getPublicSchemas,
-            this.getPrivateResources,
+            getPrivateResources,
+            getSamSchemas,
             this.settings.profile,
             (region, profile) => this.rebuildAffectedCombinedSchemas(region, profile),
         );

src/server/CfnExternal.ts

@@ -1,5 +1,6 @@
-import { FeatureFlagProvider } from '../featureFlag/FeatureFlagProvider';
+import { FeatureFlagProvider, getFromGitHub } from '../featureFlag/FeatureFlagProvider';
 import { LspComponents } from '../protocol/LspComponents';
+import { getSamSchemas } from '../schema/GetSamSchemaTask';
 import { getRemotePrivateSchemas, getRemotePublicSchemas } from '../schema/GetSchemaTask';
 import { SchemaRetriever } from '../schema/SchemaRetriever';
 import { SchemaStore } from '../schema/SchemaStore';
@@ -46,8 +47,11 @@ export class CfnExternal implements Configurables, Closeable {
         this.schemaStore = overrides.schemaStore ?? new SchemaStore(core.dataStoreFactory);
         this.schemaRetriever =
             overrides.schemaRetriever ??
-            new SchemaRetriever(this.schemaStore, getRemotePublicSchemas, () =>
-                getRemotePrivateSchemas(core.awsCredentials, this.cfnService),
+            new SchemaRetriever(
+                this.schemaStore,
+                getRemotePublicSchemas,
+                () => getRemotePrivateSchemas(core.awsCredentials, this.cfnService),
+                getSamSchemas,
             );
 
         this.cfnLintService =
@@ -58,7 +62,7 @@ export class CfnExternal implements Configurables, Closeable {
             new GuardService(core.documentManager, core.diagnosticCoordinator, core.syntaxTreeManager);
 
         this.onlineStatus = overrides.onlineStatus ?? new OnlineStatus(core.clientMessage);
-        this.featureFlags = overrides.featureFlags ?? new FeatureFlagProvider();
+        this.featureFlags = overrides.featureFlags ?? new FeatureFlagProvider(getFromGitHub);
     }
 
     configurables(): Configurable[] {

tools/telemetry-generator.ts

@@ -44,11 +44,8 @@ import {
     createMockLspCommunication,
     createMockAuthHandlers,
 } from '../tst/utils/MockServerComponents';
-import { getTestPrivateSchemas } from '../tst/utils/SchemaUtils';
 import { MemoryDataStoreFactoryProvider } from '../src/datastore/DataStore';
 import { SchemaStore } from '../src/schema/SchemaStore';
-import { GetSchemaTaskManager } from '../src/schema/GetSchemaTaskManager';
-import { getRemotePublicSchemas } from '../src/schema/GetSchemaTask';
 import { completionHandler } from '../src/handlers/CompletionHandler';
 import { hoverHandler } from '../src/handlers/HoverHandler';
 import { definitionHandler } from '../src/handlers/DefinitionHandler';
@@ -67,7 +64,6 @@ import { LspResourceHandlers } from '../src/protocol/LspResourceHandlers';
 import { LspRelatedResourcesHandlers } from '../src/protocol/LspRelatedResourcesHandlers';
 import { LspS3Handlers } from '../src/protocol/LspS3Handlers';
 import { ExtendedInitializeParams } from '../src/server/InitParams';
-import { FeatureFlagProvider } from '../src/featureFlag/FeatureFlagProvider';
 import { RelationshipSchemaService } from '../src/services/RelationshipSchemaService';
 import { LspCfnEnvironmentHandlers } from '../src/protocol/LspCfnEnvironmentHandlers';
 
@@ -200,7 +196,6 @@ function main() {
     const schemaStore = new SchemaStore(dataStoreFactory);
     const external = new CfnExternal(lsp, core, {
         schemaStore,
-        featureFlags: new FeatureFlagProvider(join(__dirname, '..', 'assets', 'featureFlag', 'alpha.json')),
     });
 
     const providers = new CfnLspProviders(core, external, {