fix(appbuilder): Prevent parallel build processes on the same template

packages/core/src/shared/sam/build.ts

@@ -25,6 +25,9 @@ import {
     getSamCliPathAndVersion,
     getTerminalFromError,
     isDotnetRuntime,
+    registerTemplateBuild,
+    throwIfTemplateIsBeingBuilt,
+    unregisterTemplateBuild,
     updateRecentResponse,
 } from './utils'
 import { getConfigFileUri, validateSamBuildConfig } from './config'
@@ -207,6 +210,9 @@ export async function runBuild(arg?: TreeNode): Promise<SamBuildResult> {
         throw new CancellationError('user')
     }
 
+    throwIfTemplateIsBeingBuilt(params.template.uri.path)
+    await registerTemplateBuild(params.template.uri.path)
+
     const projectRoot = params.projectRoot
 
     const defaultFlags: string[] = ['--cached', '--parallel', '--save-params', '--use-container']
@@ -229,23 +235,35 @@ export async function runBuild(arg?: TreeNode): Promise<SamBuildResult> {
     await updateRecentResponse(buildMementoRootKey, 'global', 'templatePath', templatePath)
 
     try {
-        const { path: samCliPath } = await getSamCliPathAndVersion()
+        await vscode.window.withProgress(
+            {
+                location: vscode.ProgressLocation.Notification,
+            },
+            async (progress) => {
+                progress.report({ message: `Building SAM template at ${params.template.uri.path}` })
 
-        // Create a child process to run the SAM build command
-        const buildProcess = new ChildProcess(samCliPath, ['build', ...buildFlags], {
-            spawnOptions: await addTelemetryEnvVar({
-                cwd: params.projectRoot.fsPath,
-                env: await getSpawnEnv(process.env),
-            }),
-        })
+                const { path: samCliPath } = await getSamCliPathAndVersion()
+
+                // Create a child process to run the SAM build command
+                const buildProcess = new ChildProcess(samCliPath, ['build', ...buildFlags], {
+                    spawnOptions: await addTelemetryEnvVar({
+                        cwd: params.projectRoot.fsPath,
+                        env: await getSpawnEnv(process.env),
+                    }),
+                })
+
+                // Run SAM build in Terminal
+                await runInTerminal(buildProcess, 'build')
+            }
+        )
 
-        // Run SAM build in Terminal
-        await runInTerminal(buildProcess, 'build')
+        await unregisterTemplateBuild(params.template.uri.path)
 
         return {
             isSuccess: true,
         }
     } catch (error) {
+        await unregisterTemplateBuild(params.template.uri.path)
         throw ToolkitError.chain(error, 'Failed to build SAM template', {
             details: { terminal: getTerminalFromError(error), ...resolveBuildArgConflict(buildFlags) },
             code: getErrorCode(error),

packages/core/src/shared/sam/utils.ts

@@ -108,6 +108,35 @@ export async function updateRecentResponse(
         getLogger().warn(`sam: unable to save response at key "${key}": %s`, err)
     }
 }
+
+const buildProcessMementoRootKey = 'samcli.build.processes'
+
+/**
+ * Returns true if there's an ongoing build process for the provided template, false otherwise
+ * @Param templatePath The path to the template.yaml file
+ */
+function isBuildInProgress(templatePath: string): boolean {
+    return getRecentResponse(buildProcessMementoRootKey, 'global', templatePath) !== undefined
+}
+
+/**
+ * Throws an error if there's a build in progress for the provided template
+ * @Param templatePath The path to the template.yaml file
+ */
+export function throwIfTemplateIsBeingBuilt(templatePath: string) {
+    if (isBuildInProgress(templatePath)) {
+        throw new ToolkitError('Template is already being built', { code: 'BuildInProgress' })
+    }
+}
+
+export async function registerTemplateBuild(templatePath: string) {
+    await updateRecentResponse(buildProcessMementoRootKey, 'global', templatePath, 'true')
+}
+
+export async function unregisterTemplateBuild(templatePath: string) {
+    await updateRecentResponse(buildProcessMementoRootKey, 'global', templatePath, undefined)
+}
+
 export function getSamCliErrorMessage(stderr: string): string {
     // Split the stderr string by newline, filter out empty lines, and get the last line
     const lines = stderr

packages/core/src/test/shared/sam/build.test.ts

@@ -17,6 +17,7 @@ import {
     getBuildFlags,
     ParamsSource,
     runBuild,
+    SamBuildResult,
 } from '../../../shared/sam/build'
 import { TreeNode } from '../../../shared/treeview/resourceTreeDataProvider'
 import { createWizardTester } from '../wizards/wizardTestUtils'
@@ -32,6 +33,7 @@ import { samconfigCompleteData, validTemplateData } from './samTestUtils'
 import { CloudFormationTemplateRegistry } from '../../../shared/fs/templateRegistry'
 import { getTestWindow } from '../vscode/window'
 import { CancellationError } from '../../../shared/utilities/timeoutUtils'
+import { SamAppLocation } from '../../../awsService/appBuilder/explorer/samProject'
 
 describe('SAM BuildWizard', async function () {
     const createTester = async (params?: Partial<BuildParams>, arg?: TreeNode | undefined) =>
@@ -388,22 +390,8 @@ describe('SAM runBuild', () => {
             verifyCorrectDependencyCall()
         })
 
-        it('[entry: appbuilder node] with default flags should instantiate correct process in terminal', async () => {
-            const prompterTester = PrompterTester.init()
-                .handleQuickPick('Specify parameter source for build', async (quickPick) => {
-                    // Need sometime to wait for the template to search for template file
-                    await quickPick.untilReady()
-
-                    assert.strictEqual(quickPick.items.length, 2)
-                    const items = quickPick.items
-                    assert.strictEqual(quickPick.items.length, 2)
-                    assert.deepStrictEqual(items[0], { data: ParamsSource.Specify, label: 'Specify build flags' })
-                    assert.deepStrictEqual(items[1].label, 'Use default values')
-                    quickPick.acceptItem(quickPick.items[1])
-                })
-                .build()
-
-            // Invoke sync command from command palette
+        it('[entry: appbuilder node] with default flags should instantiate correct process in terminal and show progress notification', async () => {
+            const prompterTester = getPrompterTester()
             const expectedSamAppLocation = {
                 workspaceFolder: workspaceFolder,
                 samTemplateUri: templateFile,
@@ -412,6 +400,10 @@ describe('SAM runBuild', () => {
 
             await runBuild(new AppNode(expectedSamAppLocation))
 
+            getTestWindow()
+                .getFirstMessage()
+                .assertProgress(`Building SAM template at ${expectedSamAppLocation.samTemplateUri.path}`)
+
             assert.deepEqual(mockChildProcessClass.getCall(0).args, [
                 'sam-cli-path',
                 [
@@ -437,6 +429,27 @@ describe('SAM runBuild', () => {
             prompterTester.assertCallAll()
         })
 
+        it('[entry: appbuilder node] should throw an error when running two build processes in parallel for the same template', async () => {
+            const prompterTester = getPrompterTester()
+            const expectedSamAppLocation = {
+                workspaceFolder: workspaceFolder,
+                samTemplateUri: templateFile,
+                projectRoot: projectRoot,
+            }
+            await assert.rejects(
+                async () => {
+                    await runInParallel(expectedSamAppLocation)
+                },
+                (e: any) => {
+                    assert.strictEqual(e instanceof ToolkitError, true)
+                    assert.strictEqual(e.message, 'Template is already being built')
+                    assert.strictEqual(e.code, 'BuildInProgress')
+                    return true
+                }
+            )
+            prompterTester.assertCallAll(undefined, 2)
+        })
+
         it('[entry: command palette] use samconfig should instantiate correct process in terminal', async () => {
             const samconfigFile = vscode.Uri.file(await testFolder.write('samconfig.toml', samconfigCompleteData))
 
@@ -551,3 +564,23 @@ describe('SAM runBuild', () => {
         })
     })
 })
+
+async function runInParallel(samLocation: SamAppLocation): Promise<[SamBuildResult, SamBuildResult]> {
+    return Promise.all([runBuild(new AppNode(samLocation)), runBuild(new AppNode(samLocation))])
+}
+
+function getPrompterTester() {
+    return PrompterTester.init()
+        .handleQuickPick('Specify parameter source for build', async (quickPick) => {
+            // Need sometime to wait for the template to search for template file
+            await quickPick.untilReady()
+
+            assert.strictEqual(quickPick.items.length, 2)
+            const items = quickPick.items
+            assert.strictEqual(quickPick.items.length, 2)
+            assert.deepStrictEqual(items[0], { data: ParamsSource.Specify, label: 'Specify build flags' })
+            assert.deepStrictEqual(items[1].label, 'Use default values')
+            quickPick.acceptItem(quickPick.items[1])
+        })
+        .build()
+}

packages/core/src/testInteg/sam.test.ts

@@ -700,7 +700,7 @@ describe('SAM Integration Tests', async function () {
     describe('SAM Build', async function () {
         let workspaceFolder: vscode.WorkspaceFolder
         // We're testing only one case (python 3.10 (ZIP)) on the integration tests. More niche cases are handled as unit tests.
-        const scenarioIndex = 2
+        const scenarioIndex = 3
         const scenario = scenarios[scenarioIndex]
         let testRoot: string
         let sandbox: sinon.SinonSandbox

packages/toolkit/.changes/next-release/Bug Fix-db0d3605-5cb7-4b78-b4ae-29be86f51f99.json

@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "SAM build: prevent running multiple build processes for the same template"
+}