filewatcher: template watcher lazy-loads if enableCodeLenses is off (#3938)

## Problem
The template file watcher always ran regardless of SAM hint setting

## Solution
The template file watcher now loads on demand. This appears to work even when toggling from off to on (codelenses appear on the template file)
* ~~This may hit the startup function multiple times? Will do some more testing~~ should be resolved with 0b1df9d
* Confirmed SAM debug works, when coming from startup with codelenses disabled
* Confirmed the registry builds when codelenses are enabled

Author: bryceitoc9

src/lambda/commands/createNewSamApp.ts

@@ -271,7 +271,7 @@ export async function createNewSamApplication(
         // Race condition where SAM app is created but template doesn't register in time.
         // Poll for 5 seconds, otherwise direct user to codelens.
         const isTemplateRegistered = await waitUntil(
-            async () => globals.templateRegistry.getRegisteredItem(templateUri),
+            async () => (await globals.templateRegistry).getRegisteredItem(templateUri),
             {
                 timeout: 5000,
                 interval: 500,

src/lambda/commands/downloadLambda.ts

@@ -206,11 +206,8 @@ async function addLaunchConfigEntry(
     )
 
     const launchConfig = new LaunchConfiguration(vscode.Uri.file(lambdaLocation))
-    if (
-        !getReferencedHandlerPaths(launchConfig).has(
-            pathutils.normalize(path.join(path.dirname(lambdaLocation), handler))
-        )
-    ) {
+    const refPaths = await getReferencedHandlerPaths(launchConfig)
+    if (!refPaths.has(pathutils.normalize(path.join(path.dirname(lambdaLocation), handler)))) {
         await launchConfig.addDebugConfiguration(samDebugConfig)
     }
 }

src/lambda/local/debugConfiguration.ts

@@ -100,10 +100,10 @@ export interface PipeTransport {
  * - For "code" configs this is the `projectRoot` field.
  * - For "template" configs this is the `CodeUri` field in the template.
  */
-export function getCodeRoot(
+export async function getCodeRoot(
     folder: vscode.WorkspaceFolder | undefined,
     config: AwsSamDebuggerConfiguration
-): string | undefined {
+): Promise<string | undefined> {
     switch (config.invokeTarget.target) {
         case 'code': {
             const codeInvoke = config.invokeTarget as CodeTargetProperties
@@ -112,11 +112,11 @@ export function getCodeRoot(
         case 'api':
         case 'template': {
             const templateInvoke = config.invokeTarget as TemplateTargetProperties
-            const template = getTemplate(folder, config)
+            const template = await getTemplate(folder, config)
             if (!template) {
                 return undefined
             }
-            const templateResource = getTemplateResource(folder, config)
+            const templateResource = await getTemplateResource(folder, config)
             if (!templateResource?.Properties) {
                 return undefined
             }
@@ -142,22 +142,22 @@ export function getCodeRoot(
 /**
  * Gets the lambda handler name specified in the given config.
  */
-export function getHandlerName(
+export async function getHandlerName(
     folder: vscode.WorkspaceFolder | undefined,
     config: AwsSamDebuggerConfiguration
-): string {
+): Promise<string> {
     switch (config.invokeTarget.target) {
         case 'code': {
             const codeInvoke = config.invokeTarget as CodeTargetProperties
             return codeInvoke.lambdaHandler
         }
         case 'api':
         case 'template': {
-            const template = getTemplate(folder, config)
+            const template = await getTemplate(folder, config)
             if (!template) {
                 return ''
             }
-            const templateResource = getTemplateResource(folder, config)
+            const templateResource = await getTemplateResource(folder, config)
             if (CloudFormation.isImageLambdaResource(templateResource?.Properties)) {
                 return config.invokeTarget.logicalId
             }
@@ -184,32 +184,32 @@ export function getHandlerName(
 }
 
 /** Gets a template object from the given config. */
-export function getTemplate(
+export async function getTemplate(
     folder: vscode.WorkspaceFolder | undefined,
     config: AwsSamDebuggerConfiguration
-): CloudFormation.Template | undefined {
+): Promise<CloudFormation.Template | undefined> {
     if (!['api', 'template'].includes(config.invokeTarget.target)) {
         return undefined
     }
     const templateInvoke = config.invokeTarget as TemplateTargetProperties
     const fullPath = tryGetAbsolutePath(folder, templateInvoke.templatePath)
-    const cfnTemplate = globals.templateRegistry.getRegisteredItem(fullPath)?.item
+    const cfnTemplate = (await globals.templateRegistry).getRegisteredItem(fullPath)?.item
     return cfnTemplate
 }
 
 /**
  * Gets the template resources object specified by the `logicalId`
  * field (if the config has `target=template` or `target=api`).
  */
-export function getTemplateResource(
+export async function getTemplateResource(
     folder: vscode.WorkspaceFolder | undefined,
     config: AwsSamDebuggerConfiguration
-): CloudFormation.Resource | undefined {
+): Promise<CloudFormation.Resource | undefined> {
     if (!['api', 'template'].includes(config.invokeTarget.target)) {
         return undefined
     }
     const templateInvoke = config.invokeTarget as TemplateTargetProperties
-    const cfnTemplate = getTemplate(folder, config)
+    const cfnTemplate = await getTemplate(folder, config)
     if (!cfnTemplate) {
         throw Error(`template not found (not registered?): ${templateInvoke.templatePath}`)
     }
@@ -231,8 +231,8 @@ export function getTemplateResource(
  *
  * Intended for use only by the language-specific `makeConfig` functions.
  */
-export function isImageLambdaConfig(config: SamLaunchRequestArgs): boolean {
-    const templateResource = getTemplateResource(config.workspaceFolder, config)
+export async function isImageLambdaConfig(config: SamLaunchRequestArgs): Promise<boolean> {
+    const templateResource = await getTemplateResource(config.workspaceFolder, config)
 
     return CloudFormation.isImageLambdaResource(templateResource?.Properties)
 }

src/lambda/vue/configEditor/samInvokeBackend.ts

@@ -94,7 +94,7 @@ export class SamInvokeWebview extends VueWebview {
         }
         const uri = workspaceFolder.uri
         const launchConfig = new LaunchConfiguration(uri)
-        const pickerItems = getLaunchConfigQuickPickItems(launchConfig, uri)
+        const pickerItems = await getLaunchConfigQuickPickItems(launchConfig, uri)
         if (pickerItems.length === 0) {
             pickerItems.push({
                 index: -1,
@@ -161,7 +161,7 @@ export class SamInvokeWebview extends VueWebview {
     public async getTemplate() {
         const items: (vscode.QuickPickItem & { templatePath: string })[] = []
         const noTemplate = 'NOTEMPLATEFOUND'
-        for (const template of globals.templateRegistry.registeredItems) {
+        for (const template of (await globals.templateRegistry).registeredItems) {
             const resources = template.item.Resources
             if (resources) {
                 for (const resource of Object.keys(resources)) {
@@ -227,6 +227,7 @@ export class SamInvokeWebview extends VueWebview {
             return
         }
         const launchConfig = new LaunchConfiguration(uri)
+        const launchConfigItems = await getLaunchConfigQuickPickItems(launchConfig, uri)
         const pickerItems = [
             {
                 label: addCodiconToString(
@@ -236,7 +237,7 @@ export class SamInvokeWebview extends VueWebview {
                 index: -1,
                 alwaysShow: true,
             },
-            ...getLaunchConfigQuickPickItems(launchConfig, uri),
+            ...launchConfigItems,
         ]
 
         const qp = picker.createQuickPick({
@@ -343,17 +344,24 @@ function getUriFromLaunchConfig(config: AwsSamDebuggerConfiguration): vscode.Uri
     return undefined
 }
 
-function getLaunchConfigQuickPickItems(launchConfig: LaunchConfiguration, uri: vscode.Uri): LaunchConfigPickItem[] {
+async function getLaunchConfigQuickPickItems(
+    launchConfig: LaunchConfiguration,
+    uri: vscode.Uri
+): Promise<LaunchConfigPickItem[]> {
     const existingConfigs = launchConfig.getDebugConfigurations()
     const samValidator = new DefaultAwsSamDebugConfigurationValidator(vscode.workspace.getWorkspaceFolder(uri))
+    const registry = await globals.templateRegistry
     return existingConfigs
         .map((val, index) => {
             return {
                 config: val,
                 index,
             }
         })
-        .filter(o => samValidator.validate(o.config as any as AwsSamDebuggerConfiguration, true)?.isValid)
+        .filter(o => {
+            const res = samValidator.validate(o.config as any as AwsSamDebuggerConfiguration, registry, true)
+            return res?.isValid
+        })
         .map(val => {
             return {
                 index: val.index,

src/lambda/wizards/samDeployWizard.ts

@@ -211,7 +211,7 @@ export class DefaultSamDeployWizardContext implements SamDeployWizardContext {
     }
 
     public async determineIfTemplateHasImages(templatePath: vscode.Uri): Promise<boolean> {
-        const template = globals.templateRegistry.getRegisteredItem(templatePath.fsPath)
+        const template = (await globals.templateRegistry).getRegisteredItem(templatePath.fsPath)
         const resources = template?.item?.Resources
         if (resources === undefined) {
             return false
@@ -933,7 +933,7 @@ function validateStackName(value: string): string | undefined {
 }
 
 async function getTemplateChoices(...workspaceFolders: vscode.Uri[]): Promise<SamTemplateQuickPickItem[]> {
-    const templateUris = globals.templateRegistry.registeredItems.map(o => vscode.Uri.file(o.path))
+    const templateUris = (await globals.templateRegistry).registeredItems.map(o => vscode.Uri.file(o.path))
     const uriToLabel: Map<vscode.Uri, string> = new Map<vscode.Uri, string>()
     const labelCounts: Map<string, number> = new Map()
 

src/shared/awsFiletypes.ts

@@ -67,7 +67,7 @@ export function activate(): void {
         vscode.workspace.onDidOpenTextDocument(async (doc: vscode.TextDocument) => {
             const isAwsFileExt = isAwsFiletype(doc)
             const isSchemaHandled = globals.schemaService.isMapped(doc.uri)
-            const isCfnTemplate = !!globals.templateRegistry.registeredItems.find(
+            const isCfnTemplate = !!(await globals.templateRegistry).registeredItems.find(
                 t => pathutil.normalize(t.path) === pathutil.normalize(doc.fileName)
             )
             if (!isAwsFileExt && !isSchemaHandled && !isCfnTemplate) {

src/shared/cloudformation/activation.ts

@@ -5,14 +5,15 @@
 
 import * as vscode from 'vscode'
 import { getLogger } from '../logger'
-import { localize } from '../utilities/vsCodeUtils'
+import { isToolkitActive, localize } from '../utilities/vsCodeUtils'
 
 import { AsyncCloudFormationTemplateRegistry, CloudFormationTemplateRegistry } from '../fs/templateRegistry'
 import { getIdeProperties } from '../extensionUtilities'
 import { NoopWatcher } from '../fs/watchedFiles'
 import { createStarterTemplateFile } from './cloudformation'
 import { Commands } from '../vscode/commands2'
 import globals from '../extensionGlobals'
+import { SamCliSettings } from '../sam/cli/samCliSettings'
 
 export const templateFileGlobPattern = '**/*.{yaml,yml}'
 
@@ -48,7 +49,7 @@ export async function activate(extensionContext: vscode.ExtensionContext): Promi
         getLogger().error('Failed to activate template registry: %s', e)
         // This prevents us from breaking for any reason later if it fails to load. Since
         // Noop watcher is always empty, we will get back empty arrays with no issues.
-        globals.templateRegistry = new NoopWatcher() as unknown as CloudFormationTemplateRegistry
+        globals.templateRegistry = (async () => new NoopWatcher() as unknown as CloudFormationTemplateRegistry)()
     }
     // If setting it up worked, add it to subscriptions so it is cleaned up at exit
     extensionContext.subscriptions.push(
@@ -71,6 +72,8 @@ function setTemplateRegistryInGlobals(registry: CloudFormationTemplateRegistry)
         await registry.addExcludedPattern(templateFileExcludePattern)
         await registry.addWatchPatterns([templateFileGlobPattern])
         await registry.watchUntitledFiles()
+
+        return registry
     }
 
     const asyncRegistry = new AsyncCloudFormationTemplateRegistry(registry, registrySetupFunc)
@@ -79,15 +82,21 @@ function setTemplateRegistryInGlobals(registry: CloudFormationTemplateRegistry)
         set(newInstance: CloudFormationTemplateRegistry) {
             this.cfnInstance = newInstance
         },
-        get() {
+        async get() {
             // This condition handles testing scenarios where we may have
             // already set a mock object before activation.
             // Though in prod nothing should be calling this 'set' function.
             if (this.cfnInstance) {
                 return this.cfnInstance
             }
 
-            return asyncRegistry.getInstance()
+            // prevent eager load if codelenses are off
+            const config = SamCliSettings.instance
+            if (config.get('enableCodeLenses', false) || isToolkitActive()) {
+                return await asyncRegistry.getInstance()
+            }
+
+            return NoopWatcher
         },
     })
 }

src/shared/codelens/codeLensUtils.ts

@@ -25,6 +25,7 @@ import * as goCodelens from './goCodeLensProvider'
 import { VSCODE_EXTENSION_ID } from '../extensions'
 import { getIdeProperties } from '../extensionUtilities'
 import { SamCliSettings } from '../sam/cli/samCliSettings'
+import globals from '../extensionGlobals'
 
 export type Language = 'python' | 'javascript' | 'csharp' | 'go' | 'java' | 'typescript'
 
@@ -59,7 +60,12 @@ export async function makeCodeLenses({
                   )
 
         try {
-            const associatedResources = getResourcesForHandler(handler.filename, handler.handlerName)
+            const registry = await globals.templateRegistry
+            const associatedResources = getResourcesForHandler(
+                handler.filename,
+                handler.handlerName,
+                registry.registeredItems
+            )
             const templateConfigs: AddSamDebugConfigurationInput[] = []
 
             if (associatedResources.length > 0) {

src/shared/codelens/samTemplateCodeLensProvider.ts

@@ -31,8 +31,8 @@ export class SamTemplateCodeLensProvider implements vscode.CodeLensProvider {
         }
 
         // User already has launch configs for:
-        const mappedApiConfigs = Array.from(getConfigsMappedToTemplates(launchConfig, 'api'))
-        const mappedFunConfigs = Array.from(getConfigsMappedToTemplates(launchConfig, 'template'))
+        const mappedApiConfigs = Array.from(await getConfigsMappedToTemplates(launchConfig, 'api'))
+        const mappedFunConfigs = Array.from(await getConfigsMappedToTemplates(launchConfig, 'template'))
 
         const unmappedApis = apiResources.filter(
             r =>

src/shared/debug/launchConfiguration.ts

@@ -26,6 +26,7 @@ import { getLogger } from '../logger'
 import { makeFailedWriteMessage, showViewLogsMessage } from '../utilities/messages'
 import { launchConfigDocUrl } from '../constants'
 import { openUrl } from '../utilities/vsCodeUtils'
+import globals from '../extensionGlobals'
 
 const localize = nls.loadMessageBundle()
 
@@ -68,11 +69,12 @@ export class LaunchConfiguration {
     /**
      * Returns all valid Sam Debug Configurations.
      */
-    public getSamDebugConfigurations(): AwsSamDebuggerConfiguration[] {
+    public async getSamDebugConfigurations(): Promise<AwsSamDebuggerConfiguration[]> {
         const configs = this.getDebugConfigurations().filter(o =>
             isAwsSamDebugConfiguration(o)
         ) as AwsSamDebuggerConfiguration[]
-        return configs.filter(o => this.samValidator.validate(o)?.isValid)
+        const registry = await globals.templateRegistry
+        return configs.filter(o => this.samValidator.validate(o, registry)?.isValid)
     }
 
     /**
@@ -127,8 +129,9 @@ class DefaultDebugConfigSource implements DebugConfigurationSource {
     }
 }
 
-function getSamCodeTargets(launchConfig: LaunchConfiguration): CodeTargetProperties[] {
-    return _(launchConfig.getSamDebugConfigurations())
+async function getSamCodeTargets(launchConfig: LaunchConfiguration): Promise<CodeTargetProperties[]> {
+    const debugConfigs = await launchConfig.getSamDebugConfigurations()
+    return _(debugConfigs)
         .map(samConfig => samConfig.invokeTarget)
         .filter(isCodeTargetProperties)
         .value()
@@ -141,18 +144,18 @@ function getSamCodeTargets(launchConfig: LaunchConfiguration): CodeTargetPropert
  * @param launchConfig Launch config to check
  * @param type  target type ('api' or 'template'), or undefined for 'both'
  */
-export function getConfigsMappedToTemplates(
+export async function getConfigsMappedToTemplates(
     launchConfig: LaunchConfiguration,
     type: AwsSamTargetType | undefined
-): Set<AwsSamDebuggerConfiguration> {
+): Promise<Set<AwsSamDebuggerConfiguration>> {
     if (type === 'code') {
         throw Error()
     }
     const folder = launchConfig.workspaceFolder
     // Launch configs with target=template or target=api.
-    const templateConfigs = launchConfig
-        .getSamDebugConfigurations()
-        .filter(o => isTemplateTargetProperties(o.invokeTarget))
+    const templateConfigs = (await launchConfig.getSamDebugConfigurations()).filter(o =>
+        isTemplateTargetProperties(o.invokeTarget)
+    )
     const filtered = templateConfigs.filter(
         t =>
             (type === undefined || t.invokeTarget.target === type) &&
@@ -175,8 +178,8 @@ export function getConfigsMappedToTemplates(
  *
  * @param launchConfig Launch config to check
  */
-export function getReferencedHandlerPaths(launchConfig: LaunchConfiguration): Set<string> {
-    const existingSamCodeTargets = getSamCodeTargets(launchConfig)
+export async function getReferencedHandlerPaths(launchConfig: LaunchConfiguration): Promise<Set<string>> {
+    const existingSamCodeTargets = await getSamCodeTargets(launchConfig)
 
     return _(existingSamCodeTargets)
         .map(target => {