diff --git a/package-lock.json b/package-lock.json index 3e625d1bd5b..da7a479fbb9 100644 --- a/package-lock.json +++ b/package-lock.json @@ -16122,35 +16122,30 @@ "version": "1.1.2", "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz", "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/base64": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz", "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/codegen": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz", "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/eventemitter": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz", "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/fetch": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz", "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", - "dev": true, "license": "BSD-3-Clause", "dependencies": { "@protobufjs/aspromise": "^1.1.1", @@ -16161,35 +16156,30 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz", "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/inquire": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz", "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/path": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz", "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/pool": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz", "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@protobufjs/utf8": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz", "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", - "dev": true, "license": "BSD-3-Clause" }, "node_modules/@sindresorhus/is": { @@ -24251,10 +24241,9 @@ "license": "MIT" }, "node_modules/long": { - "version": "5.3.2", - "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz", - "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==", - "dev": true, + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.3.1.tgz", + "integrity": "sha512-ka87Jz3gcx/I7Hal94xaN2tZEOPoUOEVftkQqZx2EeQRN7LGdfLlI3FvZ+7WDplm+vK2Urx9ULrvSowtdCieng==", "license": "Apache-2.0" }, "node_modules/lowercase-keys": { @@ -26025,10 +26014,9 @@ "license": "MIT" }, "node_modules/protobufjs": { - "version": "7.5.1", - "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.1.tgz", - "integrity": "sha512-3qx3IRjR9WPQKagdwrKjO3Gu8RgQR2qqw+1KnigWhoVjFqegIj1K3bP11sGqhxrO46/XL7lekuG4jmjL+4cLsw==", - "dev": true, + "version": "7.4.0", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.4.0.tgz", + "integrity": "sha512-mRUWCc3KUU4w1jU8sGxICXH/gNS94DvI1gxqDvBzhj1JpcsimQkYiOJfwsPUykUI5ZaspFbSgmBLER8IrQ3tqw==", "hasInstallScript": true, "license": "BSD-3-Clause", "dependencies": { @@ -29629,7 +29617,6 @@ }, "node_modules/ws": { "version": "8.17.1", - "dev": true, "license": "MIT", "engines": { "node": ">=10.0.0" @@ -30053,6 +30040,7 @@ "mime-types": "^2.1.32", "node-fetch": "^2.7.0", "portfinder": "^1.0.32", + "protobufjs": "^7.2.6", "semver": "^7.5.4", "stream-buffers": "^3.0.2", "strip-ansi": "^5.2.0", @@ -30067,6 +30055,7 @@ "whatwg-url": "^14.0.0", "winston": "^3.11.0", "winston-transport": "^4.6.0", + "ws": "^8.16.0", "xml2js": "^0.6.1", "yaml-cfn": "^0.3.2" }, diff --git a/packages/core/package.json b/packages/core/package.json index baa8446aea9..6f8d27ef4dc 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -609,8 +609,10 @@ "whatwg-url": "^14.0.0", "winston": "^3.11.0", "winston-transport": "^4.6.0", + "ws": "^8.16.0", "xml2js": "^0.6.1", "yaml-cfn": "^0.3.2", + "protobufjs": "^7.2.6", "@svgdotjs/svg.js": "^3.0.16", "svgdom": "^0.1.0", "jaro-winkler": "^0.2.8" diff --git a/packages/core/package.nls.json b/packages/core/package.nls.json index c8c091a609e..20d500e07bd 100644 --- a/packages/core/package.nls.json +++ b/packages/core/package.nls.json @@ -99,7 +99,7 @@ "AWS.configuration.description.amazonq.workspaceIndexCacheDirPath": "The path to the directory that contains the cache of the index of your workspace files", "AWS.configuration.description.amazonq.ignoredSecurityIssues": "Specifies a list of code issue identifiers that Amazon Q should ignore when reviewing your workspace. Each item in the array should be a unique string identifier for a specific code issue. This allows you to suppress notifications for known issues that you've assessed and determined to be false positives or not applicable to your project. Use this setting with caution, as it may cause you to miss important security alerts.", "AWS.configuration.description.amazonq.proxy.certificateAuthority": "Path to a Certificate Authority (PEM file) for SSL/TLS verification when using a proxy.", - "AWS.command.apig.invokeRemoteRestApi": "Invoke in the cloud", + "AWS.command.apig.invokeRemoteRestApi": "Invoke remotely", "AWS.command.apig.invokeRemoteRestApi.cn": "Invoke on Amazon", "AWS.appBuilder.explorerTitle": "Application Builder", "AWS.appBuilder.explorerNode.noApps": "[This resource is not yet supported.]", @@ -159,11 +159,12 @@ "AWS.command.aboutToolkit": "About", "AWS.command.downloadLambda": "Download...", "AWS.command.uploadLambda": "Upload Lambda...", - "AWS.command.invokeLambda": "Invoke in the cloud", + "AWS.command.invokeLambda": "Invoke Remotely", "AWS.command.openLambdaFile": "Open your Lambda code", "AWS.command.quickDeployLambda": "Save and deploy your code", "AWS.command.openLambdaWorkspace": "Open in a workspace", "AWS.command.invokeLambda.cn": "Invoke on Amazon", + "AWS.command.remoteDebugging.clearSnapshot": "Reset Lambda Remote Debugging Snapshot", "AWS.command.lambda.convertToSam": "Convert to SAM Application", "AWS.command.refreshAwsExplorer": "Refresh Explorer", "AWS.command.refreshCdkExplorer": "Refresh CDK Explorer", diff --git a/packages/core/src/awsService/appBuilder/explorer/nodes/deployedNode.ts b/packages/core/src/awsService/appBuilder/explorer/nodes/deployedNode.ts index 470169a7725..100c6802c52 100644 --- a/packages/core/src/awsService/appBuilder/explorer/nodes/deployedNode.ts +++ b/packages/core/src/awsService/appBuilder/explorer/nodes/deployedNode.ts @@ -27,6 +27,7 @@ import { s3BucketType, } from '../../../../shared/cloudformation/cloudformation' import { ToolkitError } from '../../../../shared/errors' +import { ResourceTreeEntity } from '../samProject' const localize = nls.loadMessageBundle() export interface DeployedResource { @@ -77,7 +78,8 @@ export async function generateDeployedNode( deployedResource: any, regionCode: string, stackName: string, - resourceTreeEntity: any + resourceTreeEntity: ResourceTreeEntity, + location?: vscode.Uri ): Promise { let newDeployedResource: any const partitionId = globals.regionProvider.getPartitionId(regionCode) ?? defaultPartition @@ -90,7 +92,13 @@ export async function generateDeployedNode( try { configuration = (await defaultClient.getFunction(deployedResource.PhysicalResourceId)) .Configuration as Lambda.FunctionConfiguration - newDeployedResource = new LambdaFunctionNode(lambdaNode, regionCode, configuration) + newDeployedResource = new LambdaFunctionNode( + lambdaNode, + regionCode, + configuration, + undefined, + location ? vscode.Uri.joinPath(location, resourceTreeEntity.CodeUri ?? '').fsPath : undefined + ) } catch (error: any) { getLogger().error('Error getting Lambda configuration: %O', error) throw ToolkitError.chain(error, 'Error getting Lambda configuration', { diff --git a/packages/core/src/awsService/appBuilder/explorer/nodes/resourceNode.ts b/packages/core/src/awsService/appBuilder/explorer/nodes/resourceNode.ts index bda7b69ac4f..72de5afc60f 100644 --- a/packages/core/src/awsService/appBuilder/explorer/nodes/resourceNode.ts +++ b/packages/core/src/awsService/appBuilder/explorer/nodes/resourceNode.ts @@ -60,7 +60,8 @@ export class ResourceNode implements TreeNode { this.deployedResource, this.region, this.stackName, - this.resourceTreeEntity + this.resourceTreeEntity, + this.location.projectRoot ) } if (this.resourceTreeEntity.Type === SERVERLESS_FUNCTION_TYPE) { diff --git a/packages/core/src/awsService/appBuilder/utils.ts b/packages/core/src/awsService/appBuilder/utils.ts index ba5b3baf7f8..bdaa6293b30 100644 --- a/packages/core/src/awsService/appBuilder/utils.ts +++ b/packages/core/src/awsService/appBuilder/utils.ts @@ -569,19 +569,24 @@ export async function getLambdaHandlerFile( }) } + // if this function is used to get handler from a just downloaded lambda function zip. codeUri will be '' + if (codeUri !== '') { + folderUri = vscode.Uri.joinPath(folderUri, codeUri) + } + const handlerParts = handler.split('.') // sample: app.lambda_handler -> app.rb if (family === RuntimeFamily.Ruby) { // Ruby supports namespace/class handlers as well, but the path is // guaranteed to be slash-delimited so we can assume the first part is // the path - return vscode.Uri.joinPath(folderUri, codeUri, handlerParts.slice(0, handlerParts.length - 1).join('/') + '.rb') + return vscode.Uri.joinPath(folderUri, handlerParts.slice(0, handlerParts.length - 1).join('/') + '.rb') } // sample:app.lambda_handler -> app.py if (family === RuntimeFamily.Python) { // Otherwise (currently Node.js and Python) handle dot-delimited paths - return vscode.Uri.joinPath(folderUri, codeUri, handlerParts.slice(0, handlerParts.length - 1).join('/') + '.py') + return vscode.Uri.joinPath(folderUri, handlerParts.slice(0, handlerParts.length - 1).join('/') + '.py') } // sample: app.handler -> app.mjs/app.js @@ -591,8 +596,8 @@ export async function getLambdaHandlerFile( const handlerPath = path.dirname(handlerName) const handlerFile = path.basename(handlerName) const pattern = new vscode.RelativePattern( - vscode.Uri.joinPath(folderUri, codeUri, handlerPath), - `${handlerFile}.{js,mjs}` + vscode.Uri.joinPath(folderUri, handlerPath), + `${handlerFile}.{js,mjs,cjs,ts}` ) return searchHandlerFile(folderUri, pattern) } @@ -600,14 +605,14 @@ export async function getLambdaHandlerFile( // sample: ImageResize::ImageResize.Function::FunctionHandler -> Function.cs if (family === RuntimeFamily.DotNet) { const handlerName = path.basename(handler.split('::')[1].replaceAll('.', '/')) - const pattern = new vscode.RelativePattern(vscode.Uri.joinPath(folderUri, codeUri), `${handlerName}.cs`) + const pattern = new vscode.RelativePattern(folderUri, `${handlerName}.cs`) return searchHandlerFile(folderUri, pattern) } // sample: resizer.App::handleRequest -> App.java if (family === RuntimeFamily.Java) { const handlerName = handler.split('::')[0].replaceAll('.', '/') - const pattern = new vscode.RelativePattern(vscode.Uri.joinPath(folderUri, codeUri), `**/${handlerName}.java`) + const pattern = new vscode.RelativePattern(folderUri, `**/${handlerName}.java`) return searchHandlerFile(folderUri, pattern) } } diff --git a/packages/core/src/lambda/activation.ts b/packages/core/src/lambda/activation.ts index 9873371d40f..eaebc17de3b 100644 --- a/packages/core/src/lambda/activation.ts +++ b/packages/core/src/lambda/activation.ts @@ -13,7 +13,6 @@ import { uploadLambdaCommand } from './commands/uploadLambda' import { LambdaFunctionNode } from './explorer/lambdaFunctionNode' import { downloadLambdaCommand, openLambdaFile } from './commands/downloadLambda' import { tryRemoveFolder } from '../shared/filesystemUtilities' -import { ExtContext } from '../shared/extensions' import { invokeRemoteLambda } from './vue/remoteInvoke/invokeLambda' import { registerSamDebugInvokeVueCommand, registerSamInvokeVueCommand } from './vue/configEditor/samInvokeBackend' import { Commands } from '../shared/vscode/commands2' @@ -42,6 +41,8 @@ import { registerLambdaUriHandler } from './uriHandlers' import globals from '../shared/extensionGlobals' const localize = nls.loadMessageBundle() +import { activateRemoteDebugging } from './remoteDebugging/ldkController' +import { ExtContext } from '../shared/extensions' async function openReadme() { const readmeUri = vscode.Uri.file(await getReadme()) @@ -263,4 +264,6 @@ export async function activate(context: ExtContext): Promise { registerLambdaUriHandler() ) + + void activateRemoteDebugging() } diff --git a/packages/core/src/lambda/commands/downloadLambda.ts b/packages/core/src/lambda/commands/downloadLambda.ts index bc189b54c81..baf82b5b30c 100644 --- a/packages/core/src/lambda/commands/downloadLambda.ts +++ b/packages/core/src/lambda/commands/downloadLambda.ts @@ -27,9 +27,33 @@ import { telemetry } from '../../shared/telemetry/telemetry' import { Result, Runtime } from '../../shared/telemetry/telemetry' import { fs } from '../../shared/fs/fs' import { LambdaFunction } from './uploadLambda' +import globals from '../../shared/extensionGlobals' + +// Workspace state key for Lambda function ARN to local path cache +const LAMBDA_ARN_CACHE_KEY = 'aws.lambda.functionArnToLocalPathCache' // eslint-disable-line @typescript-eslint/naming-convention + +async function setLambdaArnCache(functionArn: string, localPath: string): Promise { + try { + const cache: Record = globals.context.workspaceState.get(LAMBDA_ARN_CACHE_KEY, {}) + cache[functionArn] = localPath + await globals.context.workspaceState.update(LAMBDA_ARN_CACHE_KEY, cache) + getLogger().debug(`lambda: cached local path for function ARN: ${functionArn} -> ${localPath}`) + } catch (error) { + getLogger().error(`lambda: failed to cache local path for function ARN: ${functionArn}`, error) + } +} + +export function getCachedLocalPath(functionArn: string): string | undefined { + const cache: Record = globals.context.workspaceState.get(LAMBDA_ARN_CACHE_KEY, {}) + return cache[functionArn] +} export async function downloadLambdaCommand(functionNode: LambdaFunctionNode) { const result = await runDownloadLambda(functionNode) + // check if result is Result + if (result instanceof vscode.Uri) { + return + } telemetry.lambda_import.emit({ result, @@ -37,7 +61,10 @@ export async function downloadLambdaCommand(functionNode: LambdaFunctionNode) { }) } -async function runDownloadLambda(functionNode: LambdaFunctionNode): Promise { +export async function runDownloadLambda( + functionNode: LambdaFunctionNode, + returnDir: boolean = false +): Promise { const workspaceFolders = vscode.workspace.workspaceFolders || [] const functionName = functionNode.configuration.FunctionName! @@ -74,6 +101,9 @@ async function runDownloadLambda(functionNode: LambdaFunctionNode): Promise { - return await vscode.window.withProgress( + selectedUri?: vscode.Uri, + returnDir: boolean = false +): Promise { + const result = await vscode.window.withProgress( { location: vscode.ProgressLocation.Notification, cancellable: false, @@ -107,8 +139,22 @@ export async function downloadLambdaInLocation( let lambdaLocation: string try { - lambdaLocation = path.join(downloadLocation, getLambdaDetails(lambda.configuration!).fileName) await downloadAndUnzipLambda(progress, lambda, downloadLocation) + // Cache the mapping of function ARN to downloaded location + if (lambda.configuration?.FunctionArn) { + await setLambdaArnCache(lambda.configuration.FunctionArn, downloadLocation) + } + lambdaLocation = path.join(downloadLocation, getLambdaDetails(lambda.configuration!).fileName) + if (!(await fs.exists(lambdaLocation))) { + // if file ext is mjs, change to js or vice versa + const currentExt = path.extname(lambdaLocation) + const alternativeExt = currentExt === '.mjs' ? '.js' : '.mjs' + const alternativePath = lambdaLocation.replace(currentExt, alternativeExt) + + if (await fs.exists(alternativePath)) { + lambdaLocation = alternativePath + } + } } catch (e) { // initial download failed or runtime is unsupported. // show error and return a failure @@ -127,6 +173,7 @@ export async function downloadLambdaInLocation( } try { + await vscode.commands.executeCommand('workbench.action.focusFirstEditorGroup') await openLambdaFile(lambdaLocation) if (workspaceFolders) { if ( @@ -148,6 +195,12 @@ export async function downloadLambdaInLocation( } } ) + + if (returnDir) { + return vscode.Uri.file(downloadLocation) + } else { + return result + } } async function downloadAndUnzipLambda( @@ -205,6 +258,7 @@ export async function openLambdaFile(lambdaLocation: string, viewColumn?: vscode void vscode.window.showWarningMessage(warning) throw new Error() } + await vscode.commands.executeCommand('workbench.action.focusFirstEditorGroup') const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(lambdaLocation)) await vscode.window.showTextDocument(doc, viewColumn) } diff --git a/packages/core/src/lambda/explorer/lambdaFunctionNode.ts b/packages/core/src/lambda/explorer/lambdaFunctionNode.ts index 2093a9585d4..03cb9210aaa 100644 --- a/packages/core/src/lambda/explorer/lambdaFunctionNode.ts +++ b/packages/core/src/lambda/explorer/lambdaFunctionNode.ts @@ -27,7 +27,8 @@ export class LambdaFunctionNode extends AWSTreeNodeBase implements AWSResourceNo public readonly parent: AWSTreeNodeBase, public override readonly regionCode: string, public configuration: Lambda.FunctionConfiguration, - public override readonly contextValue?: string + public override readonly contextValue?: string, + public localDir?: string ) { super( `${configuration.FunctionArn}`, diff --git a/packages/core/src/lambda/models/samLambdaRuntime.ts b/packages/core/src/lambda/models/samLambdaRuntime.ts index d6d8683e28b..06e35dbcd2b 100644 --- a/packages/core/src/lambda/models/samLambdaRuntime.ts +++ b/packages/core/src/lambda/models/samLambdaRuntime.ts @@ -99,6 +99,16 @@ const defaultRuntimes = ImmutableMap([ [RuntimeFamily.Ruby, 'ruby3.3'], ]) +export const mapFamilyToDebugType = ImmutableMap([ + [RuntimeFamily.NodeJS, 'node'], + [RuntimeFamily.Python, 'python'], + [RuntimeFamily.DotNet, 'csharp'], + [RuntimeFamily.Go, 'go'], + [RuntimeFamily.Java, 'java'], + [RuntimeFamily.Ruby, 'ruby'], + [RuntimeFamily.Unknown, 'unknown'], +]) + export const samZipLambdaRuntimes: ImmutableSet = ImmutableSet.union([ nodeJsRuntimes, pythonRuntimes, diff --git a/packages/core/src/lambda/remoteDebugging/ldkClient.ts b/packages/core/src/lambda/remoteDebugging/ldkClient.ts new file mode 100644 index 00000000000..915e150b039 --- /dev/null +++ b/packages/core/src/lambda/remoteDebugging/ldkClient.ts @@ -0,0 +1,470 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import * as vscode from 'vscode' +import { IoTSecureTunneling, Lambda } from 'aws-sdk' +import { getClientId } from '../../shared/telemetry/util' +import { DefaultLambdaClient } from '../../shared/clients/lambdaClient' +import { LocalProxy } from './localProxy' +import globals from '../../shared/extensionGlobals' +import { getLogger } from '../../shared/logger/logger' +import { getIoTSTClientWithAgent, getLambdaClientWithAgent } from './utils' +import { ToolkitError } from '../../shared/errors' +import * as nls from 'vscode-nls' + +const localize = nls.loadMessageBundle() + +export function isTunnelInfo(data: TunnelInfo): data is TunnelInfo { + return ( + typeof data === 'object' && + data !== null && + typeof data.tunnelID === 'string' && + typeof data.sourceToken === 'string' && + typeof data.destinationToken === 'string' + ) +} + +interface TunnelInfo { + tunnelID: string + sourceToken: string + destinationToken: string +} + +async function callUpdateFunctionConfiguration( + lambda: DefaultLambdaClient, + config: Lambda.FunctionConfiguration, + waitForUpdate: boolean +): Promise { + // Update function configuration back to original values + return await lambda.updateFunctionConfiguration( + { + FunctionName: config.FunctionName!, + Timeout: config.Timeout, + Layers: config.Layers?.map((layer) => layer.Arn!).filter(Boolean) || [], + Environment: { + Variables: config.Environment?.Variables ?? {}, + }, + }, + { + maxRetries: 5, + initialDelayMs: 2000, + backoffMultiplier: 2, + waitForUpdate: waitForUpdate, + } + ) +} + +export class LdkClient { + static #instance: LdkClient + private localProxy: LocalProxy | undefined + private static instanceCreating = false + private lambdaClientCache: Map = new Map() + private iotSTClientCache: Map = new Map() + + constructor() {} + + public static get instance() { + if (this.#instance !== undefined) { + return this.#instance + } + if (this.instanceCreating) { + getLogger().warn( + localize( + 'AWS.lambda.ldkClient.multipleInstancesError', + 'Attempt to create multiple LdkClient instances simultaneously' + ) + ) + } + // Set flag to prevent recursive instance creation + this.instanceCreating = true + try { + const self = (this.#instance = new this()) + return self + } finally { + this.instanceCreating = false + } + } + + /** + * Get or create a cached Lambda client for the specified region + */ + private getLambdaClient(region: string): DefaultLambdaClient { + if (!this.lambdaClientCache.has(region)) { + this.lambdaClientCache.set(region, getLambdaClientWithAgent(region)) + } + return this.lambdaClientCache.get(region)! + } + + private async getIoTSTClient(region: string): Promise { + if (!this.iotSTClientCache.has(region)) { + this.iotSTClientCache.set(region, await getIoTSTClientWithAgent(region)) + } + return this.iotSTClientCache.get(region)! + } + /** + * Clean up all resources held by this client + * Should be called when the extension is deactivated + */ + public dispose(): void { + if (this.localProxy) { + this.localProxy.stop() + this.localProxy = undefined + } + // Clear the Lambda client cache + this.iotSTClientCache.clear() + this.lambdaClientCache.clear() + } + + // Create or reuse tunnel + async createOrReuseTunnel(region: string): Promise { + try { + // Get VSCode UUID using getClientId from telemetry.utils.ts + const vscodeUuid = getClientId(globals.globalState) + + // Create IoTSecureTunneling client + const iotSecureTunneling = await this.getIoTSTClient(region) + + // Define tunnel identifier + const tunnelIdentifier = `RemoteDebugging+${vscodeUuid}` + const timeoutInMinutes = 720 + // List existing tunnels + const listTunnelsResponse = await iotSecureTunneling.listTunnels({}).promise() + + // Find tunnel with our identifier + const existingTunnel = listTunnelsResponse.tunnelSummaries?.find( + (tunnel) => tunnel.description === tunnelIdentifier && tunnel.status?.toLowerCase() === 'open' + ) + + if (existingTunnel && existingTunnel.tunnelId) { + const timeCreated = existingTunnel?.createdAt ? new Date(existingTunnel.createdAt) : new Date() + const expiryTime = new Date(timeCreated.getTime() + timeoutInMinutes * 60 * 1000) + const currentTime = new Date() + const minutesRemaining = (expiryTime.getTime() - currentTime.getTime()) / (60 * 1000) + + if (minutesRemaining >= 15) { + // Rotate access tokens for the existing tunnel + const rotateResponse = await this.refreshTunnelTokens(existingTunnel.tunnelId, region) + + return rotateResponse + } else { + // Close tunnel if less than 15 minutes remaining + await iotSecureTunneling + .closeTunnel({ + tunnelId: existingTunnel.tunnelId, + delete: false, + }) + .promise() + + getLogger().info(`Closed tunnel ${existingTunnel.tunnelId} with less than 15 minutes remaining`) + } + } + + // Create new tunnel + const openTunnelResponse = await iotSecureTunneling + .openTunnel({ + description: tunnelIdentifier, + timeoutConfig: { + maxLifetimeTimeoutMinutes: timeoutInMinutes, // 12 hours + }, + destinationConfig: { + services: ['WSS'], + }, + }) + .promise() + + getLogger().info(`Created new tunnel with ID: ${openTunnelResponse.tunnelId}`) + + return { + tunnelID: openTunnelResponse.tunnelId || '', + sourceToken: openTunnelResponse.sourceAccessToken || '', + destinationToken: openTunnelResponse.destinationAccessToken || '', + } + } catch (error) { + throw ToolkitError.chain(error, 'Error creating/reusing tunnel') + } + } + + // Refresh tunnel tokens + async refreshTunnelTokens(tunnelId: string, region: string): Promise { + try { + const iotSecureTunneling = await this.getIoTSTClient(region) + const rotateResponse = await iotSecureTunneling + .rotateTunnelAccessToken({ + tunnelId: tunnelId, + clientMode: 'ALL', + }) + .promise() + + return { + tunnelID: tunnelId, + sourceToken: rotateResponse.sourceAccessToken || '', + destinationToken: rotateResponse.destinationAccessToken || '', + } + } catch (error) { + throw ToolkitError.chain(error, 'Error refreshing tunnel tokens') + } + } + + async getFunctionDetail(functionArn: string): Promise { + try { + const region = getRegionFromArn(functionArn) + if (!region) { + getLogger().error( + localize( + 'AWS.lambda.ldkClient.couldNotDetermineRegion', + 'Could not determine region from Lambda ARN' + ) + ) + return undefined + } + const client = this.getLambdaClient(region) + const configuration = (await client.getFunction(functionArn)).Configuration as Lambda.FunctionConfiguration + // get function detail + // return function detail + return configuration + } catch (error) { + getLogger().warn(`Error getting function detail:${error}`) + return undefined + } + } + + // Create debug deployment to given lambda function + // save a snapshot of the current config to global : aws.lambda.remoteDebugContext + // we are 1: changing function timeout to 15 minute + // 2: adding the ldk layer LDK_LAYER_ARN_X86_64 or LDK_LAYER_ARN_ARM64 (ignore if already added, fail if 5 layer already there) + // 3: adding two param to lambda environment variable + // {AWS_LAMBDA_EXEC_WRAPPER:/opt/bin/ldk_wrapper, AWS_LDK_DESTINATION_TOKEN: destinationToken } + async createDebugDeployment( + config: Lambda.FunctionConfiguration, + destinationToken: string, + lambdaTimeout: number, + shouldPublishVersion: boolean, + ldkLayerArn: string, + progress: vscode.Progress<{ message?: string | undefined; increment?: number | undefined }> + ): Promise { + try { + if (!config.FunctionArn || !config.FunctionName) { + throw new Error(localize('AWS.lambda.ldkClient.functionArnMissing', 'Function ARN is missing')) + } + const region = getRegionFromArn(config.FunctionArn ?? '') + if (!region) { + throw new Error( + localize( + 'AWS.lambda.ldkClient.couldNotDetermineRegion', + 'Could not determine region from Lambda ARN' + ) + ) + } + + // fix out of bound timeout + if (lambdaTimeout && (lambdaTimeout > 900 || lambdaTimeout <= 0)) { + lambdaTimeout = 900 + } + + // Inform user about the changes that will be made + + progress.report({ message: localize('AWS.lambda.ldkClient.applyingChanges', 'Applying changes...') }) + + // Determine architecture and select appropriate layer + + const layers = config.Layers || [] + + // Check if LDK layer is already added + const ldkLayerExists = layers.some( + (layer) => layer.Arn?.includes('LDKLayerX86') || layer.Arn?.includes('LDKLayerArm64') + ) + + // Check if we have room to add a layer (max 5) + if (!ldkLayerExists && layers.length >= 5) { + throw new Error( + localize( + 'AWS.lambda.ldkClient.cannotAddLdkLayer', + 'Cannot add LDK layer: Lambda function already has 5 layers' + ) + ) + } + // Create updated layers list + const updatedLayers = ldkLayerExists + ? layers.map((layer) => layer.Arn!).filter(Boolean) + : [...layers.map((layer) => layer.Arn!).filter(Boolean), ldkLayerArn] + + // Create updated environment variables + const currentEnv = config.Environment?.Variables || {} + const updatedEnv: { [key: string]: string } = { + ...currentEnv, + AWS_LAMBDA_EXEC_WRAPPER: '/opt/bin/ldk_wrapper', + AWS_LAMBDA_DEBUG_ON_LATEST: shouldPublishVersion ? 'false' : 'true', + AWS_LDK_DESTINATION_TOKEN: destinationToken, + } + if (currentEnv['AWS_LAMBDA_EXEC_WRAPPER']) { + updatedEnv.ORIGINAL_AWS_LAMBDA_EXEC_WRAPPER = currentEnv['AWS_LAMBDA_EXEC_WRAPPER'] + } + + // Create Lambda client using AWS SDK + const lambda = this.getLambdaClient(region) + + // Update function configuration + if (!config.FunctionArn || !config.FunctionName) { + throw new Error('Function ARN is missing') + } + + // Create a temporary config for the update + const updateConfig: Lambda.FunctionConfiguration = { + FunctionName: config.FunctionName, + Timeout: lambdaTimeout ?? 900, // 15 minutes + Layers: updatedLayers.map((arn) => ({ Arn: arn })), + Environment: { + Variables: updatedEnv, + }, + } + + await callUpdateFunctionConfiguration(lambda, updateConfig, true) + + // publish version + let version = '$Latest' + if (shouldPublishVersion) { + // should somehow return version for debugging + const versionResp = await lambda.publishVersion(config.FunctionName, { waitForUpdate: true }) + version = versionResp.Version ?? '' + // remove debug deployment in a non-blocking way + void Promise.resolve( + callUpdateFunctionConfiguration(lambda, config, false).then(() => { + progress.report({ + message: localize( + 'AWS.lambda.ldkClient.debugDeploymentCompleted', + 'Debug deployment completed successfully' + ), + }) + }) + ) + } + return version + } catch (error) { + getLogger().error(`Error creating debug deployment: ${error}`) + if (error instanceof Error) { + throw new ToolkitError(`Failed to create debug deployment: ${error.message}`) + } + return 'Failed' + } + } + + // Remove debug deployment from the given lambda function + // use the snapshot we took before create debug deployment + // we are 1: reverting timeout to it's original snapshot + // 2: reverting layer status according to it's original snapshot + // 3: reverting environment back to it's original snapshot + async removeDebugDeployment(config: Lambda.FunctionConfiguration, check: boolean = true): Promise { + try { + if (!config.FunctionArn || !config.FunctionName) { + throw new Error('Function ARN is missing') + } + const region = getRegionFromArn(config.FunctionArn ?? '') + if (!region) { + throw new Error('Could not determine region from Lambda ARN') + } + + if (check) { + const currentConfig = await this.getFunctionDetail(config.FunctionArn) + if ( + currentConfig?.Timeout === config?.Timeout && + currentConfig?.Layers?.length === config?.Layers?.length + ) { + // nothing to remove + return true + } + } + + // Create Lambda client using AWS SDK + const lambda = this.getLambdaClient(region) + + // Update function configuration back to original values + await callUpdateFunctionConfiguration(lambda, config, false) + + return true + } catch (error) { + // no need to raise, even this failed we want the following to execute + throw ToolkitError.chain(error, 'Error removing debug deployment') + } + } + + async deleteDebugVersion(functionArn: string, qualifier: string) { + try { + const region = getRegionFromArn(functionArn) + if (!region) { + throw new Error('Could not determine region from Lambda ARN') + } + const lambda = this.getLambdaClient(region) + await lambda.deleteFunction(functionArn, qualifier) + return true + } catch (error) { + getLogger().error('Error deleting debug version: %O', error) + return false + } + } + + // Start proxy with better resource management + async startProxy(region: string, sourceToken: string, port: number = 0): Promise { + try { + getLogger().info(`Starting direct proxy for region:${region}`) + + // Clean up any existing proxy thoroughly + if (this.localProxy) { + getLogger().info('Stopping existing proxy before starting a new one') + this.localProxy.stop() + this.localProxy = undefined + + // Small delay to ensure resources are released + await new Promise((resolve) => setTimeout(resolve, 100)) + } + + // Create and start a new local proxy + this.localProxy = new LocalProxy() + + // Start the proxy and get the assigned port + const localPort = await this.localProxy.start(region, sourceToken, port) + getLogger().info(`Local proxy started successfully on port ${localPort}`) + return true + } catch (error) { + getLogger().error(`Failed to start proxy: ${error}`) + if (this.localProxy) { + this.localProxy.stop() + this.localProxy = undefined + } + throw ToolkitError.chain(error, 'Failed to start proxy') + } + } + + // Stop proxy with proper cleanup and reference handling + async stopProxy(): Promise { + try { + getLogger().info(`Stopping proxy`) + + if (this.localProxy) { + // Ensure proper resource cleanup + this.localProxy.stop() + + // Force delete the reference to allow GC + this.localProxy = undefined + + getLogger().info('Local proxy stopped successfully') + } else { + getLogger().info('No active local proxy to stop') + } + + return true + } catch (error) { + throw ToolkitError.chain(error, 'Error stopping proxy') + } + } +} + +// Helper function to extract region from ARN +export function getRegionFromArn(arn: string | undefined): string | undefined { + if (!arn) { + return undefined + } + const parts = arn.split(':') + return parts.length >= 4 ? parts[3] : undefined +} diff --git a/packages/core/src/lambda/remoteDebugging/ldkController.ts b/packages/core/src/lambda/remoteDebugging/ldkController.ts new file mode 100644 index 00000000000..c4c08b10254 --- /dev/null +++ b/packages/core/src/lambda/remoteDebugging/ldkController.ts @@ -0,0 +1,784 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import * as vscode from 'vscode' +import { getLogger } from '../../shared/logger/logger' +import globals from '../../shared/extensionGlobals' +import { Lambda } from 'aws-sdk' +import { getRegionFromArn, isTunnelInfo, LdkClient } from './ldkClient' +import { getFamily, mapFamilyToDebugType } from '../models/samLambdaRuntime' +import { findJavaPath } from '../../shared/utilities/pathFind' +import { ToolkitError } from '../../shared/errors' +import { showConfirmationMessage, showMessage } from '../../shared/utilities/messages' +import { telemetry } from '../../shared/telemetry/telemetry' +import * as nls from 'vscode-nls' +import { getRemoteDebugLayer } from './ldkLayers' +import path from 'path' +import { glob } from 'glob' +import { Commands } from '../../shared/vscode/commands2' + +const localize = nls.loadMessageBundle() +const logger = getLogger() +export const remoteDebugContextString = 'aws.lambda.remoteDebugContext' +export const remoteDebugSnapshotString = 'aws.lambda.remoteDebugSnapshot' + +// Map debug types to their corresponding VS Code extension IDs +const mapDebugTypeToExtensionId = new Map([ + ['python', ['ms-python.python']], + ['java', ['redhat.java', 'vscjava.vscode-java-debug']], + ['node', ['ms-vscode.js-debug']], +]) + +const mapExtensionToBackup = new Map([['ms-vscode.js-debug', 'ms-vscode.js-debug-nightly']]) + +export interface DebugConfig { + functionArn: string + functionName: string + port: number + localRoot: string + remoteRoot: string + skipFiles: string[] + shouldPublishVersion: boolean + lambdaRuntime?: string // Lambda runtime (e.g., nodejs18.x) + debuggerRuntime?: string // VS Code debugger runtime (e.g., node) + outFiles?: string[] + sourceMap?: boolean + justMyCode?: boolean + projectName?: string + otherDebugParams?: string + lambdaTimeout?: number + layerArn?: string + handlerFile?: string +} + +// Helper function to create a human-readable diff message +function createDiffMessage( + config: Lambda.FunctionConfiguration, + currentConfig: Lambda.FunctionConfiguration, + isRevert: boolean = true +): string { + let message = isRevert ? 'The following changes will be reverted:\n\n' : 'The following changes will be made:\n\n' + + message += + '1. Timeout: ' + + (currentConfig.Timeout || 'default') + + ' seconds → ' + + (config.Timeout || 'default') + + ' seconds\n' + + message += '2. Layers: ' + const hasLdkLayer = currentConfig.Layers?.some( + (layer) => layer.Arn?.includes('LDKLayerX86') || layer.Arn?.includes('LDKLayerArm64') + ) + + message += hasLdkLayer ? 'Remove LDK layer\n' : 'No Change\n' + + message += '3. Environment Variables: Remove AWS_LAMBDA_EXEC_WRAPPER and AWS_LDK_DESTINATION_TOKEN\n' + + return message +} + +/** + * Attempts to revert an existing debug configuration if one exists + * @returns true if revert was successful or no config exists, false if revert failed or user chose not to revert + */ +export async function revertExistingConfig(): Promise { + try { + // Check if a debug context exists from a previous session + const savedConfig = getLambdaSnapshot() + + if (!savedConfig) { + // No existing config to revert + return true + } + + // clear the snapshot for it's corrupted + if (!savedConfig.FunctionArn || !savedConfig.FunctionName) { + logger.error('Function ARN or Function Name is missing, cannot revert') + void (await persistLambdaSnapshot(undefined)) + return true + } + + // compare with current config + const currentConfig = await LdkClient.instance.getFunctionDetail(savedConfig.FunctionArn) + // could be permission issues, or user has deleted previous function, we should remove the snapshot + if (!currentConfig) { + logger.error('Failed to get current function state, cannot revert') + void (await persistLambdaSnapshot(undefined)) + return true + } + + if ( + currentConfig?.Timeout === savedConfig?.Timeout && + currentConfig?.Layers?.length === savedConfig?.Layers?.length + ) { + // No changes needed, remove the snapshot + void (await persistLambdaSnapshot(undefined)) + return true + } + + // Create a diff message to show what will be changed + const diffMessage = currentConfig + ? createDiffMessage(savedConfig, currentConfig, true) + : 'Failed to get current function state' + + const response = await showConfirmationMessage({ + prompt: localize( + 'AWS.lambda.remoteDebug.revertPreviousDeployment', + 'A previous debug deployment was detected for {0}. Would you like to revert those changes before proceeding?\n\n{1}', + savedConfig.FunctionName, + diffMessage + ), + confirm: localize('AWS.lambda.remoteDebug.revert', 'Revert'), + cancel: localize('AWS.lambda.remoteDebug.dontShowAgain', "Don't show again"), + type: 'warning', + }) + + if (!response) { + // User chose not to revert, remove the snapshot + void (await persistLambdaSnapshot(undefined)) + return true + } + + await LdkClient.instance.removeDebugDeployment(savedConfig, false) + await persistLambdaSnapshot(undefined) + void showMessage( + 'info', + localize( + 'AWS.lambda.remoteDebug.successfullyReverted', + 'Successfully reverted changes to {0}', + savedConfig.FunctionName + ) + ) + + return true + } catch (error) { + throw ToolkitError.chain(error, `Error in revertExistingConfig`) + } +} + +export async function activateRemoteDebugging(): Promise { + try { + globals.context.subscriptions.push( + Commands.register('aws.lambda.remoteDebugging.clearSnapshot', async () => { + void (await persistLambdaSnapshot(undefined)) + }) + ) + } catch (error) { + logger.error(`Error in registering clearSnapshot command:${error}`) + } + + try { + logger.info('Remote debugging is initiated') + + // Use the revertExistingConfig function to handle any existing debug configurations + await revertExistingConfig() + + // Initialize RemoteDebugController to ensure proper startup state + RemoteDebugController.instance.ensureCleanState() + } catch (error) { + // show warning + void vscode.window.showWarningMessage(`Error in activateRemoteDebugging: ${error}`) + logger.error(`Error in activateRemoteDebugging:${error}`) + } +} + +// this should be called when the debug session is started +async function persistLambdaSnapshot(config: Lambda.FunctionConfiguration | undefined): Promise { + try { + await globals.globalState.update(remoteDebugSnapshotString, config) + } catch (error) { + // TODO raise toolkit error + logger.error(`Error persisting debug sessions:${error}`) + } +} + +export function getLambdaSnapshot(): Lambda.FunctionConfiguration | undefined { + return globals.globalState.get(remoteDebugSnapshotString) +} + +/** + * Helper function to check if a string is a valid VSCode glob pattern + */ +function isVscodeGlob(pattern: string): boolean { + // Check for common glob patterns: *, **, ?, [], {} + return /[*?[\]{}]/.test(pattern) +} + +/** + * Helper function to validate source map files exist for given outFiles patterns + */ +async function validateSourceMapFiles(outFiles: string[]): Promise { + const allAreGlobs = outFiles.every((pattern) => isVscodeGlob(pattern)) + if (!allAreGlobs) { + return false + } + + try { + let jsfileCount = 0 + let mapfileCount = 0 + const jsFiles = await glob(outFiles, { ignore: 'node_modules/**' }) + + for (const file of jsFiles) { + if (file.includes('js')) { + jsfileCount += 1 + } + if (file.includes('.map')) { + mapfileCount += 1 + } + } + + return jsfileCount === 0 || mapfileCount === 0 ? false : true + } catch (error) { + getLogger().warn(`Error validating source map files: ${error}`) + return false + } +} + +function processOutFiles(outFiles: string[], localRoot: string): string[] { + const processedOutFiles: string[] = [] + + for (let outFile of outFiles) { + if (!outFile.includes('*')) { + // add * in the end + outFile = path.join(outFile, '*') + } + if (!path.isAbsolute(outFile)) { + // Find which workspace contains the localRoot path + const workspaceFolders = vscode.workspace.workspaceFolders + if (workspaceFolders) { + let matchingWorkspace: vscode.WorkspaceFolder | undefined + + // Check if localRoot is within any workspace + for (const workspace of workspaceFolders) { + const absoluteLocalRoot = path.resolve(localRoot) + const workspacePath = workspace.uri.fsPath + + if (absoluteLocalRoot.startsWith(workspacePath)) { + matchingWorkspace = workspace + break + } + } + + if (matchingWorkspace) { + // Join workspace folder with the relative outFile path + processedOutFiles.push(path.join(matchingWorkspace.uri.fsPath, outFile)) + } else { + // If no matching workspace found, use the original outFile + processedOutFiles.push(outFile) + } + } else { + // No workspace folders, use the original outFile + processedOutFiles.push(outFile) + } + } else { + // Already absolute path, use as is + processedOutFiles.push(outFile) + } + } + return processedOutFiles +} + +async function getVscodeDebugConfig( + functionConfig: Lambda.FunctionConfiguration, + debugConfig: DebugConfig +): Promise { + // Parse and validate otherDebugParams if provided + let additionalParams: Record = {} + if (debugConfig.otherDebugParams) { + try { + const parsed = JSON.parse(debugConfig.otherDebugParams) + if (typeof parsed === 'object' && !Array.isArray(parsed)) { + additionalParams = parsed + getLogger().info('Additional debug parameters parsed successfully: %O ', additionalParams) + } else { + void vscode.window.showWarningMessage( + localize( + 'AWS.lambda.remoteDebug.invalidDebugParams', + 'Other Debug Parameters must be a valid JSON object. The parameter will be ignored.' + ) + ) + getLogger().warn(`Invalid otherDebugParams format: expected object, got ${typeof parsed}`) + } + } catch (error) { + void vscode.window.showWarningMessage( + localize( + 'AWS.lambda.remoteDebug.failedToParseDebugParams', + 'Failed to parse Other Debug Parameters as JSON: {0}. The parameter will be ignored.', + error instanceof Error ? error.message : 'Invalid JSON' + ) + ) + getLogger().warn(`Failed to parse otherDebugParams as JSON: ${error}`) + } + } + + const debugSessionName = `Debug ${functionConfig.FunctionArn!.split(':').pop()}` + + // Define debugConfig before the try block + const debugType = mapFamilyToDebugType.get(getFamily(functionConfig.Runtime ?? ''), 'unknown') + let vsCodeDebugConfig: vscode.DebugConfiguration + switch (debugType) { + case 'node': + // source map support + if (debugConfig.sourceMap && debugConfig.outFiles) { + // process outFiles first, if they are relative path (not starting with /), + // check local root path is located in which workspace. Then join workspace Folder with outFiles + + // Update debugConfig with processed outFiles + debugConfig.outFiles = processOutFiles(debugConfig.outFiles, debugConfig.localRoot) + + // Use glob to search if there are any matching js file or source map file + const hasSourceMaps = await validateSourceMapFiles(debugConfig.outFiles) + + if (hasSourceMaps) { + // support mapping common sam cli location + additionalParams['sourceMapPathOverrides'] = { + ...additionalParams['sourceMapPathOverrides'], + '?:*/T/?:*/*': path.join(debugConfig.localRoot, '*'), + } + debugConfig.localRoot = debugConfig.outFiles[0].split('*')[0] + } else { + debugConfig.sourceMap = false + debugConfig.outFiles = undefined + await showMessage( + 'warn', + localize( + 'AWS.lambda.remoteDebug.outFileNotFound', + 'outFiles not valid or no js and map file found in outFiles, debug will continue without sourceMap support' + ) + ) + } + } + vsCodeDebugConfig = { + type: debugType, + request: 'attach', + name: debugSessionName, + address: 'localhost', + port: debugConfig.port, + localRoot: debugConfig.localRoot, + remoteRoot: debugConfig.remoteRoot, + skipFiles: debugConfig.skipFiles, + sourceMaps: debugConfig.sourceMap, + outFiles: debugConfig.outFiles, + continueOnAttach: debugConfig.outFiles ? false : true, + stopOnEntry: false, + timeout: 60000, + ...additionalParams, // Merge additional debug parameters + } + break + case 'python': + vsCodeDebugConfig = { + type: debugType, + request: 'attach', + name: debugSessionName, + port: debugConfig.port, + cwd: debugConfig.localRoot, + pathMappings: [ + { + localRoot: debugConfig.localRoot, + remoteRoot: debugConfig.remoteRoot, + }, + ], + justMyCode: debugConfig.justMyCode ?? true, + ...additionalParams, // Merge additional debug parameters + } + break + case 'java': + vsCodeDebugConfig = { + type: debugType, + request: 'attach', + name: debugSessionName, + hostName: 'localhost', + port: debugConfig.port, + sourcePaths: [debugConfig.localRoot], + projectName: debugConfig.projectName, + timeout: 60000, + ...additionalParams, // Merge additional debug parameters + } + break + default: + throw new ToolkitError(`Unsupported debug type: ${debugType}`) + } + getLogger().info('VS Code debug configuration: %O', vsCodeDebugConfig) + return vsCodeDebugConfig +} + +export class RemoteDebugController { + static #instance: RemoteDebugController + isDebugging: boolean = false + qualifier: string | undefined = undefined + private lastDebugStartTime: number = 0 + // private debugSession: DebugSession | undefined + private debugSessionDisposables: Map = new Map() + + public static get instance() { + if (this.#instance !== undefined) { + return this.#instance + } + + const self = (this.#instance = new this()) + return self + } + + constructor() {} + + /** + * Ensures the controller is in a clean state at startup or before a new operation + */ + public ensureCleanState(): void { + this.isDebugging = false + this.qualifier = undefined + + // Clean up any leftover disposables + for (const [key, disposable] of this.debugSessionDisposables.entries()) { + try { + disposable.dispose() + } catch (e) { + // Ignore errors during startup cleanup + } + this.debugSessionDisposables.delete(key) + } + } + + public supportCodeDownload(runtime: string | undefined): boolean { + if (!runtime) { + return false + } + try { + return ['node', 'python'].includes(mapFamilyToDebugType.get(getFamily(runtime)) ?? '') + } catch { + // deprecated runtime + return false + } + } + + public supportRuntimeRemoteDebug(runtime: string | undefined): boolean { + if (!runtime) { + return false + } + try { + return ['node', 'python', 'java'].includes(mapFamilyToDebugType.get(getFamily(runtime)) ?? '') + } catch { + return false + } + } + + public getRemoteDebugLayer( + region: string | undefined, + architectures: Lambda.ArchitecturesList | undefined + ): string | undefined { + if (!region || !architectures) { + return undefined + } + if (architectures.includes('x86_64')) { + return getRemoteDebugLayer(region, 'x86_64') + } + if (architectures.includes('arm64')) { + return getRemoteDebugLayer(region, 'arm64') + } + return undefined + } + + public async installDebugExtension(runtime: string | undefined): Promise { + if (!runtime) { + throw new ToolkitError('Runtime is undefined') + } + + const debugType = mapFamilyToDebugType.get(getFamily(runtime)) + if (!debugType) { + throw new ToolkitError(`Debug type is undefined for runtime ${runtime}`) + } + // Install needed debug extension based on runtime + const extensions = mapDebugTypeToExtensionId.get(debugType) + if (extensions) { + for (const extension of extensions) { + const extensionObj = vscode.extensions.getExtension(extension) + const backupExtensionObj = vscode.extensions.getExtension(mapExtensionToBackup.get(extension) ?? '') + + if (!extensionObj && !backupExtensionObj) { + // Extension is not installed, install it + const choice = await showConfirmationMessage({ + prompt: localize( + 'AWS.lambda.remoteDebug.extensionNotInstalled', + 'You need to install the {0} extension to debug {1} functions. Would you like to install it now?', + extension, + debugType + ), + confirm: localize('AWS.lambda.remoteDebug.install', 'Install'), + cancel: localize('AWS.lambda.remoteDebug.cancel', 'Cancel'), + type: 'warning', + }) + if (!choice) { + return false + } + await vscode.commands.executeCommand('workbench.extensions.installExtension', extension) + if (vscode.extensions.getExtension(extension) === undefined) { + return false + } + } + } + } + + if (debugType === 'java' && !(await findJavaPath())) { + // jvm not available + const choice = await showConfirmationMessage({ + prompt: localize( + 'AWS.lambda.remoteDebug.jvmNotInstalled', + 'You need to install a JVM to debug Java functions. Would you like to install it now?' + ), + confirm: localize('AWS.lambda.remoteDebug.install', 'Install'), + cancel: localize('AWS.lambda.remoteDebug.continueAnyway', 'Continue Anyway'), + type: 'warning', + }) + // open https://developers.redhat.com/products/openjdk/download + if (choice) { + await vscode.env.openExternal( + vscode.Uri.parse('https://developers.redhat.com/products/openjdk/download') + ) + return false + } + } + // passed all checks + return true + } + + public async startDebugging(functionArn: string, runtime: string, debugConfig: DebugConfig): Promise { + if (this.isDebugging) { + getLogger().error('Debug already in progress, remove debug setup to restart') + return + } + + await telemetry.lambda_remoteDebugStart.run(async (span) => { + // Create a copy of debugConfig without functionName and functionArn for telemetry + const debugConfigForTelemetry: Partial = { ...debugConfig } + debugConfigForTelemetry.functionName = undefined + debugConfigForTelemetry.functionArn = undefined + debugConfigForTelemetry.localRoot = undefined + + span.record({ + source: 'remoteDebug', + passive: false, + action: JSON.stringify(debugConfigForTelemetry), + }) + this.lastDebugStartTime = Date.now() + await vscode.window.withProgress( + { + location: vscode.ProgressLocation.Notification, + title: 'Setting up debug session', + cancellable: false, + }, + async (progress) => { + // Reset state before starting + this.ensureCleanState() + + getLogger().info(`Starting debugger for ${functionArn}`) + + const region = getRegionFromArn(functionArn) + if (!region) { + throw new ToolkitError('Could not determine region from Lambda ARN') + } + + // Check if runtime / region is supported for remote debugging + if (!this.supportRuntimeRemoteDebug(runtime)) { + throw new ToolkitError( + `Runtime ${runtime} is not supported for remote debugging. ` + + `Only Python, Node.js, and Java runtimes are supported.` + ) + } + + // Check if a snapshot already exists and revert if needed + // Use the revertExistingConfig function from ldkController + progress.report({ message: 'Checking if snapshot exists...' }) + const revertResult = await revertExistingConfig() + + // If revert failed and user didn't choose to ignore, abort the deployment + if (revertResult === false) { + return + } + try { + // Anything fails before this point doesn't requires reverting + this.isDebugging = true + + // the following will contain changes that requires reverting. + // Create a snapshot of lambda config before debug + // let's preserve this config to a global variable at here + // we will use this config to revert the changes back to it once was, once confirm it's success, update the global to undefined + // if somehow the changes failed to revert, in init phase(activate remote debugging), we will detect this config and prompt user to revert the changes + const ldkClient = LdkClient.instance + // get function config again in case anything changed + const functionConfig = await LdkClient.instance.getFunctionDetail(functionArn) + if (!functionConfig?.Runtime || !functionConfig?.FunctionArn) { + throw new ToolkitError('Could not retrieve Lambda function configuration') + } + await persistLambdaSnapshot(functionConfig) + + // Record runtime in telemetry + span.record({ + runtimeString: functionConfig.Runtime as any, + }) + + // Create or reuse tunnel + progress.report({ message: 'Creating secure tunnel...' }) + getLogger().info('Creating secure tunnel...') + const tunnelInfo = await ldkClient.createOrReuseTunnel(region) + if (!tunnelInfo) { + throw new ToolkitError(`Empty tunnel info response, please retry:${tunnelInfo}`) + } + + if (!isTunnelInfo(tunnelInfo)) { + throw new ToolkitError(`Invalid tunnel info response:${tunnelInfo}`) + } + // start update lambda funcion, await in the end + // Create debug deployment + progress.report({ message: 'Configuring Lambda function for debugging...' }) + getLogger().info('Configuring Lambda function for debugging...') + + const layerArn = + debugConfig.layerArn ?? this.getRemoteDebugLayer(region, functionConfig.Architectures) + if (!layerArn) { + throw new ToolkitError(`No Layer Arn is provided`) + } + // start this request and await in the end + const debugDeployPromise = ldkClient.createDebugDeployment( + functionConfig, + tunnelInfo.destinationToken, + debugConfig.lambdaTimeout ?? 900, + debugConfig.shouldPublishVersion, + layerArn, + progress + ) + + const vscodeDebugConfig = await getVscodeDebugConfig(functionConfig, debugConfig) + // show every field in debugConfig + // getLogger().info(`Debug configuration created successfully ${JSON.stringify(debugConfig)}`) + + // Start local proxy with timeout and better error handling + progress.report({ message: 'Starting local proxy...' }) + + const proxyStartTimeout = new Promise((_, reject) => { + setTimeout(() => reject(new Error('Local proxy start timed out')), 30000) + }) + + const proxyStartAttempt = ldkClient.startProxy(region, tunnelInfo.sourceToken, debugConfig.port) + + const proxyStarted = await Promise.race([proxyStartAttempt, proxyStartTimeout]) + + if (!proxyStarted) { + throw new ToolkitError('Failed to start local proxy') + } + getLogger().info('Local proxy started successfully') + progress.report({ message: 'Starting debugger...' }) + // Start debugging in a non-blocking way + void Promise.resolve(vscode.debug.startDebugging(undefined, vscodeDebugConfig)).then( + async (debugStarted) => { + if (!debugStarted) { + // this could be triggered by another stop debugging, let's check state before stopping. + throw new ToolkitError('Failed to start debug session') + } + } + ) + + const debugSessionEndDisposable = vscode.debug.onDidTerminateDebugSession(async (session) => { + if (session.name === vscodeDebugConfig.name) { + void (await this.stopDebugging()) + } + }) + + // wait until lambda function update is completed + progress.report({ message: 'Waiting for function update...' }) + const qualifier = await debugDeployPromise + if (!qualifier || qualifier === 'Failed') { + throw new ToolkitError('Failed to configure Lambda function for debugging') + } + // store the published version for debugging in version + if (debugConfig.shouldPublishVersion) { + // we already reverted + this.qualifier = qualifier + } + + // Store the disposable + this.debugSessionDisposables.set(functionConfig.FunctionArn, debugSessionEndDisposable) + progress.report({ + message: `Debug session setup completed for ${functionConfig.FunctionArn.split(':').pop()}`, + }) + } catch (error) { + try { + await this.stopDebugging() + } catch (errStop) { + getLogger().error( + 'encountered following error when stoping debug for failed debug session:' + ) + getLogger().error(errStop as Error) + } + + throw ToolkitError.chain(error, 'Error StartDebugging') + } + } + ) + }) + } + + public async stopDebugging(): Promise { + await telemetry.lambda_remoteDebugStop.run(async (span) => { + if (!this.isDebugging) { + void showMessage( + 'info', + localize('AWS.lambda.remoteDebug.debugNotInProgress', 'Debug is not in progress') + ) + return + } + span.record({ duration: this.lastDebugStartTime === 0 ? 0 : Date.now() - this.lastDebugStartTime }) + try { + await vscode.window.withProgress( + { + location: vscode.ProgressLocation.Notification, + title: 'Stopping debug session', + cancellable: false, + }, + async (progress) => { + progress.report({ message: 'Stopping debugging...' }) + const ldkClient = LdkClient.instance + + // First attempt to clean up resources from Lambda + const savedConfig = getLambdaSnapshot() + if (!savedConfig?.FunctionArn) { + getLogger().error('No saved configuration found during cleanup') + throw new ToolkitError('No saved configuration found during cleanup') + } + + const disposable = this.debugSessionDisposables.get(savedConfig.FunctionArn) + if (disposable) { + disposable.dispose() + this.debugSessionDisposables.delete(savedConfig.FunctionArn) + } + getLogger().info(`Removing debug deployment for function: ${savedConfig.FunctionName}`) + + await vscode.commands.executeCommand('workbench.action.debug.stop') + // Then stop the proxy (with more reliable error handling) + getLogger().info('Stopping proxy during cleanup') + await ldkClient.stopProxy() + // Ensure our resources are properly cleaned up + if (this.qualifier) { + await ldkClient.deleteDebugVersion(savedConfig.FunctionArn, this.qualifier) + } + if (await ldkClient.removeDebugDeployment(savedConfig, true)) { + await persistLambdaSnapshot(undefined) + } + + progress.report({ message: `Debug session stopped` }) + } + ) + void showMessage( + 'info', + localize('AWS.lambda.remoteDebug.debugSessionStopped', 'Debug session stopped') + ) + } catch (error) { + throw ToolkitError.chain(error, 'error when stopping remote debug') + } finally { + this.isDebugging = false + } + }) + } +} diff --git a/packages/core/src/lambda/remoteDebugging/ldkLayers.ts b/packages/core/src/lambda/remoteDebugging/ldkLayers.ts new file mode 100644 index 00000000000..5573a84f980 --- /dev/null +++ b/packages/core/src/lambda/remoteDebugging/ldkLayers.ts @@ -0,0 +1,46 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +interface RegionAccountMapping { + [region: string]: string +} + +// Map region to account ID +export const regionToAccount: RegionAccountMapping = { + 'us-east-1': '166855510987', + 'ap-northeast-1': '435951944084', + 'us-west-1': '397974708477', + 'us-west-2': '116489046076', + 'us-east-2': '372632330791', + 'ca-central-1': '816313119386', + 'eu-west-1': '020236748984', + 'eu-west-2': '199003954714', + 'eu-west-3': '490913546906', + 'eu-central-1': '944487268028', + 'eu-north-1': '351516301086', + 'ap-southeast-1': '812073016575', + 'ap-southeast-2': '185226997092', + 'ap-northeast-2': '241511115815', + 'ap-south-1': '926022987530', + 'sa-east-1': '313162186107', + 'ap-east-1': '416298298123', + 'me-south-1': '511027370648', + 'me-central-1': '766358817862', +} + +// Global layer version +const globalLayerVersion = 1 + +export function getRemoteDebugLayer(region: string, arch: string): string | undefined { + const account = regionToAccount[region] + + if (!account) { + return undefined + } + + const layerName = arch === 'x86_64' ? 'LDKLayerX86' : 'LDKLayerArm64' + + return `arn:aws:lambda:${region}:${account}:layer:${layerName}:${globalLayerVersion}` +} diff --git a/packages/core/src/lambda/remoteDebugging/localProxy.ts b/packages/core/src/lambda/remoteDebugging/localProxy.ts new file mode 100644 index 00000000000..8b228deeb1a --- /dev/null +++ b/packages/core/src/lambda/remoteDebugging/localProxy.ts @@ -0,0 +1,901 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import * as net from 'net' +import WebSocket from 'ws' +import * as crypto from 'crypto' +import { getLogger } from '../../shared/logger/logger' +import { v4 as uuidv4 } from 'uuid' +import * as protobuf from 'protobufjs' + +const logger = getLogger() + +// Define the message types from the protocol +enum MessageType { + UNKNOWN = 0, + DATA = 1, + STREAM_START = 2, + STREAM_RESET = 3, + SESSION_RESET = 4, + SERVICE_IDS = 5, + CONNECTION_START = 6, + CONNECTION_RESET = 7, +} + +// Interface for tunnel info +export interface TunnelInfo { + tunnelId: string + sourceToken: string + destinationToken: string +} + +// Interface for TCP connection +interface TcpConnection { + socket: net.Socket + streamId: number + connectionId: number +} + +/** + * LocalProxy class that handles WebSocket connection to IoT secure tunneling + * and sets up a TCP adapter as a local proxy + */ +export class LocalProxy { + private ws: WebSocket.WebSocket | undefined = undefined + private tcpServer: net.Server | undefined = undefined + private tcpConnections: Map = new Map() + private isConnected: boolean = false + private reconnectAttempts: number = 0 + private maxReconnectAttempts: number = 10 + private reconnectInterval: number = 2500 // 2.5 seconds + private pingInterval: NodeJS.Timeout | undefined = undefined + private serviceId: string = 'WSS' + private currentStreamId: number = 1 + private nextConnectionId: number = 1 + private localPort: number = 0 + private region: string = '' + private accessToken: string = '' + private Message: protobuf.Type | undefined = undefined + private clientToken: string = '' + private eventHandlers: { [key: string]: any[] } = {} + private isDisposed: boolean = false + + constructor() { + void this.loadProtobufDefinition() + } + + // Define the protobuf schema as a string constant + private static readonly protobufSchema = ` + syntax = "proto3"; + + package com.amazonaws.iot.securedtunneling; + + message Message { + Type type = 1; + int32 streamId = 2; + bool ignorable = 3; + bytes payload = 4; + string serviceId = 5; + repeated string availableServiceIds = 6; + uint32 connectionId = 7; + + enum Type { + UNKNOWN = 0; + DATA = 1; + STREAM_START = 2; + STREAM_RESET = 3; + SESSION_RESET = 4; + SERVICE_IDS = 5; + CONNECTION_START = 6; + CONNECTION_RESET = 7; + } + }` + + /** + * Load the protobuf definition from the embedded schema string + */ + private async loadProtobufDefinition(): Promise { + try { + if (this.Message) { + // Already loaded, don't parse again + return + } + + const root = protobuf.parse(LocalProxy.protobufSchema).root + this.Message = root.lookupType('com.amazonaws.iot.securedtunneling.Message') + + if (!this.Message) { + throw new Error('Failed to load Message type from protobuf definition') + } + + logger.debug('Protobuf definition loaded successfully') + } catch (error) { + logger.error(`Error loading protobuf definition:${error}`) + throw error + } + } + + /** + * Start the local proxy + * @param region AWS region + * @param sourceToken Source token for the tunnel + * @param port Local port to listen on + */ + public async start(region: string, sourceToken: string, port: number = 0): Promise { + // Reset disposal state when starting + this.isDisposed = false + + this.region = region + this.accessToken = sourceToken + + try { + // Start TCP server first + this.localPort = await this.startTcpServer(port) + + // Then connect to WebSocket + await this.connectWebSocket() + + return this.localPort + } catch (error) { + logger.error(`Failed to start local proxy:${error}`) + this.stop() + throw error + } + } + + /** + * Stop the local proxy and clean up all resources + */ + public stop(): void { + if (this.isDisposed) { + logger.debug('LocalProxy already stopped, skipping duplicate stop call') + return + } + + logger.debug('Stopping LocalProxy and cleaning up resources') + + // Cancel any pending reconnect timeouts + if (this.eventHandlers['reconnectTimeouts']) { + for (const timeoutId of this.eventHandlers['reconnectTimeouts']) { + clearTimeout(timeoutId as NodeJS.Timeout) + } + } + + this.stopPingInterval() + this.closeWebSocket() + this.closeTcpServer() + + // Reset all state + this.clientToken = '' + this.isConnected = false + this.reconnectAttempts = 0 + this.currentStreamId = 1 + this.nextConnectionId = 1 + this.localPort = 0 + this.region = '' + this.accessToken = '' + + // Mark as disposed to prevent duplicate stop calls + this.isDisposed = true + + // Clear any remaining event handlers reference + this.eventHandlers = {} + } + + /** + * Start the TCP server + * @param port Port to listen on (0 for random port) + * @returns The port the server is listening on + */ + private startTcpServer(port: number): Promise { + return new Promise((resolve, reject) => { + try { + this.tcpServer = net.createServer((socket) => { + this.handleNewTcpConnection(socket) + }) + + this.tcpServer.on('error', (err) => { + logger.error(`TCP server error:${err}`) + }) + + this.tcpServer.listen(port, '127.0.0.1', () => { + const address = this.tcpServer?.address() as net.AddressInfo + this.localPort = address.port + logger.debug(`TCP server listening on port ${this.localPort}`) + resolve(this.localPort) + }) + } catch (error) { + logger.error(`Failed to start TCP server:${error}`) + reject(error) + } + }) + } + + /** + * Close the TCP server and all connections + */ + private closeTcpServer(): void { + if (this.tcpServer) { + logger.debug('Closing TCP server and connections') + + // Remove all listeners from the server + this.tcpServer.removeAllListeners('error') + this.tcpServer.removeAllListeners('connection') + this.tcpServer.removeAllListeners('listening') + + // Close all TCP connections with proper error handling + for (const connection of this.tcpConnections.values()) { + try { + // Remove all listeners before destroying + connection.socket.removeAllListeners('data') + connection.socket.removeAllListeners('error') + connection.socket.removeAllListeners('close') + connection.socket.destroy() + } catch (err) { + logger.error(`Error closing TCP connection: ${err}`) + } + } + this.tcpConnections.clear() + + // Close the server with proper error handling and timeout + try { + // Set a timeout in case server.close() hangs + const serverCloseTimeout = setTimeout(() => { + logger.warn('TCP server close timed out, forcing closure') + this.tcpServer = undefined + }, 5000) + + this.tcpServer.close(() => { + clearTimeout(serverCloseTimeout) + logger.debug('TCP server closed successfully') + this.tcpServer = undefined + }) + } catch (err) { + logger.error(`Error closing TCP server: ${err}`) + this.tcpServer = undefined + } + } + } + + /** + * Handle a new TCP connection with proper resource management + * @param socket The TCP socket + */ + private handleNewTcpConnection(socket: net.Socket): void { + if (!this.isConnected || this.isDisposed) { + logger.warn('WebSocket not connected or proxy disposed, rejecting TCP connection') + socket.destroy() + return + } + + const connectionId = this.nextConnectionId++ + const streamId = this.currentStreamId + + logger.debug(`New TCP connection: ${connectionId}`) + + // Track event handlers for this connection + const handlers: { [event: string]: (...args: any[]) => void } = {} + + // Data handler + const dataHandler = (data: Buffer) => { + this.sendData(streamId, connectionId, data) + } + socket.on('data', dataHandler) + handlers.data = dataHandler + + // Error handler + const errorHandler = (err: Error) => { + logger.error(`TCP connection ${connectionId} error: ${err}`) + this.sendConnectionReset(streamId, connectionId) + + // Cleanup handlers on error + this.cleanupSocketHandlers(socket, handlers) + } + socket.on('error', errorHandler) + handlers.error = errorHandler + + // Close handler + const closeHandler = () => { + logger.debug(`TCP connection ${connectionId} closed`) + + // Remove from connections map and send reset + this.tcpConnections.delete(connectionId) + this.sendConnectionReset(streamId, connectionId) + + // Cleanup handlers on close + this.cleanupSocketHandlers(socket, handlers) + } + socket.on('close', closeHandler) + handlers.close = closeHandler + + // Set a timeout to close idle connections after 10 minutes + const idleTimeout = setTimeout( + () => { + if (this.tcpConnections.has(connectionId)) { + logger.debug(`Closing idle TCP connection ${connectionId}`) + socket.destroy() + } + }, + 10 * 60 * 1000 + ) + + // Clear timeout on socket close + socket.once('close', () => { + clearTimeout(idleTimeout) + }) + + // Store the connection + const connection: TcpConnection = { + socket, + streamId, + connectionId, + } + this.tcpConnections.set(connectionId, connection) + + // Send StreamStart for the first connection, ConnectionStart for subsequent ones + if (connectionId === 1) { + this.sendStreamStart(streamId, connectionId) + } else { + this.sendConnectionStart(streamId, connectionId) + } + } + + /** + * Helper method to clean up socket event handlers + * @param socket The socket to clean up + * @param handlers The handlers to remove + */ + private cleanupSocketHandlers(socket: net.Socket, handlers: { [event: string]: (...args: any[]) => void }): void { + try { + if (handlers.data) { + socket.removeListener('data', handlers.data as (...args: any[]) => void) + } + if (handlers.error) { + socket.removeListener('error', handlers.error as (...args: any[]) => void) + } + if (handlers.close) { + socket.removeListener('close', handlers.close as (...args: any[]) => void) + } + } catch (error) { + logger.error(`Error cleaning up socket handlers: ${error}`) + } + } + + /** + * Connect to the WebSocket server with proper event tracking + */ + private async connectWebSocket(): Promise { + if (this.ws) { + this.closeWebSocket() + } + + // Reset for new connection + this.isDisposed = false + + return new Promise((resolve, reject) => { + try { + const url = `wss://data.tunneling.iot.${this.region}.amazonaws.com:443/tunnel?local-proxy-mode=source` + + if (!this.clientToken) { + this.clientToken = uuidv4().replace(/-/g, '') + } + + this.ws = new WebSocket.WebSocket(url, ['aws.iot.securetunneling-3.0'], { + headers: { + 'access-token': this.accessToken, + 'client-token': this.clientToken, + }, + handshakeTimeout: 30000, // 30 seconds + }) + + // Track event listeners for proper cleanup + this.eventHandlers['wsOpen'] = [] + this.eventHandlers['wsMessage'] = [] + this.eventHandlers['wsClose'] = [] + this.eventHandlers['wsError'] = [] + this.eventHandlers['wsPing'] = [] + this.eventHandlers['wsPong'] = [] + + // Open handler + const openHandler = () => { + logger.debug('WebSocket connected') + this.isConnected = true + this.reconnectAttempts = 0 + this.startPingInterval() + resolve() + } + this.ws.on('open', openHandler) + this.eventHandlers['wsOpen'].push(openHandler) + + // Message handler + const messageHandler = (data: WebSocket.RawData) => { + this.handleWebSocketMessage(data) + } + this.ws.on('message', messageHandler) + this.eventHandlers['wsMessage'].push(messageHandler) + + // Close handler + const closeHandler = (code: number, reason: Buffer) => { + logger.debug(`WebSocket closed: ${code} ${reason.toString()}`) + this.isConnected = false + this.stopPingInterval() + + // Only attempt reconnect if we haven't explicitly stopped + if (!this.isDisposed) { + void this.attemptReconnect() + } + } + this.ws.on('close', closeHandler) + this.eventHandlers['wsClose'].push(closeHandler) + + // Error handler + const errorHandler = (err: Error) => { + logger.error(`WebSocket error: ${err}`) + reject(err) + } + this.ws.on('error', errorHandler) + this.eventHandlers['wsError'].push(errorHandler) + + // Ping handler + const pingHandler = (data: Buffer) => { + // Respond to ping with pong + if (this.ws && this.ws.readyState === WebSocket.OPEN) { + this.ws.pong(data) + } + } + this.ws.on('ping', pingHandler) + this.eventHandlers['wsPing'].push(pingHandler) + + // Pong handler + const pongHandler = () => { + logger.debug('Received pong') + } + this.ws.on('pong', pongHandler) + this.eventHandlers['wsPong'].push(pongHandler) + + // Set connection timeout + const connectionTimeout = setTimeout(() => { + if (this.ws && this.ws.readyState !== WebSocket.OPEN) { + logger.error('WebSocket connection timed out') + this.closeWebSocket() + reject(new Error('WebSocket connection timed out')) + } + }, 35000) // 35 seconds (slightly longer than handshake timeout) + + // Add a handler to clear the timeout on successful connection + this.ws.once('open', () => { + clearTimeout(connectionTimeout) + }) + } catch (error) { + logger.error(`Failed to connect WebSocket: ${error}`) + this.isConnected = false + reject(error) + } + }) + } + + /** + * Close the WebSocket connection with proper cleanup + */ + private closeWebSocket(): void { + if (this.ws) { + try { + logger.debug('Closing WebSocket connection') + + // Remove all event listeners before closing + this.ws.removeAllListeners('open') + this.ws.removeAllListeners('message') + this.ws.removeAllListeners('close') + this.ws.removeAllListeners('error') + this.ws.removeAllListeners('ping') + this.ws.removeAllListeners('pong') + + // Try to close gracefully first + if (this.ws.readyState === WebSocket.OPEN) { + // Set timeout in case close hangs + const closeTimeout = setTimeout(() => { + logger.warn('WebSocket close timed out, forcing termination') + if (this.ws) { + try { + this.ws.terminate() + } catch (e) { + // Ignore errors on terminate after timeout + } + this.ws = undefined + } + }, 1000) + + // Try graceful closure first + this.ws.close(1000, 'Normal Closure') + + // Set up a handler to clear the timeout if close works normally + this.ws.once('close', () => { + clearTimeout(closeTimeout) + }) + } else { + // If not open, just terminate + this.ws.terminate() + } + } catch (error) { + logger.error(`Error closing WebSocket: ${error}`) + } finally { + this.ws = undefined + } + } + } + + /** + * Start the ping interval to keep the connection alive + */ + private startPingInterval(): void { + this.stopPingInterval() + + // Send ping every 30 seconds to keep the connection alive + this.pingInterval = setInterval(() => { + if (this.ws && this.ws.readyState === WebSocket.OPEN) { + logger.debug('Sending ping') + try { + this.ws.ping(crypto.randomBytes(16)) + } catch (error) { + logger.error(`Error sending ping: ${error}`) + } + } else { + // If websocket is no longer open, stop the interval + this.stopPingInterval() + } + }, 30000) + } + + /** + * Stop the ping interval with better error handling + */ + private stopPingInterval(): void { + try { + if (this.pingInterval) { + clearInterval(this.pingInterval) + this.pingInterval = undefined + logger.debug('Ping interval stopped') + } + } catch (error) { + logger.error(`Error stopping ping interval: ${error}`) + this.pingInterval = undefined + } + } + + /** + * Attempt to reconnect to the WebSocket server with better resource management + */ + private async attemptReconnect(): Promise { + if (this.isDisposed) { + logger.debug('LocalProxy is disposed, not attempting reconnect') + return + } + + if (!this.clientToken) { + logger.debug('stop retrying, ws closed manually') + return + } + + if (this.reconnectAttempts >= this.maxReconnectAttempts) { + logger.error('Max reconnect attempts reached') + // Clean up resources when max attempts reached + this.stop() + return + } + + this.reconnectAttempts++ + const delay = this.reconnectInterval * Math.pow(1.5, this.reconnectAttempts - 1) + + logger.debug(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`) + + // Use a tracked timeout that we can clear if needed + const reconnectTimeoutId = setTimeout(() => { + if (!this.isDisposed) { + void this.connectWebSocket().catch((err) => { + logger.error(`Reconnect failed: ${err}`) + }) + } else { + logger.debug('Reconnect cancelled because LocalProxy was disposed') + } + }, delay) + + // Store the timeout ID so it can be cleared if stop() is called + if (!this.eventHandlers['reconnectTimeouts']) { + this.eventHandlers['reconnectTimeouts'] = [] + } + this.eventHandlers['reconnectTimeouts'].push(reconnectTimeoutId) + } + + /** + * Handle a WebSocket message + * @param data The message data + */ + private handleWebSocketMessage(data: WebSocket.RawData): void { + try { + // Handle binary data + if (Buffer.isBuffer(data)) { + let offset = 0 + + // Process all messages in the buffer + while (offset < data.length) { + // Read the 2-byte length prefix + if (offset + 2 > data.length) { + logger.error('Incomplete message length prefix') + break + } + + const messageLength = data.readUInt16BE(offset) + offset += 2 + + // Check if we have the complete message + if (offset + messageLength > data.length) { + logger.error('Incomplete message data') + break + } + + // Extract the message data + const messageData = data.slice(offset, offset + messageLength) + offset += messageLength + + // Decode and process the message + this.processMessage(messageData) + } + } else { + logger.warn('Received non-buffer WebSocket message') + } + } catch (error) { + logger.error(`Error handling WebSocket message:${error}`) + } + } + + /** + * Process a decoded message + * @param messageData The message data + */ + private processMessage(messageData: Buffer): void { + try { + if (!this.Message) { + logger.error('Protobuf Message type not loaded') + return + } + + // Decode the message + const message = this.Message.decode(messageData) + + // Process based on message type + const typedMessage = message as any + switch (typedMessage.type) { + case MessageType.DATA: + this.handleDataMessage(message) + break + + case MessageType.STREAM_RESET: + this.handleStreamReset(message) + break + + case MessageType.CONNECTION_RESET: + this.handleConnectionReset(message) + break + + case MessageType.SESSION_RESET: + this.handleSessionReset() + break + + case MessageType.SERVICE_IDS: + this.handleServiceIds(message) + break + + default: + logger.debug(`Received message of type ${typedMessage.type}`) + break + } + } catch (error) { + logger.error(`Error processing message:${error}`) + } + } + + /** + * Handle a DATA message + * @param message The message + */ + private handleDataMessage(message: any): void { + const { streamId, connectionId, payload } = message + + // Validate stream ID + if (streamId !== this.currentStreamId) { + logger.warn(`Received data for invalid stream ID: ${streamId}, current: ${this.currentStreamId}`) + return + } + + // Find the connection + const connection = this.tcpConnections.get(connectionId || 1) + if (!connection) { + logger.warn(`Received data for unknown connection ID: ${connectionId}`) + return + } + + logger.debug(`Received data for connection ${connectionId} in stream ${streamId}`) + + // Write data to the TCP socket + if (connection.socket.writable) { + connection.socket.write(Buffer.from(payload)) + } + } + + /** + * Handle a STREAM_RESET message + * @param message The message + */ + private handleStreamReset(message: any): void { + const { streamId } = message + + logger.debug(`Received STREAM_RESET for stream ${streamId}`) + + // Close all connections for this stream + for (const [connectionId, connection] of this.tcpConnections.entries()) { + if (connection.streamId === streamId) { + connection.socket.destroy() + this.tcpConnections.delete(connectionId) + } + } + } + + /** + * Handle a CONNECTION_RESET message + * @param message The message + */ + private handleConnectionReset(message: any): void { + const { streamId, connectionId } = message + + logger.debug(`Received CONNECTION_RESET for connection ${connectionId} in stream ${streamId}`) + + // Close the specific connection + const connection = this.tcpConnections.get(connectionId) + if (connection) { + connection.socket.destroy() + this.tcpConnections.delete(connectionId) + } + } + + /** + * Handle a SESSION_RESET message + */ + private handleSessionReset(): void { + logger.debug('Received SESSION_RESET') + + // Close all connections + for (const connection of this.tcpConnections.values()) { + connection.socket.destroy() + } + this.tcpConnections.clear() + + // Increment stream ID for new connections + this.currentStreamId++ + } + + /** + * Handle a SERVICE_IDS message + * @param message The message + */ + private handleServiceIds(message: any): void { + const { availableServiceIds } = message + + logger.debug(`Received SERVICE_IDS: ${availableServiceIds}`) + + // Validate service IDs + if (Array.isArray(availableServiceIds) && availableServiceIds.length > 0) { + // Use the first service ID + this.serviceId = availableServiceIds[0] + } + } + + /** + * Send a message over the WebSocket + * @param messageType The message type + * @param streamId The stream ID + * @param connectionId The connection ID + * @param payload The payload + */ + private sendMessage(messageType: MessageType, streamId: number, connectionId: number, payload?: Buffer): void { + if (!this.ws || this.ws.readyState !== WebSocket.OPEN) { + logger.warn('WebSocket not connected, cannot send message') + return + } + + if (!this.Message) { + logger.error('Protobuf Message type not loaded') + return + } + + try { + // Create the message + const message = { + type: messageType, + streamId, + connectionId, + serviceId: this.serviceId, + } + + // Add payload if provided + const typedMessage: any = message + if (payload) { + typedMessage.payload = payload + } + + // Verify and encode the message + const err = this.Message.verify(message) + if (err) { + throw new Error(`Invalid message: ${err}`) + } + + const encodedMessage = this.Message.encode(this.Message.create(message)).finish() + + // Create the frame with 2-byte length prefix + const frameLength = encodedMessage.length + const frame = Buffer.alloc(2 + frameLength) + + // Write the length prefix + frame.writeUInt16BE(frameLength, 0) + + // Copy the encoded message + Buffer.from(encodedMessage).copy(frame, 2) + + // Send the frame + if (this.ws?.readyState === WebSocket.OPEN) { + this.ws.send(frame) + } else { + logger.warn('WebSocket connection lost before sending message') + } + } catch (error) { + logger.error(`Error sending message: ${error}`) + } + } + + /** + * Send a STREAM_START message + * @param streamId The stream ID + * @param connectionId The connection ID + */ + private sendStreamStart(streamId: number, connectionId: number): void { + logger.debug(`Sending STREAM_START for stream ${streamId}, connection ${connectionId}`) + this.sendMessage(MessageType.STREAM_START, streamId, connectionId) + } + + /** + * Send a CONNECTION_START message + * @param streamId The stream ID + * @param connectionId The connection ID + */ + private sendConnectionStart(streamId: number, connectionId: number): void { + logger.debug(`Sending CONNECTION_START for stream ${streamId}, connection ${connectionId}`) + this.sendMessage(MessageType.CONNECTION_START, streamId, connectionId) + } + + /** + * Send a CONNECTION_RESET message + * @param streamId The stream ID + * @param connectionId The connection ID + */ + private sendConnectionReset(streamId: number, connectionId: number): void { + logger.debug(`Sending CONNECTION_RESET for stream ${streamId}, connection ${connectionId}`) + this.sendMessage(MessageType.CONNECTION_RESET, streamId, connectionId) + } + + /** + * Send data over the WebSocket + * @param streamId The stream ID + * @param connectionId The connection ID + * @param data The data to send + */ + private sendData(streamId: number, connectionId: number, data: Buffer): void { + // Split data into chunks if it exceeds the maximum payload size (63kb) + const maxChunkSize = 63 * 1024 // 63kb + + for (let offset = 0; offset < data.length; offset += maxChunkSize) { + const chunk = data.slice(offset, offset + maxChunkSize) + this.sendMessage(MessageType.DATA, streamId, connectionId, chunk) + } + } +} diff --git a/packages/core/src/lambda/remoteDebugging/utils.ts b/packages/core/src/lambda/remoteDebugging/utils.ts new file mode 100644 index 00000000000..6f7256f9f61 --- /dev/null +++ b/packages/core/src/lambda/remoteDebugging/utils.ts @@ -0,0 +1,27 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import IoTSecureTunneling from 'aws-sdk/clients/iotsecuretunneling' +import { DefaultLambdaClient } from '../../shared/clients/lambdaClient' +import { getUserAgent } from '../../shared/telemetry/util' +import globals from '../../shared/extensionGlobals' + +const customUserAgentBase = 'LAMBDA-DEBUG/1.0.0' + +export function getLambdaClientWithAgent(region: string): DefaultLambdaClient { + const customUserAgent = `${customUserAgentBase} ${getUserAgent({ includePlatform: true, includeClientId: true })}` + return new DefaultLambdaClient(region, customUserAgent) +} + +export function getIoTSTClientWithAgent(region: string): Promise { + const customUserAgent = `${customUserAgentBase} ${getUserAgent({ includePlatform: true, includeClientId: true })}` + return globals.sdkClientBuilder.createAwsService( + IoTSecureTunneling, + { + customUserAgent, + }, + region + ) +} diff --git a/packages/core/src/lambda/vue/remoteInvoke/invokeLambda.ts b/packages/core/src/lambda/vue/remoteInvoke/invokeLambda.ts index aafde327d7f..9e027bde2bc 100644 --- a/packages/core/src/lambda/vue/remoteInvoke/invokeLambda.ts +++ b/packages/core/src/lambda/vue/remoteInvoke/invokeLambda.ts @@ -7,7 +7,7 @@ import { _Blob } from 'aws-sdk/clients/lambda' import { readFileSync } from 'fs' // eslint-disable-line no-restricted-imports import * as _ from 'lodash' import * as vscode from 'vscode' -import { DefaultLambdaClient, LambdaClient } from '../../../shared/clients/lambdaClient' +import { LambdaClient } from '../../../shared/clients/lambdaClient' import * as picker from '../../../shared/ui/picker' import { ExtContext } from '../../../shared/extensions' @@ -19,7 +19,7 @@ import { getSampleLambdaPayloads, SampleRequest } from '../../utils' import * as nls from 'vscode-nls' import { VueWebview } from '../../../webviews/main' -import { telemetry, Result } from '../../../shared/telemetry/telemetry' +import { telemetry, Result, Runtime } from '../../../shared/telemetry/telemetry' import { runSamCliRemoteTestEvents, SamCliRemoteTestEventsParameters, @@ -29,6 +29,13 @@ import { getSamCliContext } from '../../../shared/sam/cli/samCliContext' import { ToolkitError } from '../../../shared/errors' import { basename } from 'path' import { decodeBase64 } from '../../../shared/utilities/textUtilities' +import { DebugConfig, RemoteDebugController, revertExistingConfig } from '../../remoteDebugging/ldkController' +import { getCachedLocalPath, openLambdaFile, runDownloadLambda } from '../../commands/downloadLambda' +import { getLambdaHandlerFile } from '../../../awsService/appBuilder/utils' +import { runUploadDirectory } from '../../commands/uploadLambda' +import fs from '../../../shared/fs/fs' +import { showConfirmationMessage, showMessage } from '../../../shared/utilities/messages' +import { getLambdaClientWithAgent } from '../../remoteDebugging/utils' const localize = nls.loadMessageBundle() @@ -48,19 +55,75 @@ export interface InitialData { Source?: string StackName?: string LogicalId?: string + Runtime?: string + LocalRootPath?: string + LambdaFunctionNode?: LambdaFunctionNode + supportCodeDownload?: boolean + runtimeSupportsRemoteDebug?: boolean + remoteDebugLayer?: string | undefined } -export interface RemoteInvokeData { - initialData: InitialData +// Debug configuration sub-interface +export interface DebugConfiguration { + debugPort: number + localRootPath: string + remoteRootPath: string + shouldPublishVersion: boolean + lambdaTimeout: number + otherDebugParams: string +} + +// Debug state sub-interface +export interface DebugState { + isDebugging: boolean + debugTimer: number | undefined + debugTimeRemaining: number + showDebugTimer: boolean + handlerFileAvailable: boolean + remoteDebuggingEnabled: boolean +} + +// Runtime-specific debug settings sub-interface +export interface RuntimeDebugSettings { + // Node.js specific + sourceMapEnabled: boolean + skipFiles: string + outFiles: string | undefined + // Python specific + justMyCode: boolean + // Java specific + projectName: string +} + +// UI state sub-interface +export interface UIState { + isCollapsed: boolean + showNameInput: boolean + payload: string +} + +// Payload/Event handling sub-interface +export interface PayloadData { selectedSampleRequest: string sampleText: string selectedFile: string selectedFilePath: string selectedTestEvent: string - payload: string - showNameInput: boolean newTestEventName: string - selectedFunction: string +} + +export interface RemoteInvokeData { + initialData: InitialData + debugConfig: DebugConfiguration + debugState: DebugState + runtimeSettings: RuntimeDebugSettings + uiState: UIState + payloadData: PayloadData +} + +// Event types for communicating state between backend and frontend +export type StateChangeEvent = { + isDebugging?: boolean } interface SampleQuickPickItem extends vscode.QuickPickItem { filename: string @@ -70,6 +133,19 @@ export class RemoteInvokeWebview extends VueWebview { public static readonly sourcePath: string = 'src/lambda/vue/remoteInvoke/index.js' public readonly id = 'remoteInvoke' + // Event emitter for state changes that need to be synchronized with the frontend + public readonly onStateChange = new vscode.EventEmitter() + + // Backend timer that will continue running even when the webview loses focus + private debugTimerHandle: NodeJS.Timeout | undefined + private debugTimeRemaining: number = 0 + private isInvoking: boolean = false + private debugging: boolean = false + private watcherDisposable: vscode.Disposable | undefined + private fileWatcherDisposable: vscode.Disposable | undefined + private handlerFileAvailable: boolean = false + private isStartingDebug: boolean = false + private handlerFile: string | undefined public constructor( private readonly channel: vscode.OutputChannel, private readonly client: LambdaClient, @@ -79,17 +155,137 @@ export class RemoteInvokeWebview extends VueWebview { } public init() { + this.watcherDisposable = vscode.debug.onDidTerminateDebugSession(async (session: vscode.DebugSession) => { + this.resetServerState() + }) return this.data } - public async invokeLambda(input: string, source?: string): Promise { + public resetServerState() { + this.stopDebugTimer() + this.debugging = false + this.isInvoking = false + this.isStartingDebug = false + this.onStateChange.fire({ + isDebugging: false, + }) + } + + public async disposeServer() { + this.watcherDisposable?.dispose() + this.fileWatcherDisposable?.dispose() + if (this.debugging && RemoteDebugController.instance.isDebugging) { + await this.stopDebugging() + } + this.dispose() + } + + private setupFileWatcher() { + // Dispose existing watcher if any + this.fileWatcherDisposable?.dispose() + + if (!this.data.LocalRootPath) { + return + } + + // Create a file system watcher for the local root path + const pattern = new vscode.RelativePattern(this.data.LocalRootPath, '**/*') + const watcher = vscode.workspace.createFileSystemWatcher(pattern) + + // Set up event handlers for file changes + const handleFileChange = async () => { + const result = await showMessage( + 'info', + localize( + 'AWS.lambda.remoteInvoke.codeChangesDetected', + 'Code changes detected in the local directory. Would you like to update the Lambda function {0}@{1}?', + this.data.FunctionName, + this.data.FunctionRegion + ), + ['Yes', 'No'] + ) + + if (result === 'Yes') { + try { + if (this.data.LambdaFunctionNode && this.data.LocalRootPath) { + const lambdaFunction = { + name: this.data.FunctionName, + region: this.data.FunctionRegion, + configuration: this.data.LambdaFunctionNode.configuration, + } + await runUploadDirectory(lambdaFunction, 'zip', vscode.Uri.file(this.data.LocalRootPath)) + } + } catch (error) { + throw ToolkitError.chain( + error, + localize('AWS.lambda.remoteInvoke.updateFailed', 'Failed to update Lambda function') + ) + } + } + } + + // Listen for file changes, creations, and deletions + watcher.onDidChange(handleFileChange) + watcher.onDidCreate(handleFileChange) + watcher.onDidDelete(handleFileChange) + + // Store the disposable so we can clean it up later + this.fileWatcherDisposable = watcher + } + + // Method to start the backend timer + public startDebugTimer() { + // Clear any existing timer + this.stopDebugTimer() + + this.debugTimeRemaining = 60 + + // Create a new timer that ticks every second + this.debugTimerHandle = setInterval(async () => { + this.debugTimeRemaining-- + + // When timer reaches zero, stop debugging + if (this.debugTimeRemaining <= 0) { + await this.handleTimerExpired() + } + }, 1000) + } + + // Method to stop the timer + public stopDebugTimer() { + if (this.debugTimerHandle) { + clearInterval(this.debugTimerHandle) + this.debugTimerHandle = undefined + this.debugTimeRemaining = 0 + } + } + + // Handler for timer expiration + private async handleTimerExpired() { + await this.stopDebugging() + } + + public async invokeLambda(input: string, source?: string, remoteDebugEnabled: boolean = false): Promise { let result: Result = 'Succeeded' + let qualifier: string | undefined = undefined + // if debugging, focus on the first editor + if (remoteDebugEnabled && RemoteDebugController.instance.isDebugging) { + await vscode.commands.executeCommand('workbench.action.focusFirstEditorGroup') + qualifier = RemoteDebugController.instance.qualifier + } + + this.isInvoking = true + + // If debugging is active, reset the timer during invoke + if (RemoteDebugController.instance.isDebugging) { + this.stopDebugTimer() + } this.channel.show() this.channel.appendLine('Loading response...') try { - const funcResponse = await this.client.invoke(this.data.FunctionArn, input) + const funcResponse = await this.client.invoke(this.data.FunctionArn, input, qualifier) const logs = funcResponse.LogResult ? decodeBase64(funcResponse.LogResult) : '' const payload = funcResponse.Payload ? funcResponse.Payload : JSON.stringify({}) @@ -107,13 +303,28 @@ export class RemoteInvokeWebview extends VueWebview { this.channel.appendLine('') result = 'Failed' } finally { - telemetry.lambda_invokeRemote.emit({ result, passive: false, source: source }) + telemetry.lambda_invokeRemote.emit({ + result, + passive: false, + source: source, + runtimeString: this.data.Runtime, + action: remoteDebugEnabled ? 'debug' : 'invoke', + }) + + // Update the session state to indicate we've finished invoking + this.isInvoking = false + + // If debugging is active, restart the timer + if (RemoteDebugController.instance.isDebugging) { + this.startDebugTimer() + } + this.channel.show() } } public async promptFile() { const fileLocations = await vscode.window.showOpenDialog({ - openLabel: 'Open', + openLabel: localize('AWS.lambda.remoteInvoke.open', 'Open'), }) if (!fileLocations || fileLocations.length === 0) { @@ -129,8 +340,66 @@ export class RemoteInvokeWebview extends VueWebview { } } catch (e) { getLogger().error('readFileSync: Failed to read file at path %s %O', fileLocations[0].fsPath, e) - throw ToolkitError.chain(e, 'Failed to read selected file') + throw ToolkitError.chain( + e, + localize('AWS.lambda.remoteInvoke.failedToReadFile', 'Failed to read selected file') + ) + } + } + + public async promptFolder(): Promise { + const fileLocations = await vscode.window.showOpenDialog({ + openLabel: localize('AWS.lambda.remoteInvoke.open', 'Open'), + canSelectFolders: true, + canSelectFiles: false, + canSelectMany: false, + }) + + if (!fileLocations || fileLocations.length === 0) { + return undefined + } + this.data.LocalRootPath = fileLocations[0].fsPath + // try to find the handler file in this folder, open it if not opened already + if (!(await this.tryOpenHandlerFile())) { + const warning = localize( + 'AWS.lambda.remoteInvoke.handlerFileNotFound', + 'Handler {0} not found in selected location. Please select the folder that contains the copy of your handler file', + this.data.LambdaFunctionNode?.configuration.Handler + ) + getLogger().warn(warning) + void vscode.window.showWarningMessage(warning) + } + return fileLocations[0].fsPath + } + + public async tryOpenHandlerFile(path?: string, watchForUpdates: boolean = true): Promise { + this.handlerFile = undefined + if (path) { + // path is provided, override init path + this.data.LocalRootPath = path } + // init path or node not available + if (!this.data.LocalRootPath || !this.data.LambdaFunctionNode) { + return false + } + + const handlerFile = await getLambdaHandlerFile( + vscode.Uri.file(this.data.LocalRootPath), + '', + this.data.LambdaFunctionNode?.configuration.Handler ?? '', + this.data.Runtime ?? 'unknown' + ) + if (!handlerFile || !(await fs.exists(handlerFile))) { + this.handlerFileAvailable = false + return false + } + this.handlerFileAvailable = true + if (watchForUpdates) { + this.setupFileWatcher() + } + await openLambdaFile(handlerFile.fsPath) + this.handlerFile = handlerFile.fsPath + return true } public async loadFile(fileLocations: string) { @@ -152,7 +421,10 @@ export class RemoteInvokeWebview extends VueWebview { } } catch (e) { getLogger().error('readFileSync: Failed to read file at path %s %O', fileLocation.fsPath, e) - throw ToolkitError.chain(e, 'Failed to read selected file') + throw ToolkitError.chain( + e, + localize('AWS.lambda.remoteInvoke.failedToReadFile', 'Failed to read selected file') + ) } } @@ -225,12 +497,234 @@ export class RemoteInvokeWebview extends VueWebview { return sample } catch (err) { getLogger().error('Error getting manifest data..: %O', err as Error) - throw ToolkitError.chain(err, 'getting manifest data') + throw ToolkitError.chain( + err, + localize('AWS.lambda.remoteInvoke.gettingManifestData', 'getting manifest data') + ) } } -} -const Panel = VueWebview.compilePanel(RemoteInvokeWebview) + // Download lambda code and update the local root path + public async downloadRemoteCode(): Promise { + return await telemetry.lambda_import.run(async (span) => { + span.record({ runtime: this.data.Runtime as Runtime | undefined, source: 'RemoteDebug' }) + try { + if (this.data.LambdaFunctionNode) { + const output = await runDownloadLambda(this.data.LambdaFunctionNode, true) + if (output instanceof vscode.Uri) { + this.data.LocalRootPath = output.fsPath + this.handlerFileAvailable = true + this.setupFileWatcher() + + return output.fsPath + } + } else { + getLogger().error( + localize( + 'AWS.lambda.remoteInvoke.lambdaFunctionNodeUndefined', + 'LambdaFunctionNode is undefined' + ) + ) + } + return undefined + } catch (error) { + throw ToolkitError.chain( + error, + localize('AWS.lambda.remoteInvoke.failedToDownloadCode', 'Failed to download remote code') + ) + } + }) + } + + // this serves as a lock for invoke + public checkReadyToInvoke(): boolean { + if (this.isInvoking) { + void vscode.window.showWarningMessage( + localize( + 'AWS.lambda.remoteInvoke.invokeInProgress', + 'A remote invoke is already in progress, please wait for previous invoke, or remove debug setup' + ) + ) + return false + } + if (this.isStartingDebug) { + void vscode.window.showWarningMessage( + localize( + 'AWS.lambda.remoteInvoke.debugSetupInProgress', + 'A debugger setup is already in progress, please wait for previous setup to complete, or remove debug setup' + ) + ) + } + return true + } + + // this check is run when user click remote invoke with remote debugging checked + public async checkReadyToDebug(config: DebugConfig): Promise { + if (!this.data.LambdaFunctionNode) { + return false + } + + if (!this.handlerFileAvailable) { + const result = await showConfirmationMessage({ + prompt: localize( + 'AWS.lambda.remoteInvoke.handlerFileNotLocated', + 'The handler file cannot be located in the specified Local Root Path. As a result, remote debugging will not pause at breakpoints.' + ), + confirm: 'Continue Anyway', + cancel: 'Cancel', + type: 'warning', + }) + if (!result) { + return false + } + } + // check if snapstart is on and we are publishing a version + if ( + config.shouldPublishVersion && + this.data.LambdaFunctionNode.configuration.SnapStart?.ApplyOn === 'PublishedVersions' + ) { + const result = await showConfirmationMessage({ + prompt: localize( + 'AWS.lambda.remoteInvoke.snapstartWarning', + "This function has Snapstart enabled. If you use Remote Debug with the 'publish version' setting, you'll experience notable delays. For faster debugging, consider disabling the 'publish version' option." + ), + confirm: 'Continue Anyway', + cancel: 'Cancel', + type: 'warning', + }) + if (!result) { + // didn't confirm + getLogger().warn( + localize('AWS.lambda.remoteInvoke.userCanceledSnapstart', 'User canceled Snapstart confirm') + ) + return false + } + } + + // ready to debug + return true + } + + public async startDebugging(config: DebugConfig): Promise { + if (!this.data.LambdaFunctionNode) { + return false + } + if (!(await this.checkReadyToDebug(config))) { + return false + } + this.isStartingDebug = true + try { + await RemoteDebugController.instance.startDebugging(this.data.FunctionArn, this.data.Runtime ?? 'unknown', { + ...config, + handlerFile: this.handlerFile, + }) + } catch (e) { + throw ToolkitError.chain( + e, + localize('AWS.lambda.remoteInvoke.failedToStartDebugging', 'Failed to start debugging') + ) + } finally { + this.isStartingDebug = false + } + + this.startDebugTimer() + this.debugging = this.isLDKDebugging() + return this.debugging + } + + public async stopDebugging(): Promise { + if (this.isLDKDebugging()) { + this.resetServerState() + await RemoteDebugController.instance.stopDebugging() + } + this.debugging = this.isLDKDebugging() + return this.debugging + } + + public isLDKDebugging(): boolean { + return RemoteDebugController.instance.isDebugging + } + + public isWebViewDebugging(): boolean { + return this.debugging + } + + public getIsInvoking(): boolean { + return this.isInvoking + } + + public getDebugTimeRemaining(): number { + return this.debugTimeRemaining + } + + public getLocalPath(): string { + return this.data.LocalRootPath ?? '' + } + + public getHandlerAvailable(): boolean { + return this.handlerFileAvailable + } + + // prestatus check run at checkbox click + public async debugPreCheck(): Promise { + return await telemetry.lambda_remoteDebugPrecheck.run(async (span) => { + span.record({ runtimeString: this.data.Runtime, source: 'webview' }) + if (!this.debugging && RemoteDebugController.instance.isDebugging) { + // another debug session in progress + const result = await showConfirmationMessage({ + prompt: localize( + 'AWS.lambda.remoteInvoke.debugSessionActive', + 'A remote debug session is already active. Stop that for this new session?' + ), + confirm: 'Stop Previous Session', + cancel: 'Cancel', + type: 'warning', + }) + + if (result) { + // Stop the previous session + if (await this.stopDebugging()) { + getLogger().error( + localize( + 'AWS.lambda.remoteInvoke.failedToStopPreviousSession', + 'Failed to stop previous debug session.' + ) + ) + return false + } + } else { + // user canceled, Do nothing + return false + } + } + + const result = await RemoteDebugController.instance.installDebugExtension(this.data.Runtime) + if (!result && result === false) { + // install failed + return false + } + + await revertExistingConfig() + + // Check if the function ARN is in the cache and try to open handler file + const cachedPath = getCachedLocalPath(this.data.FunctionArn) + // only check cache if not comming from appbuilder + if (cachedPath && !this.data.LambdaFunctionNode?.localDir) { + getLogger().debug( + `lambda: found cached local path for function ARN: ${this.data.FunctionArn} -> ${cachedPath}` + ) + await this.tryOpenHandlerFile(cachedPath, true) + } + + // this is comming from appbuilder + if (this.data.LambdaFunctionNode?.localDir) { + await this.tryOpenHandlerFile(undefined, false) + } + + return true + }) + } +} export async function invokeRemoteLambda( context: ExtContext, @@ -247,9 +741,22 @@ export async function invokeRemoteLambda( } ) { const inputs = await getSampleLambdaPayloads() - const resource: any = params.functionNode + const resource: LambdaFunctionNode = params.functionNode const source: string = params.source || 'AwsExplorerRemoteInvoke' - const client = new DefaultLambdaClient(resource.regionCode) + const client = getLambdaClientWithAgent(resource.regionCode) + + const Panel = VueWebview.compilePanel(RemoteInvokeWebview) + + // Initialize support and debugging capabilities + const runtime = resource.configuration.Runtime ?? 'unknown' + const region = resource.regionCode + const supportCodeDownload = RemoteDebugController.instance.supportCodeDownload(runtime) + const runtimeSupportsRemoteDebug = RemoteDebugController.instance.supportRuntimeRemoteDebug(runtime) + const remoteDebugLayer = RemoteDebugController.instance.getRemoteDebugLayer( + region, + resource.configuration.Architectures + ) + const wv = new Panel(context.extensionContext, context.outputChannel, client, { FunctionName: resource.configuration.FunctionName ?? '', FunctionArn: resource.configuration.FunctionArn ?? '', @@ -257,9 +764,22 @@ export async function invokeRemoteLambda( InputSamples: inputs, TestEvents: [], Source: source, + Runtime: runtime, + LocalRootPath: params.functionNode.localDir, + LambdaFunctionNode: params.functionNode, + supportCodeDownload: supportCodeDownload, + runtimeSupportsRemoteDebug: runtimeSupportsRemoteDebug, + remoteDebugLayer: remoteDebugLayer, }) + // focus on first group so wv will show up in the side + await vscode.commands.executeCommand('workbench.action.focusFirstEditorGroup') - await wv.show({ + const activePanel = await wv.show({ title: localize('AWS.invokeLambda.title', 'Invoke Lambda {0}', resource.configuration.FunctionName), + viewColumn: vscode.ViewColumn.Beside, + }) + + activePanel.onDidDispose(async () => { + await wv.server.disposeServer() }) } diff --git a/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.css b/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.css index 99f124e6b0c..bb7d5054bf2 100644 --- a/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.css +++ b/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.css @@ -1,6 +1,8 @@ .Icontainer { margin-inline: auto; - margin-top: 5rem; + margin-top: 2rem; + width: 100%; + min-width: 650px; } h1 { @@ -8,17 +10,35 @@ h1 { margin-bottom: 20px; } +/* Remove fixed width for divs to allow responsive behavior */ div { - width: 521px; + width: 100%; } .form-row { display: grid; grid-template-columns: 150px 1fr; margin-bottom: 10px; + align-items: center; +} + +.form-row-no-align { + display: grid; + grid-template-columns: 150px 1fr; + margin-bottom: 10px; +} + +.form-double-row { + display: grid; + grid-template-rows: 20px 1fr; + margin-inline: 0px; + padding: 0px 0px; + align-items: center; } + .form-row-select { - width: 387px; + width: 100%; + max-width: 387px; height: 28px; border: 1px; border-radius: 5px; @@ -29,16 +49,18 @@ div { .dynamic-span { white-space: nowrap; text-overflow: initial; - overflow: scroll; - width: 381px; - height: 28px; + overflow: auto; + width: 100%; + max-width: 381px; + height: auto; font-weight: 500; font-size: 13px; line-height: 15.51px; } .form-row-event-select { - width: 244px; + width: 100%; + max-width: 244px; height: 28px; margin-bottom: 15px; margin-left: 8px; @@ -52,6 +74,23 @@ div { } label { + font-weight: 500; + font-size: 14px; + margin-right: 10px; +} + +info { + color: var(--vscode-descriptionForeground); + font-weight: 500; + font-size: 13px; + margin-right: 10px; + text-wrap-mode: nowrap; +} + +info-wrap { + color: var(--vscode-descriptionForeground); + font-weight: 500; + font-size: 13px; margin-right: 10px; } @@ -65,6 +104,9 @@ textarea { color: var(--vscode-settings-textInputForeground); background: var(--vscode-settings-textInputBackground); border: 1px solid var(--vscode-settings-textInputBorder); + width: 100%; + box-sizing: border-box; + resize: none; } .payload-options-button { @@ -98,6 +140,17 @@ textarea { cursor: pointer; } +.button-theme-inline { + color: var(--vscode-button-secondaryForeground); + background: var(--vscode-button-secondaryBackground); + border: 1px solid var(--vscode-button-border); + padding: 4px 6px; +} +.button-theme-inline:hover:not(:disabled) { + background: var(--vscode-button-secondaryHoverBackground); + cursor: pointer; +} + .payload-options-buttons { display: flex; align-items: center; @@ -130,3 +183,85 @@ textarea { align-items: center; margin-bottom: 0.5rem; } + +.debug-timer { + padding: 5px 10px; + background-color: var(--vscode-editorWidget-background); + border-radius: 4px; + font-weight: 500; +} + +.collapsible-section { + margin: 15px 0; + border: 1px solid var(--vscode-widget-border); + border-radius: 4px; +} + +.collapsible-header { + padding: 8px 12px; + background-color: var(--vscode-sideBarSectionHeader-background); + cursor: pointer; + font-weight: 500; + max-width: 96%; +} + +.collapsible-content { + padding: 10px; + border-top: 1px solid var(--vscode-widget-border); + max-width: 96%; +} + +/* Ensure buttons in the same line are properly spaced */ +.button-container { + display: flex; + gap: 5px; +} + +/* For buttons that should be disabled */ +button:disabled { + opacity: 0.5; + cursor: not-allowed; +} + +/* Validation error styles */ +.input-error { + border: 1px solid var(--vscode-inputValidation-errorBorder) !important; + background-color: var(--vscode-inputValidation-errorBackground) !important; +} + +.error-message { + color: var(--vscode-inputValidation-errorForeground); + font-size: 12px; + margin-top: 4px; + font-weight: 400; + line-height: 1.2; +} + +/* Enhanced styling for remote debug checkbox to make it more obvious in dark mode */ +.remote-debug-checkbox { + width: 18px !important; + height: 18px !important; + accent-color: var(--vscode-checkbox-foreground); + border: 2px solid var(--vscode-checkbox-border) !important; + border-radius: 3px !important; + background-color: var(--vscode-checkbox-background) !important; + border-color: var(--vscode-checkbox-selectBorder) !important; + cursor: pointer; +} + +.remote-debug-checkbox:checked { + background-color: var(--vscode-checkbox-selectBackground) !important; + border-color: var(--vscode-checkbox-selectBorder) !important; +} + +.remote-debug-checkbox:disabled { + opacity: 0.6; + cursor: not-allowed; + border-color: var(--vscode-checkbox-border); + background-color: var(--vscode-input-background); +} + +.remote-debug-checkbox:focus { + outline: 2px solid var(--vscode-focusBorder); + outline-offset: 2px; +} diff --git a/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.vue b/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.vue index 8309fce6990..1743fd4ef00 100644 --- a/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.vue +++ b/packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.vue @@ -6,124 +6,402 @@ diff --git a/packages/core/src/lambda/vue/remoteInvoke/remoteInvokeFrontend.ts b/packages/core/src/lambda/vue/remoteInvoke/remoteInvokeFrontend.ts index 301b47603e9..b2253a46fd2 100644 --- a/packages/core/src/lambda/vue/remoteInvoke/remoteInvokeFrontend.ts +++ b/packages/core/src/lambda/vue/remoteInvoke/remoteInvokeFrontend.ts @@ -21,54 +21,202 @@ const defaultInitialData = { TestEvents: [], FunctionStack: '', Source: '', + LambdaFunctionNode: undefined, + supportCodeDownload: true, + runtimeSupportsRemoteDebug: true, + remoteDebugLayer: '', } export default defineComponent({ - async created() { - this.initialData = (await client.init()) ?? this.initialData - if (this.initialData.FunctionArn && this.initialData.FunctionRegion) { - this.initialData.TestEvents = await client.listRemoteTestEvents( - this.initialData.FunctionArn, - this.initialData.FunctionRegion - ) - } - }, - data(): RemoteInvokeData { return { initialData: { ...defaultInitialData }, - selectedSampleRequest: '', - sampleText: '{}', - selectedFile: '', - selectedFilePath: '', - payload: 'sampleEvents', - selectedTestEvent: '', - showNameInput: false, - newTestEventName: '', - selectedFunction: 'selectedFunction', + debugConfig: { + debugPort: 9229, + localRootPath: '', + remoteRootPath: '/var/task', + shouldPublishVersion: true, + lambdaTimeout: 900, + otherDebugParams: '', + }, + debugState: { + isDebugging: false, + debugTimer: undefined, + debugTimeRemaining: 60, + showDebugTimer: false, + handlerFileAvailable: false, + remoteDebuggingEnabled: false, + }, + runtimeSettings: { + sourceMapEnabled: true, + skipFiles: '/var/runtime/node_modules/**/*.js,/**', + justMyCode: true, + projectName: '', + outFiles: undefined, + }, + uiState: { + isCollapsed: true, + showNameInput: false, + payload: 'sampleEvents', + }, + payloadData: { + selectedSampleRequest: '', + sampleText: '{}', + selectedFile: '', + selectedFilePath: '', + selectedTestEvent: '', + newTestEventName: '', + }, } }, + + async created() { + // Initialize data from backend + this.initialData = (await client.init()) ?? this.initialData + this.debugConfig.localRootPath = this.initialData.LocalRootPath ?? '' + + // Register for state change events from the backend + void client.onStateChange(async () => { + await this.syncStateFromWorkspace() + }) + + // Check for existing session state and load it + await this.syncStateFromWorkspace() + }, + + computed: { + // Auto-adjust textarea rows based on content + textareaRows(): number { + if (!this.payloadData.sampleText) { + return 5 // Default minimum rows + } + + // Count line breaks to determine basic row count + const lineCount = this.payloadData.sampleText.split('\n').length + let additionalLine = 0 + for (const line of this.payloadData.sampleText.split('\n')) { + if (line.length > 60) { + additionalLine += Math.floor(line.length / 60) + } + } + + // Use the larger of line count or estimated lines, with min 5 and max 20 + const calculatedRows = lineCount + additionalLine + return Math.max(5, Math.min(50, calculatedRows)) + }, + + // Validation computed properties + debugPortError(): string { + if (this.debugConfig.debugPort !== null && this.debugConfig.debugPort !== undefined) { + const port = Number(this.debugConfig.debugPort) + if (isNaN(port) || port < 1 || port > 65535) { + return 'Debug port must be between 1 and 65535' + } + } + return '' + }, + + otherDebugParamsError(): string { + if (this.debugConfig.otherDebugParams && this.debugConfig.otherDebugParams.trim() !== '') { + try { + JSON.parse(this.debugConfig.otherDebugParams) + } catch (error) { + return 'Other Debug Params must be a valid JSON object' + } + } + return '' + }, + + lambdaTimeoutError(): string { + if (this.debugConfig.lambdaTimeout !== undefined) { + const timeout = Number(this.debugConfig.lambdaTimeout) + if (isNaN(timeout) || timeout < 1 || timeout > 900) { + return 'Timeout override must be between 1 and 900 seconds' + } + } + return '' + }, + + // user can override the default provided layer and bring their own layer + // this is useful to support function with code signing config + lambdaLayerError(): string { + if (this.initialData.remoteDebugLayer && this.initialData.remoteDebugLayer.trim() !== '') { + const layerArn = this.initialData.remoteDebugLayer.trim() + + // Validate Lambda layer ARN format + // Expected format: arn:aws:lambda:region:account-id:layer:layer-name:version + const layerArnRegex = /^arn:aws:lambda:[a-z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:\d+$/ + + if (!layerArnRegex.test(layerArn)) { + return 'Layer ARN must be in the format: arn:aws:lambda:::layer::' + } + + // Extract region from ARN to validate it matches the function region + const arnParts = layerArn.split(':') + if (arnParts.length >= 4) { + const layerRegion = arnParts[3] + if (this.initialData.FunctionRegion && layerRegion !== this.initialData.FunctionRegion) { + return `Layer region (${layerRegion}) must match function region (${this.initialData.FunctionRegion})` + } + } + } + return '' + }, + }, + methods: { + // Runtime detection computed properties based on the runtime string + hasRuntimePrefix(prefix: string): boolean { + const runtime = this.initialData.Runtime || '' + return runtime.startsWith(prefix) + }, + // Sync state from workspace storage + async syncStateFromWorkspace() { + try { + // Update debugging state + this.debugState.isDebugging = await client.isWebViewDebugging() + this.debugConfig.localRootPath = await client.getLocalPath() + this.debugState.handlerFileAvailable = await client.getHandlerAvailable() + // Get current session state + + if (this.debugState.isDebugging) { + // Update invoke button state based on session + const isInvoking = await client.getIsInvoking() + + // If debugging is active and we're not showing the timer, + // calculate and show remaining time + this.clearDebugTimer() + if (this.debugState.isDebugging && !isInvoking) { + await this.startDebugTimer() + } + } else { + this.clearDebugTimer() + // no debug session + } + } catch (error) { + console.error('Failed to sync state from workspace:', error) + } + }, async newSelection() { const eventData = { - name: this.selectedTestEvent, + name: this.payloadData.selectedTestEvent, region: this.initialData.FunctionRegion, arn: this.initialData.FunctionArn, } const resp = await client.getRemoteTestEvents(eventData) - this.sampleText = JSON.stringify(JSON.parse(resp), undefined, 4) + this.payloadData.sampleText = JSON.stringify(JSON.parse(resp), undefined, 4) }, async saveEvent() { const eventData = { - name: this.newTestEventName, - event: this.sampleText, + name: this.payloadData.newTestEventName, + event: this.payloadData.sampleText, region: this.initialData.FunctionRegion, arn: this.initialData.FunctionArn, } await client.createRemoteTestEvents(eventData) - this.showNameInput = false - this.newTestEventName = '' - this.selectedTestEvent = eventData.name + this.uiState.showNameInput = false + this.payloadData.newTestEventName = '' + this.payloadData.selectedTestEvent = eventData.name this.initialData.TestEvents = await client.listRemoteTestEvents( this.initialData.FunctionArn, this.initialData.FunctionRegion @@ -77,46 +225,179 @@ export default defineComponent({ async promptForFileLocation() { const resp = await client.promptFile() if (resp) { - this.selectedFile = resp.selectedFile - this.selectedFilePath = resp.selectedFilePath + this.payloadData.selectedFile = resp.selectedFile + this.payloadData.selectedFilePath = resp.selectedFilePath + } + }, + async promptForFolderLocation() { + const resp = await client.promptFolder() + if (resp) { + this.debugConfig.localRootPath = resp + this.debugState.handlerFileAvailable = await client.getHandlerAvailable() } }, + onFileChange(event: Event) { const input = event.target as HTMLInputElement if (input.files && input.files.length > 0) { const file = input.files[0] - this.selectedFile = file.name + this.payloadData.selectedFile = file.name // Use Blob.text() to read the file as text file.text() .then((text) => { - this.sampleText = text + this.payloadData.sampleText = text }) .catch((error) => { console.error('Error reading file:', error) }) } }, + async debugPreCheck() { + if (!this.debugState.remoteDebuggingEnabled) { + // don't check if unchecking + this.debugState.remoteDebuggingEnabled = false + if (this.debugState.isDebugging) { + await client.stopDebugging() + } + } else { + // check when user is checking box + this.debugState.remoteDebuggingEnabled = await client.debugPreCheck() + this.debugConfig.localRootPath = await client.getLocalPath() + this.debugState.handlerFileAvailable = await client.getHandlerAvailable() + } + }, showNameField() { if (this.initialData.FunctionRegion || this.initialData.FunctionRegion) { - this.showNameInput = true + this.uiState.showNameInput = true } }, async sendInput() { + // Tell the backend to set the button state. This state is maintained even if webview loses focus + if (this.debugState.remoteDebuggingEnabled) { + // check few outof bound issue + if ( + this.debugConfig.lambdaTimeout && + (this.debugConfig.lambdaTimeout > 900 || this.debugConfig.lambdaTimeout < 0) + ) { + this.debugConfig.lambdaTimeout = 900 + } + if ( + this.debugConfig.debugPort && + (this.debugConfig.debugPort > 65535 || this.debugConfig.debugPort <= 0) + ) { + this.debugConfig.debugPort = 9229 + } + + // acquire invoke lock + if (this.debugState.remoteDebuggingEnabled && !(await client.checkReadyToInvoke())) { + return + } + + if (!this.debugState.isDebugging) { + this.debugState.isDebugging = await client.startDebugging({ + functionArn: this.initialData.FunctionArn, + functionName: this.initialData.FunctionName, + port: this.debugConfig.debugPort ?? 9229, + sourceMap: this.runtimeSettings.sourceMapEnabled, + localRoot: this.debugConfig.localRootPath, + shouldPublishVersion: this.debugConfig.shouldPublishVersion, + remoteRoot: + this.debugConfig.remoteRootPath !== '' ? this.debugConfig.remoteRootPath : '/var/task', + skipFiles: (this.runtimeSettings.skipFiles !== '' + ? this.runtimeSettings.skipFiles + : '/**' + ).split(','), + justMyCode: this.runtimeSettings.justMyCode, + projectName: this.runtimeSettings.projectName, + otherDebugParams: this.debugConfig.otherDebugParams, + layerArn: this.initialData.remoteDebugLayer, + lambdaTimeout: this.debugConfig.lambdaTimeout ?? 900, + outFiles: this.runtimeSettings.outFiles?.split(','), + }) + if (!this.debugState.isDebugging) { + // user cancel or failed to start debugging + return + } + } + this.debugState.showDebugTimer = false + } + let event = '' - if (this.payload === 'sampleEvents' || this.payload === 'savedEvents') { - event = this.sampleText - } else if (this.payload === 'localFile') { - if (this.selectedFile && this.selectedFilePath) { - const resp = await client.loadFile(this.selectedFilePath) + if (this.uiState.payload === 'sampleEvents' || this.uiState.payload === 'savedEvents') { + event = this.payloadData.sampleText + } else if (this.uiState.payload === 'localFile') { + if (this.payloadData.selectedFile && this.payloadData.selectedFilePath) { + const resp = await client.loadFile(this.payloadData.selectedFilePath) if (resp) { event = resp.sample } } } - await client.invokeLambda(event, this.initialData.Source) + + await client.invokeLambda(event, this.initialData.Source, this.debugState.remoteDebuggingEnabled) + await this.syncStateFromWorkspace() + }, + + async removeDebugSetup() { + this.debugState.isDebugging = await client.stopDebugging() + }, + + async startDebugTimer() { + this.debugState.debugTimeRemaining = await client.getDebugTimeRemaining() + if (this.debugState.debugTimeRemaining <= 0) { + return + } + this.debugState.showDebugTimer = true + this.debugState.debugTimer = window.setInterval(() => { + this.debugState.debugTimeRemaining-- + if (this.debugState.debugTimeRemaining <= 0) { + this.clearDebugTimer() + } + }, 1000) as number | undefined + }, + + clearDebugTimer() { + if (this.debugState.debugTimer) { + window.clearInterval(this.debugState.debugTimer) + this.debugState.debugTimeRemaining = 0 + this.debugState.debugTimer = undefined + this.debugState.showDebugTimer = false + } + }, + + toggleCollapsible() { + this.uiState.isCollapsed = !this.uiState.isCollapsed + }, + + async openHandler() { + await client.tryOpenHandlerFile() + }, + + async openHandlerWithDelay() { + const preValue = this.debugConfig.localRootPath + // user is inputting the dir, only try to open dir if user stopped typing for 1 second + await new Promise((resolve) => setTimeout(resolve, 1000)) + if (preValue !== this.debugConfig.localRootPath) { + return + } + // try open if user stop input for 1 second + await client.tryOpenHandlerFile(this.debugConfig.localRootPath) + this.debugState.handlerFileAvailable = await client.getHandlerAvailable() + }, + + async downloadRemoteCode() { + try { + const path = await client.downloadRemoteCode() + if (path) { + this.debugConfig.localRootPath = path + this.debugState.handlerFileAvailable = await client.getHandlerAvailable() + } + } catch (error) { + console.error('Failed to download remote code:', error) + } }, loadSampleEvent() { @@ -125,7 +406,7 @@ export default defineComponent({ if (!sample) { return } - this.sampleText = JSON.stringify(JSON.parse(sample), undefined, 4) + this.payloadData.sampleText = JSON.stringify(JSON.parse(sample), undefined, 4) }, (e) => { console.error('client.getSamplePayload failed: %s', (e as Error).message) @@ -135,10 +416,9 @@ export default defineComponent({ async loadRemoteTestEvents() { const shouldLoadEvents = - this.payload === 'savedEvents' && + this.uiState.payload === 'savedEvents' && this.initialData.FunctionArn && - this.initialData.FunctionRegion && - !this.initialData.TestEvents + this.initialData.FunctionRegion if (shouldLoadEvents) { this.initialData.TestEvents = await client.listRemoteTestEvents( @@ -148,5 +428,6 @@ export default defineComponent({ } }, }, + mixins: [saveData], }) diff --git a/packages/core/src/shared/clients/lambdaClient.ts b/packages/core/src/shared/clients/lambdaClient.ts index 59af6f314a0..137af843e65 100644 --- a/packages/core/src/shared/clients/lambdaClient.ts +++ b/packages/core/src/shared/clients/lambdaClient.ts @@ -20,16 +20,20 @@ export type LambdaClient = ClassToInterfaceType export class DefaultLambdaClient { private readonly defaultTimeoutInMs: number - public constructor(public readonly regionCode: string) { + public constructor( + public readonly regionCode: string, + public readonly userAgent: string | undefined = undefined + ) { this.defaultTimeoutInMs = 5 * 60 * 1000 // 5 minutes (SDK default is 2 minutes) } - public async deleteFunction(name: string): Promise { + public async deleteFunction(name: string, qualifier?: string): Promise { const sdkClient = await this.createSdkClient() const response = await sdkClient .deleteFunction({ FunctionName: name, + Qualifier: qualifier, }) .promise() @@ -38,7 +42,7 @@ export class DefaultLambdaClient { } } - public async invoke(name: string, payload?: _Blob): Promise { + public async invoke(name: string, payload?: _Blob, version?: string): Promise { const sdkClient = await this.createSdkClient() const response = await sdkClient @@ -46,6 +50,7 @@ export class DefaultLambdaClient { FunctionName: name, LogType: 'Tail', Payload: payload, + Qualifier: version, }) .promise() @@ -158,10 +163,126 @@ export class DefaultLambdaClient { } } + public async updateFunctionConfiguration( + params: Lambda.UpdateFunctionConfigurationRequest, + options: { + maxRetries?: number + initialDelayMs?: number + backoffMultiplier?: number + waitForUpdate?: boolean + } = {} + ): Promise { + const client = await this.createSdkClient() + const maxRetries = options.maxRetries ?? 5 + const initialDelayMs = options.initialDelayMs ?? 1000 + const backoffMultiplier = options.backoffMultiplier ?? 2 + // return until lambda update is completed + const waitForUpdate = options.waitForUpdate ?? false + + let retryCount = 0 + let lastError: any + + // there could be race condition, if function is being updated, wait and retry + while (retryCount <= maxRetries) { + try { + const response = await client.updateFunctionConfiguration(params).promise() + getLogger().debug('updateFunctionConfiguration returned response: %O', response) + if (waitForUpdate) { + // don't return if wait for result + break + } + return response + } catch (e) { + lastError = e + + // Check if this is an "update in progress" error + if (this.isUpdateInProgressError(e) && retryCount < maxRetries) { + const delayMs = initialDelayMs * Math.pow(backoffMultiplier, retryCount) + getLogger().info( + `Update in progress for Lambda function ${params.FunctionName}. ` + + `Retrying in ${delayMs}ms (attempt ${retryCount + 1}/${maxRetries})` + ) + + await new Promise((resolve) => setTimeout(resolve, delayMs)) + retryCount++ + } else { + getLogger().error('Failed to run updateFunctionConfiguration: %s', e) + throw e + } + } + } + + // check if lambda update is completed, use client.getFunctionConfiguration to poll until + // LastUpdateStatus is Successful or Failed + if (waitForUpdate) { + let lastUpdateStatus = 'InProgress' + while (lastUpdateStatus === 'InProgress') { + await new Promise((resolve) => setTimeout(resolve, 1000)) + const response = await client.getFunctionConfiguration({ FunctionName: params.FunctionName }).promise() + lastUpdateStatus = response.LastUpdateStatus ?? 'Failed' + if (lastUpdateStatus === 'Successful') { + return response + } else if (lastUpdateStatus === 'Failed') { + getLogger().error('Failed to update function configuration: %O', response) + throw new Error(`Failed to update function configuration: ${response.LastUpdateStatusReason}`) + } + } + } + + getLogger().error(`Failed to update function configuration after ${maxRetries} retries: %s`, lastError) + throw lastError + } + + public async publishVersion( + name: string, + options: { waitForUpdate?: boolean } = {} + ): Promise { + const client = await this.createSdkClient() + // return until lambda update is completed + const waitForUpdate = options.waitForUpdate ?? false + const response = await client + .publishVersion({ + FunctionName: name, + }) + .promise() + + if (waitForUpdate) { + let state = 'Pending' + while (state === 'Pending') { + await new Promise((resolve) => setTimeout(resolve, 1000)) + const statusResponse = await client + .getFunctionConfiguration({ FunctionName: name, Qualifier: response.Version }) + .promise() + state = statusResponse.State ?? 'Failed' + if (state === 'Active' || state === 'InActive') { + // version creation finished + return statusResponse + } else if (state === 'Failed') { + getLogger().error('Failed to create Version: %O', statusResponse) + throw new Error(`Failed to create Version: ${statusResponse.LastUpdateStatusReason}`) + } + } + } + + return response + } + + private isUpdateInProgressError(error: any): boolean { + return ( + error?.message && + error.message.includes( + 'The operation cannot be performed at this time. An update is in progress for resource:' + ) + ) + } + private async createSdkClient(): Promise { return await globals.sdkClientBuilder.createAwsService( Lambda, - { httpOptions: { timeout: this.defaultTimeoutInMs } }, + { + httpOptions: { timeout: this.defaultTimeoutInMs }, + customUserAgent: this.userAgent, + }, this.regionCode ) } diff --git a/packages/core/src/shared/globalState.ts b/packages/core/src/shared/globalState.ts index 2ec0a328d24..e8e6a3bff44 100644 --- a/packages/core/src/shared/globalState.ts +++ b/packages/core/src/shared/globalState.ts @@ -79,6 +79,8 @@ export type globalKey = | 'aws.toolkit.lambda.walkthroughSelected' | 'aws.toolkit.lambda.walkthroughCompleted' | 'aws.toolkit.appComposer.templateToOpenOnStart' + | 'aws.lambda.remoteDebugContext' + | 'aws.lambda.remoteDebugSnapshot' // List of Domain-Users to show/hide Sagemaker SpaceApps in AWS Explorer. | 'aws.sagemaker.selectedDomainUsers' diff --git a/packages/core/src/shared/telemetry/vscodeTelemetry.json b/packages/core/src/shared/telemetry/vscodeTelemetry.json index 9b29d1a65a0..55f4f8934cf 100644 --- a/packages/core/src/shared/telemetry/vscodeTelemetry.json +++ b/packages/core/src/shared/telemetry/vscodeTelemetry.json @@ -1141,6 +1141,77 @@ { "name": "appbuilder_lambda2sam", "description": "User click Convert a lambda function to SAM project" + }, + { + "name": "lambda_remoteDebugStop", + "description": "user stop remote debugging", + "metadata": [ + { + "type": "sessionDuration", + "required": false + } + ] + }, + { + "name": "lambda_remoteDebugStart", + "description": "user start remote debugging", + "metadata": [ + { + "type": "runtimeString", + "required": false + }, + { + "type": "source", + "required": false + }, + { + "type": "action", + "required": false + } + ] + }, + { + "name": "lambda_remoteDebugPrecheck", + "description": "user click remote debug checkbox", + "metadata": [ + { + "type": "runtimeString", + "required": false + }, + { + "type": "source", + "required": false + }, + { + "type": "action", + "required": false + } + ] + }, + { + "name": "lambda_invokeRemote", + "description": "Called when invoking lambdas remotely", + "metadata": [ + { + "type": "result" + }, + { + "type": "runtime", + "required": false + }, + { + "type": "source", + "required": false + }, + { + "type": "runtimeString", + "required": false + }, + { + "type": "action", + "required": false + } + ] } ] } diff --git a/packages/core/src/shared/utilities/pathFind.ts b/packages/core/src/shared/utilities/pathFind.ts index 04622733a66..a0eea9e38ae 100644 --- a/packages/core/src/shared/utilities/pathFind.ts +++ b/packages/core/src/shared/utilities/pathFind.ts @@ -18,6 +18,7 @@ let vscPath: string let sshPath: string let gitPath: string let bashPath: string +let javaPath: string const pathMap = new Map() /** @@ -145,6 +146,44 @@ export async function findSshPath(useCache: boolean = true): Promise { + if (javaPath !== undefined) { + return javaPath + } + + const paths = [ + 'java', // Try $PATH first + '/usr/bin/java', + '/usr/local/bin/java', + '/opt/java/bin/java', + // Common Oracle JDK locations + '/usr/lib/jvm/default-java/bin/java', + '/usr/lib/jvm/java-11-openjdk/bin/java', + '/usr/lib/jvm/java-8-openjdk/bin/java', + // Windows locations + 'C:/Program Files/Java/jre1.8.0_301/bin/java.exe', + 'C:/Program Files/Java/jdk1.8.0_301/bin/java.exe', + 'C:/Program Files/OpenJDK/openjdk-11.0.2/bin/java.exe', + 'C:/Program Files (x86)/Java/jre1.8.0_301/bin/java.exe', + 'C:/Program Files (x86)/Java/jdk1.8.0_301/bin/java.exe', + // macOS locations + '/System/Library/Frameworks/JavaVM.framework/Versions/Current/Commands/java', + '/usr/libexec/java_home', + ] + for (const p of paths) { + if (!p || ('java' !== p && !(await fs.exists(p)))) { + continue + } + if (await tryRun(p, ['-version'])) { + javaPath = p + return p + } + } +} + /** * Gets the configured `git` path, or falls back to "ssh" (not absolute), * or tries common locations, or returns undefined. diff --git a/packages/core/src/test/lambda/commands/deleteLambda.test.ts b/packages/core/src/test/lambda/commands/deleteLambda.test.ts index 366d7344ef6..8da82c2c21e 100644 --- a/packages/core/src/test/lambda/commands/deleteLambda.test.ts +++ b/packages/core/src/test/lambda/commands/deleteLambda.test.ts @@ -11,7 +11,7 @@ import { stub } from '../../utilities/stubber' describe('deleteLambda', async function () { function createLambdaClient() { - const client = stub(DefaultLambdaClient, { regionCode: 'region-1' }) + const client = stub(DefaultLambdaClient, { regionCode: 'region-1', userAgent: undefined }) client.deleteFunction.resolves() return client diff --git a/packages/core/src/test/lambda/explorer/cloudFormationNodes.test.ts b/packages/core/src/test/lambda/explorer/cloudFormationNodes.test.ts index 8cbeedf25f3..ba8d7ccd516 100644 --- a/packages/core/src/test/lambda/explorer/cloudFormationNodes.test.ts +++ b/packages/core/src/test/lambda/explorer/cloudFormationNodes.test.ts @@ -26,7 +26,7 @@ import { getLabel } from '../../../shared/treeview/utils' const regionCode = 'someregioncode' function createLambdaClient(...functionNames: string[]) { - const client = stub(DefaultLambdaClient, { regionCode }) + const client = stub(DefaultLambdaClient, { regionCode, userAgent: undefined }) client.listFunctions.returns(asyncGenerator(functionNames.map((name) => ({ FunctionName: name })))) return client diff --git a/packages/core/src/test/lambda/explorer/lambdaNodes.test.ts b/packages/core/src/test/lambda/explorer/lambdaNodes.test.ts index 2c94d28ba9b..86ed7bbe44c 100644 --- a/packages/core/src/test/lambda/explorer/lambdaNodes.test.ts +++ b/packages/core/src/test/lambda/explorer/lambdaNodes.test.ts @@ -17,7 +17,7 @@ import { DefaultLambdaClient } from '../../../shared/clients/lambdaClient' const regionCode = 'someregioncode' function createLambdaClient(...functionNames: string[]) { - const client = stub(DefaultLambdaClient, { regionCode }) + const client = stub(DefaultLambdaClient, { regionCode, userAgent: undefined }) client.listFunctions.returns(asyncGenerator(functionNames.map((name) => ({ FunctionName: name })))) return client diff --git a/packages/core/src/test/lambda/remoteDebugging/ldkClient.test.ts b/packages/core/src/test/lambda/remoteDebugging/ldkClient.test.ts new file mode 100644 index 00000000000..91f99aa0409 --- /dev/null +++ b/packages/core/src/test/lambda/remoteDebugging/ldkClient.test.ts @@ -0,0 +1,471 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import assert from 'assert' +import sinon from 'sinon' +import { Lambda } from 'aws-sdk' +import { LdkClient, getRegionFromArn, isTunnelInfo } from '../../../lambda/remoteDebugging/ldkClient' +import { LocalProxy } from '../../../lambda/remoteDebugging/localProxy' +import * as utils from '../../../lambda/remoteDebugging/utils' +import * as telemetryUtil from '../../../shared/telemetry/util' +import globals from '../../../shared/extensionGlobals' +import { createMockFunctionConfig, createMockProgress } from './testUtils' + +describe('LdkClient', () => { + let sandbox: sinon.SinonSandbox + let ldkClient: LdkClient + let mockLambdaClient: any + let mockIoTSTClient: any + let mockLocalProxy: any + + beforeEach(() => { + sandbox = sinon.createSandbox() + + // Mock Lambda client + mockLambdaClient = { + getFunction: sandbox.stub(), + updateFunctionConfiguration: sandbox.stub(), + publishVersion: sandbox.stub(), + deleteFunction: sandbox.stub(), + } + sandbox.stub(utils, 'getLambdaClientWithAgent').returns(mockLambdaClient) + + // Mock IoT ST client with proper promise structure + const createPromiseStub = () => sandbox.stub() + mockIoTSTClient = { + listTunnels: sandbox.stub().returns({ promise: createPromiseStub() }), + openTunnel: sandbox.stub().returns({ promise: createPromiseStub() }), + closeTunnel: sandbox.stub().returns({ promise: createPromiseStub() }), + rotateTunnelAccessToken: sandbox.stub().returns({ promise: createPromiseStub() }), + } + sandbox.stub(utils, 'getIoTSTClientWithAgent').resolves(mockIoTSTClient) + + // Mock LocalProxy + mockLocalProxy = { + start: sandbox.stub(), + stop: sandbox.stub(), + } + sandbox.stub(LocalProxy.prototype, 'start').callsFake(mockLocalProxy.start) + sandbox.stub(LocalProxy.prototype, 'stop').callsFake(mockLocalProxy.stop) + + // Mock global state + const stateStorage = new Map() + const mockGlobalState = { + get: (key: string) => stateStorage.get(key), + update: async (key: string, value: any) => { + stateStorage.set(key, value) + return Promise.resolve() + }, + } + sandbox.stub(globals, 'globalState').value(mockGlobalState) + + // Mock telemetry util + sandbox.stub(telemetryUtil, 'getClientId').returns('test-client-id') + ldkClient = LdkClient.instance + ldkClient.dispose() + }) + + afterEach(() => { + sandbox.restore() + }) + + describe('Singleton Pattern', () => { + it('should return the same instance', () => { + const instance1 = LdkClient.instance + const instance2 = LdkClient.instance + assert.strictEqual(instance1, instance2, 'Should return the same singleton instance') + }) + }) + + describe('dispose()', () => { + it('should dispose resources properly', () => { + // Set up a mock local proxy + ;(ldkClient as any).localProxy = mockLocalProxy + + ldkClient.dispose() + + assert(mockLocalProxy.stop.calledOnce, 'Should stop local proxy') + assert.strictEqual((ldkClient as any).localProxy, undefined, 'Should clear local proxy reference') + }) + + it('should clear client caches', () => { + // Add some clients to cache + ;(ldkClient as any).lambdaClientCache.set('us-east-1', mockLambdaClient) + ;(ldkClient as any).lambdaClientCache.set('us-west-2', mockLambdaClient) + + assert.strictEqual((ldkClient as any).lambdaClientCache.size, 2, 'Should have cached clients') + + ldkClient.dispose() + + assert.strictEqual((ldkClient as any).lambdaClientCache.size, 0, 'Should clear Lambda client cache') + }) + }) + + describe('createOrReuseTunnel()', () => { + it('should create new tunnel when none exists', async () => { + mockIoTSTClient.listTunnels().promise.resolves({ tunnelSummaries: [] }) + mockIoTSTClient.openTunnel().promise.resolves({ + tunnelId: 'tunnel-123', + sourceAccessToken: 'source-token', + destinationAccessToken: 'dest-token', + }) + + const result = await ldkClient.createOrReuseTunnel('us-east-1') + + assert(result, 'Should return tunnel info') + assert.strictEqual(result?.tunnelID, 'tunnel-123') + assert.strictEqual(result?.sourceToken, 'source-token') + assert.strictEqual(result?.destinationToken, 'dest-token') + assert(mockIoTSTClient.listTunnels.called, 'Should list existing tunnels') + assert(mockIoTSTClient.openTunnel.called, 'Should create new tunnel') + }) + + it('should reuse existing tunnel with sufficient time remaining', async () => { + const existingTunnel = { + tunnelId: 'existing-tunnel', + description: 'RemoteDebugging+test-client-id', + status: 'OPEN', + createdAt: new Date(Date.now() - 60 * 60 * 1000), // 1 hour ago + } + + mockIoTSTClient.listTunnels().promise.resolves({ tunnelSummaries: [existingTunnel] }) + mockIoTSTClient.rotateTunnelAccessToken().promise.resolves({ + sourceAccessToken: 'rotated-source-token', + destinationAccessToken: 'rotated-dest-token', + }) + + const result = await ldkClient.createOrReuseTunnel('us-east-1') + + assert(result, 'Should return tunnel info') + assert.strictEqual(result?.tunnelID, 'existing-tunnel') + assert.strictEqual(result?.sourceToken, 'rotated-source-token') + assert.strictEqual(result?.destinationToken, 'rotated-dest-token') + }) + + it('should handle tunnel creation errors', async () => { + mockIoTSTClient.listTunnels().promise.resolves({ tunnelSummaries: [] }) + mockIoTSTClient.openTunnel().promise.rejects(new Error('Tunnel creation failed')) + + await assert.rejects( + async () => await ldkClient.createOrReuseTunnel('us-east-1'), + /Error creating\/reusing tunnel/, + 'Should throw error on tunnel creation failure' + ) + }) + }) + + describe('refreshTunnelTokens()', () => { + it('should refresh tunnel tokens successfully', async () => { + mockIoTSTClient.rotateTunnelAccessToken().promise.resolves({ + sourceAccessToken: 'new-source-token', + destinationAccessToken: 'new-dest-token', + }) + + const result = await ldkClient.refreshTunnelTokens('tunnel-123', 'us-east-1') + + assert(result, 'Should return tunnel info') + assert.strictEqual(result?.tunnelID, 'tunnel-123') + assert.strictEqual(result?.sourceToken, 'new-source-token') + assert.strictEqual(result?.destinationToken, 'new-dest-token') + }) + + it('should handle token refresh errors', async () => { + mockIoTSTClient.rotateTunnelAccessToken().promise.rejects(new Error('Token refresh failed')) + + await assert.rejects( + async () => await ldkClient.refreshTunnelTokens('tunnel-123', 'us-east-1'), + /Error refreshing tunnel tokens/, + 'Should throw error on token refresh failure' + ) + }) + }) + + describe('getFunctionDetail()', () => { + const mockFunctionConfig: Lambda.FunctionConfiguration = createMockFunctionConfig({ + FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:testFunction', + }) + + it('should get function details successfully', async () => { + mockLambdaClient.getFunction.resolves({ Configuration: mockFunctionConfig }) + + const result = await ldkClient.getFunctionDetail(mockFunctionConfig.FunctionArn!) + + assert.deepStrictEqual(result, mockFunctionConfig, 'Should return function configuration') + }) + + it('should handle function details retrieval errors', async () => { + mockLambdaClient.getFunction.reset() + mockLambdaClient.getFunction.rejects(new Error('Function not found')) + + const result = await ldkClient.getFunctionDetail(mockFunctionConfig.FunctionArn!) + + assert.strictEqual(result, undefined, 'Should return undefined on error') + }) + + it('should handle invalid ARN', async () => { + const result = await ldkClient.getFunctionDetail('invalid-arn') + + assert.strictEqual(result, undefined, 'Should return undefined for invalid ARN') + }) + }) + + describe('createDebugDeployment()', () => { + const mockFunctionConfig: Lambda.FunctionConfiguration = createMockFunctionConfig({ + FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:testFunction', + }) + + const mockProgress = createMockProgress() + + beforeEach(() => { + mockLambdaClient.updateFunctionConfiguration.resolves({}) + mockLambdaClient.publishVersion.resolves({ Version: 'v1' }) + }) + + it('should create debug deployment successfully without version publishing', async () => { + const result = await ldkClient.createDebugDeployment( + mockFunctionConfig, + 'dest-token', + 900, + false, + 'layer-arn', + mockProgress as any + ) + + assert.strictEqual(result, '$Latest', 'Should return $Latest for non-version deployment') + assert(mockLambdaClient.updateFunctionConfiguration.calledOnce, 'Should update function configuration') + assert(mockLambdaClient.publishVersion.notCalled, 'Should not publish version') + }) + + it('should create debug deployment with version publishing', async () => { + const result = await ldkClient.createDebugDeployment( + mockFunctionConfig, + 'dest-token', + 900, + true, + 'layer-arn', + mockProgress as any + ) + + assert.strictEqual(result, 'v1', 'Should return version number') + assert(mockLambdaClient.publishVersion.calledOnce, 'Should publish version') + }) + + it('should handle deployment errors', async () => { + mockLambdaClient.updateFunctionConfiguration.reset() + mockLambdaClient.updateFunctionConfiguration.rejects(new Error('Update failed')) + + await assert.rejects( + async () => + await ldkClient.createDebugDeployment( + mockFunctionConfig, + 'dest-token', + 900, + false, + 'layer-arn', + mockProgress as any + ), + /Failed to create debug deployment/, + 'Should throw error on deployment failure' + ) + }) + + it('should handle missing function ARN', async () => { + const configWithoutArn = { ...mockFunctionConfig, FunctionArn: undefined } + + await assert.rejects( + async () => + await ldkClient.createDebugDeployment( + configWithoutArn, + 'dest-token', + 900, + false, + 'layer-arn', + mockProgress as any + ), + /Function ARN is missing/, + 'Should throw error for missing ARN' + ) + }) + }) + + describe('removeDebugDeployment()', () => { + const mockFunctionConfig: Lambda.FunctionConfiguration = createMockFunctionConfig({ + FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:testFunction', + }) + + beforeEach(() => { + mockLambdaClient.updateFunctionConfiguration.resolves({}) + }) + + it('should remove debug deployment successfully', async () => { + const result = await ldkClient.removeDebugDeployment(mockFunctionConfig, false) + + assert.strictEqual(result, true, 'Should return true on successful removal') + assert(mockLambdaClient.updateFunctionConfiguration.calledOnce, 'Should update function configuration') + }) + + it('should handle removal errors', async () => { + mockLambdaClient.updateFunctionConfiguration.rejects(new Error('Update failed')) + + await assert.rejects( + async () => await ldkClient.removeDebugDeployment(mockFunctionConfig, false), + /Error removing debug deployment/, + 'Should throw error on removal failure' + ) + }) + + it('should handle missing function ARN', async () => { + const configWithoutArn = { ...mockFunctionConfig, FunctionArn: undefined, FunctionName: undefined } + + await assert.rejects( + async () => await ldkClient.removeDebugDeployment(configWithoutArn, false), + /Error removing debug deployment/, + 'Should throw error for missing ARN' + ) + }) + }) + + describe('deleteDebugVersion()', () => { + it('should delete debug version successfully', async () => { + mockLambdaClient.deleteFunction.resolves({}) + + const result = await ldkClient.deleteDebugVersion( + 'arn:aws:lambda:us-east-1:123456789012:function:testFunction', + 'v1' + ) + + assert.strictEqual(result, true, 'Should return true on successful deletion') + assert(mockLambdaClient.deleteFunction.calledOnce, 'Should call deleteFunction') + }) + + it('should handle version deletion errors', async () => { + mockLambdaClient.deleteFunction.rejects(new Error('Delete failed')) + + const result = await ldkClient.deleteDebugVersion( + 'arn:aws:lambda:us-east-1:123456789012:function:testFunction', + 'v1' + ) + + assert.strictEqual(result, false, 'Should return false on deletion error') + }) + + it('should handle invalid ARN for version deletion', async () => { + const result = await ldkClient.deleteDebugVersion('invalid-arn', 'v1') + + assert.strictEqual(result, false, 'Should return false for invalid ARN') + }) + }) + + describe('startProxy()', () => { + beforeEach(() => { + mockLocalProxy.start.resolves(9229) + mockLocalProxy.stop.returns() + }) + + it('should start proxy successfully', async () => { + const result = await ldkClient.startProxy('us-east-1', 'source-token', 9229) + + assert.strictEqual(result, true, 'Should return true on successful start') + assert( + mockLocalProxy.start.calledWith('us-east-1', 'source-token', 9229), + 'Should start proxy with correct parameters' + ) + }) + + it('should stop existing proxy before starting new one', async () => { + // Create a spy for the stop method + const stopSpy = sandbox.spy() + + // Set up existing proxy with the spy + ;(ldkClient as any).localProxy = { stop: stopSpy } + + await ldkClient.startProxy('us-east-1', 'source-token', 9229) + + assert(stopSpy.called, 'Should stop existing proxy') + }) + + it('should handle proxy start errors', async () => { + mockLocalProxy.start.rejects(new Error('Proxy start failed')) + + await assert.rejects( + async () => await ldkClient.startProxy('us-east-1', 'source-token', 9229), + /Failed to start proxy/, + 'Should throw error on proxy start failure' + ) + }) + }) + + describe('stopProxy()', () => { + it('should stop proxy successfully', async () => { + // Set up existing proxy + ;(ldkClient as any).localProxy = { stop: mockLocalProxy.stop } + + const result = await ldkClient.stopProxy() + + assert.strictEqual(result, true, 'Should return true on successful stop') + assert(mockLocalProxy.stop.calledOnce, 'Should stop proxy') + assert.strictEqual((ldkClient as any).localProxy, undefined, 'Should clear proxy reference') + }) + + it('should handle stopping when no proxy exists', async () => { + const result = await ldkClient.stopProxy() + + assert.strictEqual(result, true, 'Should return true when no proxy to stop') + }) + }) +}) + +describe('Helper Functions', () => { + describe('getRegionFromArn', () => { + it('should extract region from valid ARN', () => { + const arn = 'arn:aws:lambda:us-east-1:123456789012:function:testFunction' + const result = getRegionFromArn(arn) + assert.strictEqual(result, 'us-east-1', 'Should extract region correctly') + }) + + it('should handle undefined ARN', () => { + const result = getRegionFromArn(undefined) + assert.strictEqual(result, undefined, 'Should return undefined for undefined ARN') + }) + + it('should handle invalid ARN format', () => { + const result = getRegionFromArn('invalid-arn') + assert.strictEqual(result, undefined, 'Should return undefined for invalid ARN') + }) + + it('should handle ARN with insufficient parts', () => { + const result = getRegionFromArn('arn:aws:lambda') + assert.strictEqual(result, undefined, 'Should return undefined for ARN with insufficient parts') + }) + }) + + describe('isTunnelInfo', () => { + it('should validate correct tunnel info', () => { + const tunnelInfo = { + tunnelID: 'tunnel-123', + sourceToken: 'source-token', + destinationToken: 'dest-token', + } + const result = isTunnelInfo(tunnelInfo) + assert.strictEqual(result, true, 'Should validate correct tunnel info') + }) + + it('should reject invalid tunnel info', () => { + const invalidTunnelInfo = { + tunnelID: 'tunnel-123', + sourceToken: 'source-token', + // missing destinationToken + } + const result = isTunnelInfo(invalidTunnelInfo as any) + assert.strictEqual(result, false, 'Should reject invalid tunnel info') + }) + + it('should reject non-object types', () => { + assert.strictEqual(isTunnelInfo('string' as any), false, 'Should reject string') + assert.strictEqual(isTunnelInfo(123 as any), false, 'Should reject number') + assert.strictEqual(isTunnelInfo(undefined as any), false, 'Should reject undefined') + }) + }) +}) diff --git a/packages/core/src/test/lambda/remoteDebugging/ldkController.test.ts b/packages/core/src/test/lambda/remoteDebugging/ldkController.test.ts new file mode 100644 index 00000000000..6c2a173fdaa --- /dev/null +++ b/packages/core/src/test/lambda/remoteDebugging/ldkController.test.ts @@ -0,0 +1,600 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import assert from 'assert' +import * as vscode from 'vscode' +import sinon, { SinonStubbedInstance, createStubInstance } from 'sinon' +import { Lambda } from 'aws-sdk' +import { + RemoteDebugController, + DebugConfig, + activateRemoteDebugging, + revertExistingConfig, + getLambdaSnapshot, +} from '../../../lambda/remoteDebugging/ldkController' +import { LdkClient } from '../../../lambda/remoteDebugging/ldkClient' +import globals from '../../../shared/extensionGlobals' +import * as messages from '../../../shared/utilities/messages' +import { getOpenExternalStub } from '../../globalSetup.test' +import { assertTelemetry } from '../../testUtil' +import { + createMockFunctionConfig, + createMockDebugConfig, + createMockGlobalState, + setupMockLdkClientOperations, + setupMockVSCodeDebugAPIs, + setupMockRevertExistingConfig, + setupDebuggingState, + setupMockCleanupOperations, +} from './testUtils' + +describe('RemoteDebugController', () => { + let sandbox: sinon.SinonSandbox + let mockLdkClient: SinonStubbedInstance + let controller: RemoteDebugController + let mockGlobalState: any + + beforeEach(() => { + sandbox = sinon.createSandbox() + + // Mock LdkClient + mockLdkClient = createStubInstance(LdkClient) + sandbox.stub(LdkClient, 'instance').get(() => mockLdkClient) + + // Mock global state with actual storage + mockGlobalState = createMockGlobalState() + sandbox.stub(globals, 'globalState').value(mockGlobalState) + + // Get controller instance + controller = RemoteDebugController.instance + + // Ensure clean state + controller.ensureCleanState() + }) + + afterEach(() => { + sandbox.restore() + }) + + describe('Singleton Pattern', () => { + it('should return the same instance', () => { + const instance1 = RemoteDebugController.instance + const instance2 = RemoteDebugController.instance + assert.strictEqual(instance1, instance2, 'Should return the same singleton instance') + }) + }) + + describe('State Management', () => { + it('should initialize with clean state', () => { + controller.ensureCleanState() + + assert.strictEqual(controller.isDebugging, false, 'Should not be debugging initially') + assert.strictEqual(controller.qualifier, undefined, 'Qualifier should be undefined initially') + }) + + it('should clean up disposables on ensureCleanState', () => { + // Set up some mock disposables + const mockDisposable = { dispose: sandbox.stub() } + ;(controller as any).debugSessionDisposables.set('test-arn', mockDisposable) + + controller.ensureCleanState() + + assert(mockDisposable.dispose.calledOnce, 'Should dispose existing disposables') + assert.strictEqual((controller as any).debugSessionDisposables.size, 0, 'Should clear disposables map') + }) + }) + + describe('Runtime Support Checks', () => { + it('should support code download for node and python runtimes', () => { + assert.strictEqual(controller.supportCodeDownload('nodejs18.x'), true, 'Should support Node.js') + assert.strictEqual(controller.supportCodeDownload('python3.9'), true, 'Should support Python') + assert.strictEqual( + controller.supportCodeDownload('java11'), + false, + 'Should not support Java for code download' + ) + assert.strictEqual(controller.supportCodeDownload(undefined), false, 'Should not support undefined runtime') + }) + + it('should support remote debug for node, python, and java runtimes', () => { + assert.strictEqual(controller.supportRuntimeRemoteDebug('nodejs18.x'), true, 'Should support Node.js') + assert.strictEqual(controller.supportRuntimeRemoteDebug('python3.9'), true, 'Should support Python') + assert.strictEqual(controller.supportRuntimeRemoteDebug('java11'), true, 'Should support Java') + assert.strictEqual(controller.supportRuntimeRemoteDebug('dotnet6'), false, 'Should not support .NET') + assert.strictEqual( + controller.supportRuntimeRemoteDebug(undefined), + false, + 'Should not support undefined runtime' + ) + }) + + it('should get remote debug layer for supported regions and architectures', () => { + const result = controller.getRemoteDebugLayer('us-east-1', ['x86_64']) + + assert.strictEqual(typeof result, 'string', 'Should return layer ARN for supported region and architecture') + assert(result?.includes('us-east-1'), 'Should contain the region in the ARN') + assert(result?.includes('LDKLayerX86'), 'Should contain the x86 layer name') + }) + + it('should return undefined for unsupported regions', () => { + const result = controller.getRemoteDebugLayer('unsupported-region', ['x86_64']) + + assert.strictEqual(result, undefined, 'Should return undefined for unsupported region') + }) + + it('should return undefined when region or architectures are undefined', () => { + assert.strictEqual(controller.getRemoteDebugLayer(undefined, ['x86_64']), undefined) + assert.strictEqual(controller.getRemoteDebugLayer('us-west-2', undefined), undefined) + }) + }) + + describe('Extension Installation', () => { + it('should return true when extension is already installed', async () => { + // Mock VSCode extensions API - return extension as already installed + const mockExtension = { id: 'ms-vscode.js-debug', isActive: true } + sandbox.stub(vscode.extensions, 'getExtension').returns(mockExtension as any) + + const result = await controller.installDebugExtension('nodejs18.x') + + assert.strictEqual(result, true, 'Should return true when extension is already installed') + }) + + it('should return true when extension installation succeeds', async () => { + // Mock extension as not installed initially, then installed after command + const getExtensionStub = sandbox.stub(vscode.extensions, 'getExtension') + getExtensionStub.onFirstCall().returns(undefined) // Not installed initially + getExtensionStub.onSecondCall().returns({ isActive: true } as any) // Installed after command + + sandbox.stub(vscode.commands, 'executeCommand').resolves() + sandbox.stub(messages, 'showConfirmationMessage').resolves(true) + + const result = await controller.installDebugExtension('python3.9') + + assert.strictEqual(result, true, 'Should return true when installation succeeds') + }) + + it('should return false when user cancels extension installation', async () => { + // Mock extension as not installed + sandbox.stub(vscode.extensions, 'getExtension').returns(undefined) + sandbox.stub(messages, 'showConfirmationMessage').resolves(false) + + const result = await controller.installDebugExtension('python3.9') + + assert.strictEqual(result, false, 'Should return false when user cancels') + }) + + it('should handle Java runtime workflow', async () => { + // Mock extension as already installed to skip extension installation + const mockExtension = { id: 'redhat.java', isActive: true } + sandbox.stub(vscode.extensions, 'getExtension').returns(mockExtension as any) + + // Mock no Java path found + sandbox.stub(require('../../../shared/utilities/pathFind'), 'findJavaPath').resolves(undefined) + + // Mock user choosing to install JVM + const showConfirmationStub = sandbox.stub(messages, 'showConfirmationMessage').resolves(true) + + // Mock openExternal to prevent actual URL opening + // sandbox.stub(vscode.env, 'openExternal').resolves(true) + getOpenExternalStub().resolves(true) + const result = await controller.installDebugExtension('java11') + + assert.strictEqual(result, false, 'Should return false to allow user to install JVM') + assert(showConfirmationStub.calledOnce, 'Should show JVM installation dialog') + }) + + it('should throw error for undefined runtime', async () => { + await assert.rejects( + async () => await controller.installDebugExtension(undefined), + /Runtime is undefined/, + 'Should throw error for undefined runtime' + ) + }) + }) + + describe('Debug Session Management', () => { + let mockConfig: DebugConfig + let mockFunctionConfig: Lambda.FunctionConfiguration + + beforeEach(() => { + mockConfig = createMockDebugConfig({ + layerArn: 'arn:aws:lambda:us-west-2:123456789012:layer:LDKLayerX86:6', + }) + + mockFunctionConfig = createMockFunctionConfig() + }) + + it('should start debugging successfully', async () => { + // Mock VSCode APIs + setupMockVSCodeDebugAPIs(sandbox) + + // Mock runtime support + sandbox.stub(controller, 'supportRuntimeRemoteDebug').returns(true) + + // Mock successful LdkClient operations + setupMockLdkClientOperations(mockLdkClient, mockFunctionConfig) + + // Mock revertExistingConfig + setupMockRevertExistingConfig(sandbox) + + await controller.startDebugging(mockConfig.functionArn, 'nodejs18.x', mockConfig) + + // Assert state changes + assert.strictEqual(controller.isDebugging, true, 'Should be in debugging state') + // Qualifier is only set for version publishing, not for $LATEST + assert.strictEqual(controller.qualifier, undefined, 'Should not set qualifier for $LATEST') + + // Verify LdkClient calls + assert(mockLdkClient.getFunctionDetail.calledWith(mockConfig.functionArn), 'Should get function details') + assert(mockLdkClient.createOrReuseTunnel.calledOnce, 'Should create tunnel') + assert(mockLdkClient.createDebugDeployment.calledOnce, 'Should create debug deployment') + assert(mockLdkClient.startProxy.calledOnce, 'Should start proxy') + + assertTelemetry('lambda_remoteDebugStart', { + result: 'Succeeded', + source: 'remoteDebug', + action: '{"port":9229,"remoteRoot":"/var/task","skipFiles":[],"shouldPublishVersion":false,"lambdaTimeout":900,"layerArn":"arn:aws:lambda:us-west-2:123456789012:layer:LDKLayerX86:6"}', + runtimeString: 'nodejs18.x', + }) + }) + + it('should handle debugging start failure and cleanup', async () => { + // Mock VSCode APIs + setupMockVSCodeDebugAPIs(sandbox) + + // Mock runtime support + sandbox.stub(controller, 'supportRuntimeRemoteDebug').returns(true) + + // Mock function config retrieval success but tunnel creation failure + setupMockLdkClientOperations(mockLdkClient, mockFunctionConfig) + mockLdkClient.createOrReuseTunnel.rejects(new Error('Tunnel creation failed')) + + // Mock revertExistingConfig + setupMockRevertExistingConfig(sandbox) + + let errorThrown = false + try { + await controller.startDebugging(mockConfig.functionArn, 'nodejs18.x', mockConfig) + } catch (error) { + errorThrown = true + assert(error instanceof Error, 'Should throw an error') + assert( + error.message.includes('Error StartDebugging') || error.message.includes('Tunnel creation failed'), + 'Should throw relevant error' + ) + } + + assert(errorThrown, 'Should have thrown an error') + + // Assert state is cleaned up + assert.strictEqual(controller.isDebugging, false, 'Should not be in debugging state after failure') + assert(mockLdkClient.stopProxy.calledOnce, 'Should attempt cleanup') + }) + + it('should handle version publishing workflow', async () => { + // Mock VSCode APIs + setupMockVSCodeDebugAPIs(sandbox) + + // Mock runtime support + sandbox.stub(controller, 'supportRuntimeRemoteDebug').returns(true) + + const versionConfig = { ...mockConfig, shouldPublishVersion: true } + + // Mock successful LdkClient operations with version publishing + setupMockLdkClientOperations(mockLdkClient, mockFunctionConfig) + mockLdkClient.createDebugDeployment.resolves('v1') + + // Mock revertExistingConfig + setupMockRevertExistingConfig(sandbox) + + await controller.startDebugging(versionConfig.functionArn, 'nodejs18.x', versionConfig) + + assert.strictEqual(controller.isDebugging, true, 'Should be in debugging state') + assert.strictEqual(controller.qualifier, 'v1', 'Should set version qualifier') + // Verify telemetry was emitted with version action + assertTelemetry('lambda_remoteDebugStart', { + result: 'Succeeded', + source: 'remoteDebug', + action: '{"port":9229,"remoteRoot":"/var/task","skipFiles":[],"shouldPublishVersion":true,"lambdaTimeout":900,"layerArn":"arn:aws:lambda:us-west-2:123456789012:layer:LDKLayerX86:6"}', + runtimeString: 'nodejs18.x', + }) + }) + + it('should prevent multiple debugging sessions', async () => { + // Set controller to already debugging + controller.isDebugging = true + + await controller.startDebugging(mockConfig.functionArn, 'nodejs18.x', mockConfig) + + // Should not call LdkClient methods + assert(mockLdkClient.getFunctionDetail.notCalled, 'Should not start new session') + }) + }) + + describe('Stop Debugging', () => { + it('should stop debugging successfully', async () => { + // Mock VSCode APIs + sandbox.stub(vscode.commands, 'executeCommand').resolves() + + // Set up debugging state + await setupDebuggingState(controller, mockGlobalState) + + // Mock successful cleanup operations + setupMockCleanupOperations(mockLdkClient) + + await controller.stopDebugging() + + // Assert state is cleaned up + assert.strictEqual(controller.isDebugging, false, 'Should not be in debugging state') + + // Verify cleanup operations + assert(mockLdkClient.stopProxy.calledOnce, 'Should stop proxy') + assert(mockLdkClient.removeDebugDeployment.calledOnce, 'Should remove debug deployment') + assert(mockLdkClient.deleteDebugVersion.calledOnce, 'Should delete debug version') + assertTelemetry('lambda_remoteDebugStop', { + result: 'Succeeded', + }) + }) + + it('should handle stop debugging when not debugging', async () => { + controller.isDebugging = false + + await controller.stopDebugging() + + // Should complete without error when not debugging + assert.strictEqual(controller.isDebugging, false, 'Should remain not debugging') + }) + + it('should handle cleanup errors gracefully', async () => { + // Mock VSCode APIs + sandbox.stub(vscode.commands, 'executeCommand').resolves() + + controller.isDebugging = true + + const mockFunctionConfig = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + } + // Set up the snapshot in mock state + await mockGlobalState.update('aws.lambda.remoteDebugSnapshot', mockFunctionConfig) + + // Mock cleanup failure + mockLdkClient.stopProxy.rejects(new Error('Cleanup failed')) + mockLdkClient.removeDebugDeployment.resolves(true) + + await assert.rejects( + async () => await controller.stopDebugging(), + /error when stopping remote debug/, + 'Should throw error on cleanup failure' + ) + + // State should still be cleaned up + assert.strictEqual(controller.isDebugging, false, 'Should clean up state even on error') + // Verify telemetry was emitted for failure + assertTelemetry('lambda_remoteDebugStop', { + result: 'Failed', + }) + }) + }) + + describe('Snapshot Management', () => { + it('should get lambda snapshot from global state', async () => { + const mockSnapshot = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + } + // Set up the snapshot in mock state + await mockGlobalState.update('aws.lambda.remoteDebugSnapshot', mockSnapshot) + + const result = getLambdaSnapshot() + + assert.deepStrictEqual(result, mockSnapshot, 'Should return snapshot from global state') + }) + + it('should return undefined when no snapshot exists', () => { + const result = getLambdaSnapshot() + + assert.strictEqual(result, undefined, 'Should return undefined when no snapshot') + }) + }) + + describe('Telemetry Verification', () => { + let mockConfig: DebugConfig + let mockFunctionConfig: Lambda.FunctionConfiguration + + beforeEach(() => { + mockConfig = createMockDebugConfig({ + layerArn: 'arn:aws:lambda:us-west-2:123456789012:layer:LDKLayerX86:6', + }) + + mockFunctionConfig = createMockFunctionConfig() + }) + + it('should emit lambda_remoteDebugStart telemetry for failed debugging start', async () => { + // Mock VSCode APIs + setupMockVSCodeDebugAPIs(sandbox) + + // Mock runtime support + sandbox.stub(controller, 'supportRuntimeRemoteDebug').returns(true) + + // Mock function config retrieval success but tunnel creation failure + setupMockLdkClientOperations(mockLdkClient, mockFunctionConfig) + mockLdkClient.createOrReuseTunnel.rejects(new Error('Tunnel creation failed')) + + // Mock revertExistingConfig + setupMockRevertExistingConfig(sandbox) + + try { + await controller.startDebugging(mockConfig.functionArn, 'nodejs18.x', mockConfig) + } catch (error) { + // Expected to throw + } + + // Verify telemetry was emitted for failure + assertTelemetry('lambda_remoteDebugStart', { + result: 'Failed', + source: 'remoteDebug', + action: '{"port":9229,"remoteRoot":"/var/task","skipFiles":[],"shouldPublishVersion":false,"lambdaTimeout":900,"layerArn":"arn:aws:lambda:us-west-2:123456789012:layer:LDKLayerX86:6"}', + runtimeString: 'nodejs18.x', + }) + }) + }) +}) + +describe('Module Functions', () => { + let sandbox: sinon.SinonSandbox + let mockGlobalState: any + + beforeEach(() => { + sandbox = sinon.createSandbox() + + // Mock global state with actual storage + mockGlobalState = createMockGlobalState() + sandbox.stub(globals, 'globalState').value(mockGlobalState) + }) + + afterEach(() => { + sandbox.restore() + }) + + describe('activateRemoteDebugging', () => { + it('should activate remote debugging and ensure clean state', async () => { + // Mock revertExistingConfig + sandbox + .stub(require('../../../lambda/remoteDebugging/ldkController'), 'revertExistingConfig') + .resolves(true) + + // Mock controller + const mockController = { + ensureCleanState: sandbox.stub(), + } + sandbox.stub(RemoteDebugController, 'instance').get(() => mockController) + + await activateRemoteDebugging() + + assert(mockController.ensureCleanState.calledOnce, 'Should ensure clean state') + }) + + it('should handle activation errors gracefully', async () => { + // Mock revertExistingConfig to throw error + sandbox + .stub(require('../../../lambda/remoteDebugging/ldkController'), 'revertExistingConfig') + .rejects(new Error('Revert failed')) + + // Should not throw error, just handle gracefully + await activateRemoteDebugging() + + // Test passes if no error is thrown + assert(true, 'Should handle activation errors gracefully') + }) + }) + + describe('revertExistingConfig', () => { + let mockLdkClient: SinonStubbedInstance + + beforeEach(() => { + mockLdkClient = createStubInstance(LdkClient) + sandbox.stub(LdkClient, 'instance').get(() => mockLdkClient) + }) + + it('should return true when no existing config', async () => { + // mockGlobalState.get.returns(undefined) + + const result = await revertExistingConfig() + + assert.strictEqual(result, true, 'Should return true when no config to revert') + }) + + it('should revert existing config successfully', async () => { + const mockSnapshot = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + Timeout: 30, + } + const mockCurrentConfig = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + Timeout: 900, // Different from snapshot + } + + // Set up the snapshot in mock state + await mockGlobalState.update('aws.lambda.remoteDebugSnapshot', mockSnapshot) + mockLdkClient.getFunctionDetail.resolves(mockCurrentConfig) + mockLdkClient.removeDebugDeployment.resolves(true) + + const showConfirmationStub = sandbox.stub(messages, 'showConfirmationMessage').resolves(true) + const result = await revertExistingConfig() + + assert.strictEqual(result, true, 'Should return true on successful revert') + assert(showConfirmationStub.calledOnce, 'Should show confirmation dialog') + assert(mockLdkClient.removeDebugDeployment.calledWith(mockSnapshot, false), 'Should revert config') + }) + + it('should handle user cancellation of revert', async () => { + const mockSnapshot = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + } + const mockCurrentConfig = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + Timeout: 900, + } + + // Set up the snapshot in mock state + await mockGlobalState.update('aws.lambda.remoteDebugSnapshot', mockSnapshot) + mockLdkClient.getFunctionDetail.resolves(mockCurrentConfig) + + sandbox.stub(messages, 'showConfirmationMessage').resolves(false) + + const result = await revertExistingConfig() + + assert.strictEqual(result, true, 'Should return true when user cancels') + // Verify snapshot was cleared + assert.strictEqual( + mockGlobalState.get('aws.lambda.remoteDebugSnapshot'), + undefined, + 'Should clear snapshot' + ) + }) + + it('should handle corrupted snapshot gracefully', async () => { + const corruptedSnapshot = { + // Missing FunctionArn and FunctionName + Timeout: 30, + } + + // Set up corrupted snapshot in mock state + await mockGlobalState.update('aws.lambda.remoteDebugSnapshot', corruptedSnapshot) + + const result = await revertExistingConfig() + + assert.strictEqual(result, true, 'Should return true for corrupted snapshot') + // Verify snapshot was cleared + assert.strictEqual( + mockGlobalState.get('aws.lambda.remoteDebugSnapshot'), + undefined, + 'Should clear corrupted snapshot' + ) + }) + + it('should handle revert errors', async () => { + const mockSnapshot = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + } + + // Set up the snapshot in mock state + await mockGlobalState.update('aws.lambda.remoteDebugSnapshot', mockSnapshot) + mockLdkClient.getFunctionDetail.rejects(new Error('Failed to get function')) + + await assert.rejects( + async () => await revertExistingConfig(), + /Error in revertExistingConfig/, + 'Should throw error on revert failure' + ) + }) + }) +}) diff --git a/packages/core/src/test/lambda/remoteDebugging/localProxy.test.ts b/packages/core/src/test/lambda/remoteDebugging/localProxy.test.ts new file mode 100644 index 00000000000..7c1bd0479b4 --- /dev/null +++ b/packages/core/src/test/lambda/remoteDebugging/localProxy.test.ts @@ -0,0 +1,421 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import assert from 'assert' +import sinon from 'sinon' +import WebSocket from 'ws' +import { LocalProxy } from '../../../lambda/remoteDebugging/localProxy' + +describe('LocalProxy', () => { + let sandbox: sinon.SinonSandbox + let localProxy: LocalProxy + + beforeEach(() => { + sandbox = sinon.createSandbox() + localProxy = new LocalProxy() + }) + + afterEach(() => { + localProxy.stop() + sandbox.restore() + }) + + describe('Constructor', () => { + it('should initialize with default values', () => { + const proxy = new LocalProxy() + assert.strictEqual((proxy as any).isConnected, false, 'Should not be connected initially') + assert.strictEqual((proxy as any).reconnectAttempts, 0, 'Should have zero reconnect attempts') + assert.strictEqual((proxy as any).currentStreamId, 1, 'Should start with stream ID 1') + assert.strictEqual((proxy as any).nextConnectionId, 1, 'Should start with connection ID 1') + }) + }) + + describe('Protobuf Loading', () => { + it('should load protobuf definition successfully', async () => { + const proxy = new LocalProxy() + await (proxy as any).loadProtobufDefinition() + + assert((proxy as any).Message, 'Should load Message type') + assert.strictEqual(typeof (proxy as any).Message, 'object', 'Message should be a protobuf Type object') + assert.strictEqual((proxy as any).Message.constructor.name, 'Type', 'Message should be a protobuf Type') + }) + + it('should not reload protobuf definition if already loaded', async () => { + const proxy = new LocalProxy() + await (proxy as any).loadProtobufDefinition() + const firstMessage = (proxy as any).Message + + await (proxy as any).loadProtobufDefinition() + const secondMessage = (proxy as any).Message + + assert.strictEqual(firstMessage, secondMessage, 'Should not reload protobuf definition') + }) + }) + + describe('TCP Server Management', () => { + it('should close TCP server and connections properly', () => { + const mockSocket = { + removeAllListeners: sandbox.stub(), + destroy: sandbox.stub(), + } + + const mockServer = { + removeAllListeners: sandbox.stub(), + close: sandbox.stub().callsArg(0), + } + + // Set up mock state + ;(localProxy as any).tcpServer = mockServer + ;(localProxy as any).tcpConnections = new Map([[1, { socket: mockSocket }]]) + ;(localProxy as any).closeTcpServer() + + assert(mockSocket.removeAllListeners.called, 'Should remove socket listeners') + assert(mockSocket.destroy.calledOnce, 'Should destroy socket') + assert(mockServer.removeAllListeners.called, 'Should remove server listeners') + assert(mockServer.close.calledOnce, 'Should close server') + }) + }) + + describe('WebSocket Connection Management', () => { + it('should create WebSocket with correct URL and headers', async () => { + const mockWs = { + on: sandbox.stub(), + once: sandbox.stub(), + readyState: WebSocket.OPEN, + removeAllListeners: sandbox.stub(), + close: sandbox.stub(), + terminate: sandbox.stub(), + } + + // Set up LocalProxy with required properties + ;(localProxy as any).region = 'us-east-1' + ;(localProxy as any).accessToken = 'test-access-token' + + // Mock the WebSocket constructor + const WebSocketStub = sandbox.stub().returns(mockWs) + sandbox.stub(WebSocket, 'WebSocket').callsFake(WebSocketStub) + + // Mock the open event to resolve the promise + mockWs.on.withArgs('open').callsArg(1) + + await (localProxy as any).connectWebSocket() + + assert(WebSocketStub.calledOnce, 'Should create WebSocket') + const [url, protocols, options] = WebSocketStub.getCall(0).args + + assert(url.includes('wss://data.tunneling.iot.'), 'Should use correct WebSocket URL') + assert(url.includes('.amazonaws.com:443/tunnel'), 'Should use correct WebSocket URL') + assert(url.includes('local-proxy-mode=source'), 'Should set local proxy mode') + assert.deepStrictEqual(protocols, ['aws.iot.securetunneling-3.0'], 'Should use correct protocol') + assert(options && options.headers && options.headers['access-token'], 'Should include access token header') + assert(options && options.headers && options.headers['client-token'], 'Should include client token header') + }) + + it('should handle WebSocket connection errors', async () => { + const mockWs = { + on: sandbox.stub(), + once: sandbox.stub(), + readyState: WebSocket.CONNECTING, + removeAllListeners: sandbox.stub(), + close: sandbox.stub(), + terminate: sandbox.stub(), + } + + sandbox.stub(WebSocket, 'WebSocket').returns(mockWs) + + // Mock the error event + mockWs.on.withArgs('error').callsArgWith(1, new Error('Connection failed')) + + await assert.rejects( + async () => await (localProxy as any).connectWebSocket(), + /Connection failed/, + 'Should throw error on WebSocket connection failure' + ) + }) + + it('should close WebSocket connection properly', () => { + const mockWs = { + readyState: WebSocket.OPEN, + removeAllListeners: sandbox.stub(), + close: sandbox.stub(), + terminate: sandbox.stub(), + once: sandbox.stub(), + } + + ;(localProxy as any).ws = mockWs + ;(localProxy as any).closeWebSocket() + + assert(mockWs.removeAllListeners.called, 'Should remove all listeners') + assert(mockWs.close.calledWith(1000, 'Normal Closure'), 'Should close with normal closure code') + }) + + it('should terminate WebSocket if not open', () => { + const mockWs = { + readyState: WebSocket.CONNECTING, + removeAllListeners: sandbox.stub(), + close: sandbox.stub(), + terminate: sandbox.stub(), + } + + ;(localProxy as any).ws = mockWs + ;(localProxy as any).closeWebSocket() + + assert(mockWs.terminate.calledOnce, 'Should terminate WebSocket if not open') + }) + }) + + describe('Ping/Pong Management', () => { + it('should start ping interval', () => { + const setIntervalStub = sandbox.stub(global, 'setInterval').returns({} as any) + + ;(localProxy as any).startPingInterval() + + assert(setIntervalStub.calledOnce, 'Should start ping interval') + assert.strictEqual(setIntervalStub.getCall(0).args[1], 30000, 'Should ping every 30 seconds') + }) + + it('should stop ping interval', () => { + const clearIntervalStub = sandbox.stub(global, 'clearInterval') + const mockInterval = {} as any + ;(localProxy as any).pingInterval = mockInterval + ;(localProxy as any).stopPingInterval() + + assert(clearIntervalStub.calledWith(mockInterval), 'Should clear ping interval') + assert.strictEqual((localProxy as any).pingInterval, undefined, 'Should clear interval reference') + }) + + it('should send ping when WebSocket is open', () => { + const mockWs = { + readyState: WebSocket.OPEN, + ping: sandbox.stub(), + } + + ;(localProxy as any).ws = mockWs + + // Simulate ping interval callback + const setIntervalStub = sandbox.stub(global, 'setInterval') + ;(localProxy as any).startPingInterval() + + const pingCallback = setIntervalStub.getCall(0).args[0] + pingCallback() + + assert(mockWs.ping.calledOnce, 'Should send ping') + }) + }) + + describe('Message Processing', () => { + beforeEach(async () => { + // Load protobuf definition + await (localProxy as any).loadProtobufDefinition() + }) + + it('should process binary WebSocket messages', () => { + const processMessageStub = sandbox.stub(localProxy as any, 'processMessage') + + // Create a mock message buffer with length prefix + const messageData = Buffer.from('test message') + const buffer = Buffer.alloc(2 + messageData.length) + buffer.writeUInt16BE(messageData.length, 0) + messageData.copy(buffer, 2) + ;(localProxy as any).handleWebSocketMessage(buffer) + + assert(processMessageStub.calledOnce, 'Should process message') + assert(processMessageStub.calledWith(messageData), 'Should pass correct message data') + }) + + it('should handle incomplete message data', () => { + const processMessageStub = sandbox.stub(localProxy as any, 'processMessage') + + // Create incomplete buffer (only length prefix) + const buffer = Buffer.alloc(2) + buffer.writeUInt16BE(100, 0) // Claims 100 bytes but buffer is only 2 + ;(localProxy as any).handleWebSocketMessage(buffer) + + assert(processMessageStub.notCalled, 'Should not process incomplete message') + }) + + it('should handle non-buffer WebSocket messages', () => { + const processMessageStub = sandbox.stub(localProxy as any, 'processMessage') + + ;(localProxy as any).handleWebSocketMessage('string message') + + assert(processMessageStub.notCalled, 'Should not process non-buffer messages') + }) + }) + + describe('TCP Connection Handling', () => { + beforeEach(() => { + ;(localProxy as any).isConnected = true + ;(localProxy as any).isDisposed = false + }) + + it('should handle new TCP connections when connected', () => { + const mockSocket = { + on: sandbox.stub(), + destroy: sandbox.stub(), + once: sandbox.stub(), + } + + const sendStreamStartStub = sandbox.stub(localProxy as any, 'sendStreamStart') + + ;(localProxy as any).handleNewTcpConnection(mockSocket) + + assert(mockSocket.on.calledWith('data'), 'Should listen for data events') + assert(mockSocket.on.calledWith('error'), 'Should listen for error events') + assert(mockSocket.on.calledWith('close'), 'Should listen for close events') + assert(sendStreamStartStub.calledOnce, 'Should send stream start for first connection') + }) + + it('should reject TCP connections when not connected', () => { + ;(localProxy as any).isConnected = false + + const mockSocket = { + destroy: sandbox.stub(), + } + + ;(localProxy as any).handleNewTcpConnection(mockSocket) + + assert(mockSocket.destroy.calledOnce, 'Should destroy socket when not connected') + }) + + it('should reject TCP connections when disposed', () => { + ;(localProxy as any).isDisposed = true + + const mockSocket = { + destroy: sandbox.stub(), + } + + ;(localProxy as any).handleNewTcpConnection(mockSocket) + + assert(mockSocket.destroy.calledOnce, 'Should destroy socket when disposed') + }) + + it('should send connection start for subsequent connections', () => { + ;(localProxy as any).nextConnectionId = 2 // Second connection + + const mockSocket = { + on: sandbox.stub(), + destroy: sandbox.stub(), + once: sandbox.stub(), + } + + const sendConnectionStartStub = sandbox.stub(localProxy as any, 'sendConnectionStart') + + ;(localProxy as any).handleNewTcpConnection(mockSocket) + + assert(sendConnectionStartStub.calledOnce, 'Should send connection start for subsequent connections') + }) + }) + + describe('Lifecycle Management', () => { + it('should start proxy successfully', async () => { + const startTcpServerStub = sandbox.stub(localProxy as any, 'startTcpServer').resolves(9229) + const connectWebSocketStub = sandbox.stub(localProxy as any, 'connectWebSocket').resolves() + + const port = await localProxy.start('us-east-1', 'source-token', 9229) + + assert.strictEqual(port, 9229, 'Should return assigned port') + assert(startTcpServerStub.calledWith(9229), 'Should start TCP server') + assert(connectWebSocketStub.calledOnce, 'Should connect WebSocket') + assert.strictEqual((localProxy as any).region, 'us-east-1', 'Should store region') + assert.strictEqual((localProxy as any).accessToken, 'source-token', 'Should store access token') + }) + + it('should handle start errors and cleanup', async () => { + sandbox.stub(localProxy as any, 'startTcpServer').resolves(9229) + sandbox.stub(localProxy as any, 'connectWebSocket').rejects(new Error('WebSocket failed')) + const stopStub = sandbox.stub(localProxy, 'stop') + + await assert.rejects( + async () => await localProxy.start('us-east-1', 'source-token', 9229), + /WebSocket failed/, + 'Should throw error on start failure' + ) + + assert(stopStub.calledOnce, 'Should cleanup on start failure') + }) + + it('should stop proxy and cleanup resources', () => { + const stopPingIntervalStub = sandbox.stub(localProxy as any, 'stopPingInterval') + const closeWebSocketStub = sandbox.stub(localProxy as any, 'closeWebSocket') + const closeTcpServerStub = sandbox.stub(localProxy as any, 'closeTcpServer') + + // Set up some state + ;(localProxy as any).isConnected = true + ;(localProxy as any).reconnectAttempts = 5 + ;(localProxy as any).clientToken = 'test-token' + + localProxy.stop() + + assert(stopPingIntervalStub.calledOnce, 'Should stop ping interval') + assert(closeWebSocketStub.calledOnce, 'Should close WebSocket') + assert(closeTcpServerStub.calledOnce, 'Should close TCP server') + assert.strictEqual((localProxy as any).isConnected, false, 'Should reset connection state') + assert.strictEqual((localProxy as any).reconnectAttempts, 0, 'Should reset reconnect attempts') + assert.strictEqual((localProxy as any).clientToken, '', 'Should clear client token') + assert.strictEqual((localProxy as any).isDisposed, true, 'Should mark as disposed') + }) + + it('should handle duplicate stop calls gracefully', () => { + const stopPingIntervalStub = sandbox.stub(localProxy as any, 'stopPingInterval') + + localProxy.stop() + localProxy.stop() // Second call + + // Should not throw error and should handle gracefully + assert(stopPingIntervalStub.calledOnce, 'Should only stop once') + }) + }) + + describe('Message Sending', () => { + beforeEach(async () => { + await (localProxy as any).loadProtobufDefinition() + }) + + it('should send messages when WebSocket is open', () => { + const mockWs = { + readyState: WebSocket.OPEN, + send: sandbox.stub(), + } + + ;(localProxy as any).ws = mockWs + ;(localProxy as any).serviceId = 'WSS' + ;(localProxy as any).sendMessage(1, 1, 1, Buffer.from('test')) + + assert(mockWs.send.calledOnce, 'Should send message') + const sentData = mockWs.send.getCall(0).args[0] + assert(Buffer.isBuffer(sentData), 'Should send buffer data') + assert(sentData.length > 2, 'Should include length prefix') + }) + + it('should not send messages when WebSocket is not open', () => { + const mockWs = { + readyState: WebSocket.CONNECTING, + send: sandbox.stub(), + } + + ;(localProxy as any).ws = mockWs + ;(localProxy as any).sendMessage(1, 1, 1, Buffer.from('test')) + + assert(mockWs.send.notCalled, 'Should not send when WebSocket is not open') + }) + + it('should split large data into chunks', () => { + const mockWs = { + readyState: WebSocket.OPEN, + send: sandbox.stub(), + } + + ;(localProxy as any).ws = mockWs + + // Create data larger than max chunk size (63KB) + const largeData = Buffer.alloc(70 * 1024, 'a') + + ;(localProxy as any).sendData(1, 1, largeData) + + assert(mockWs.send.calledTwice, 'Should split large data into chunks') + }) + }) +}) diff --git a/packages/core/src/test/lambda/remoteDebugging/testUtils.ts b/packages/core/src/test/lambda/remoteDebugging/testUtils.ts new file mode 100644 index 00000000000..67a53b15d61 --- /dev/null +++ b/packages/core/src/test/lambda/remoteDebugging/testUtils.ts @@ -0,0 +1,177 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import sinon from 'sinon' +import { Lambda } from 'aws-sdk' +import { LambdaFunctionNode } from '../../../lambda/explorer/lambdaFunctionNode' +import { InitialData } from '../../../lambda/vue/remoteInvoke/invokeLambda' +import { DebugConfig } from '../../../lambda/remoteDebugging/ldkController' + +/** + * Creates a mock Lambda function configuration for testing + */ +export function createMockFunctionConfig( + overrides: Partial = {} +): Lambda.FunctionConfiguration { + return { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + Runtime: 'nodejs18.x', + Handler: 'index.handler', + Timeout: 30, + Layers: [], + Environment: { Variables: {} }, + Architectures: ['x86_64'], + SnapStart: { ApplyOn: 'None' }, + ...overrides, + } +} + +/** + * Creates a mock Lambda function node for testing + */ +export function createMockFunctionNode(overrides: Partial = {}): LambdaFunctionNode { + const config = createMockFunctionConfig() + return { + configuration: config, + regionCode: 'us-west-2', + localDir: '/local/path', + ...overrides, + } as LambdaFunctionNode +} + +/** + * Creates mock initial data for RemoteInvokeWebview testing + */ +export function createMockInitialData(overrides: Partial = {}): InitialData { + const mockFunctionNode = createMockFunctionNode() + return { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + FunctionRegion: 'us-west-2', + InputSamples: [], + Runtime: 'nodejs18.x', + LocalRootPath: '/local/path', + LambdaFunctionNode: mockFunctionNode, + supportCodeDownload: true, + runtimeSupportsRemoteDebug: true, + regionSupportsRemoteDebug: true, + ...overrides, + } as InitialData +} + +/** + * Creates a mock debug configuration for testing + */ +export function createMockDebugConfig(overrides: Partial = {}): DebugConfig { + return { + functionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + functionName: 'testFunction', + port: 9229, + localRoot: '/local/path', + remoteRoot: '/var/task', + skipFiles: [], + shouldPublishVersion: false, + lambdaTimeout: 900, + layerArn: 'arn:aws:lambda:us-west-2:123456789012:layer:LDKLayerX86:6', + ...overrides, + } +} + +/** + * Creates a mock global state for testing + */ +export function createMockGlobalState(): any { + const stateStorage = new Map() + return { + get: (key: string) => stateStorage.get(key), + tryGet: (key: string, type?: any, defaultValue?: any) => { + const value = stateStorage.get(key) + return value !== undefined ? value : defaultValue + }, + update: async (key: string, value: any) => { + stateStorage.set(key, value) + return Promise.resolve() + }, + } +} + +/** + * Sets up common mocks for VSCode APIs + */ +export function setupVSCodeMocks(sandbox: sinon.SinonSandbox) { + return { + startDebugging: sandbox.stub(), + executeCommand: sandbox.stub(), + onDidTerminateDebugSession: sandbox.stub().returns({ dispose: sandbox.stub() }), + } +} + +/** + * Creates a mock progress reporter for testing + */ +export function createMockProgress(): any { + return { + report: sinon.stub(), + } +} + +/** + * Sets up common debugging state for stop debugging tests + */ +export function setupDebuggingState(controller: any, mockGlobalState: any, qualifier: string = 'v1') { + controller.isDebugging = true + controller.qualifier = qualifier + ;(controller as any).lastDebugStartTime = Date.now() - 5000 // 5 seconds ago + + const mockFunctionConfig = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + } + + return mockGlobalState.update('aws.lambda.remoteDebugSnapshot', mockFunctionConfig) +} + +/** + * Sets up common mock operations for successful cleanup + */ +export function setupMockCleanupOperations(mockLdkClient: any) { + mockLdkClient.stopProxy.resolves(true) + mockLdkClient.removeDebugDeployment.resolves(true) + mockLdkClient.deleteDebugVersion.resolves(true) +} + +/** + * Sets up common mock operations for LdkClient testing + */ +export function setupMockLdkClientOperations(mockLdkClient: any, mockFunctionConfig: any) { + mockLdkClient.getFunctionDetail.resolves(mockFunctionConfig) + mockLdkClient.createOrReuseTunnel.resolves({ + tunnelID: 'tunnel-123', + sourceToken: 'source-token', + destinationToken: 'dest-token', + }) + mockLdkClient.createDebugDeployment.resolves('$LATEST') + mockLdkClient.startProxy.resolves(true) + mockLdkClient.stopProxy.resolves(true) + mockLdkClient.removeDebugDeployment.resolves(true) + mockLdkClient.deleteDebugVersion.resolves(true) +} + +/** + * Sets up common VSCode debug API mocks + */ +export function setupMockVSCodeDebugAPIs(sandbox: sinon.SinonSandbox) { + sandbox.stub(require('vscode').debug, 'startDebugging').resolves(true) + sandbox.stub(require('vscode').commands, 'executeCommand').resolves() + sandbox.stub(require('vscode').debug, 'onDidTerminateDebugSession').returns({ dispose: sandbox.stub() }) +} + +/** + * Sets up mock for revertExistingConfig function + */ +export function setupMockRevertExistingConfig(sandbox: sinon.SinonSandbox) { + return sandbox.stub(require('../../../lambda/remoteDebugging/ldkController'), 'revertExistingConfig').resolves(true) +} diff --git a/packages/core/src/test/lambda/vue/remoteInvoke/invokeLambda.test.ts b/packages/core/src/test/lambda/vue/remoteInvoke/invokeLambda.test.ts index 2a0fcaa0e0d..1b9f4bfde8e 100644 --- a/packages/core/src/test/lambda/vue/remoteInvoke/invokeLambda.test.ts +++ b/packages/core/src/test/lambda/vue/remoteInvoke/invokeLambda.test.ts @@ -471,7 +471,8 @@ describe('RemoteInvokeWebview', () => { createWebviewPanelArgs[1], `Invoke Lambda ${mockFunctionNode.configuration.FunctionName}` ) - assert.deepStrictEqual(createWebviewPanelArgs[2], { viewColumn: -1 }) + // opens in side panel + assert.deepStrictEqual(createWebviewPanelArgs[2], { viewColumn: vscode.ViewColumn.Beside }) }) }) }) diff --git a/packages/core/src/test/lambda/vue/remoteInvoke/invokeLambdaDebugging.test.ts b/packages/core/src/test/lambda/vue/remoteInvoke/invokeLambdaDebugging.test.ts new file mode 100644 index 00000000000..04cce5f9cef --- /dev/null +++ b/packages/core/src/test/lambda/vue/remoteInvoke/invokeLambdaDebugging.test.ts @@ -0,0 +1,595 @@ +/*! + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +import assert from 'assert' +import { RemoteInvokeWebview, InitialData } from '../../../../lambda/vue/remoteInvoke/invokeLambda' +import { LambdaClient, DefaultLambdaClient } from '../../../../shared/clients/lambdaClient' +import * as vscode from 'vscode' +import sinon, { SinonStubbedInstance, createStubInstance } from 'sinon' +import { RemoteDebugController, DebugConfig } from '../../../../lambda/remoteDebugging/ldkController' +import { getTestWindow } from '../../../shared/vscode/window' +import { LambdaFunctionNode } from '../../../../lambda/explorer/lambdaFunctionNode' +import * as downloadLambda from '../../../../lambda/commands/downloadLambda' +import * as uploadLambda from '../../../../lambda/commands/uploadLambda' +import * as appBuilderUtils from '../../../../awsService/appBuilder/utils' +import * as messages from '../../../../shared/utilities/messages' +import globals from '../../../../shared/extensionGlobals' +import fs from '../../../../shared/fs/fs' +import { ToolkitError } from '../../../../shared' +import { createMockDebugConfig } from '../../remoteDebugging/testUtils' + +describe('RemoteInvokeWebview - Debugging Functionality', () => { + let outputChannel: vscode.OutputChannel + let client: SinonStubbedInstance + let remoteInvokeWebview: RemoteInvokeWebview + let data: InitialData + let sandbox: sinon.SinonSandbox + let mockDebugController: SinonStubbedInstance + let mockFunctionNode: LambdaFunctionNode + + beforeEach(() => { + sandbox = sinon.createSandbox() + client = createStubInstance(DefaultLambdaClient) + outputChannel = { + appendLine: sandbox.stub(), + show: sandbox.stub(), + } as unknown as vscode.OutputChannel + + mockFunctionNode = { + configuration: { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + Handler: 'index.handler', + Runtime: 'nodejs18.x', + SnapStart: { ApplyOn: 'None' }, + }, + regionCode: 'us-west-2', + localDir: '/local/path', + } as LambdaFunctionNode + + data = { + FunctionName: 'testFunction', + FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:testFunction', + FunctionRegion: 'us-west-2', + InputSamples: [], + Runtime: 'nodejs18.x', + LocalRootPath: '/local/path', + LambdaFunctionNode: mockFunctionNode, + supportCodeDownload: true, + runtimeSupportsRemoteDebug: true, + regionSupportsRemoteDebug: true, + } as InitialData + + remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, data) + + // Mock RemoteDebugController + mockDebugController = createStubInstance(RemoteDebugController) + sandbox.stub(RemoteDebugController, 'instance').get(() => mockDebugController) + + // Set handler file as available by default to avoid timeout issues + ;(remoteInvokeWebview as any).handlerFileAvailable = true + }) + + afterEach(() => { + sandbox.restore() + }) + + describe('Debug Timer Management', () => { + it('should start debug timer and count down', async () => { + remoteInvokeWebview.startDebugTimer() + + // Check initial state + assert.strictEqual(remoteInvokeWebview.getDebugTimeRemaining(), 60) + + // Wait a bit and check if timer is counting down + await new Promise((resolve) => { + setTimeout(() => { + const timeRemaining = remoteInvokeWebview.getDebugTimeRemaining() + assert(timeRemaining < 60 && timeRemaining > 0, 'Timer should be counting down') + remoteInvokeWebview.stopDebugTimer() + resolve() + }, 1100) // Wait slightly more than 1 second + }) + }) + + it('should stop debug timer', () => { + remoteInvokeWebview.startDebugTimer() + assert(remoteInvokeWebview.getDebugTimeRemaining() > 0) + + remoteInvokeWebview.stopDebugTimer() + assert.strictEqual(remoteInvokeWebview.getDebugTimeRemaining(), 0) + }) + + it('should handle timer expiration by stopping debugging', async () => { + const stopDebuggingStub = sandbox.stub(remoteInvokeWebview, 'stopDebugging').resolves(true) + + // Mock a very short timer for testing + sandbox.stub(remoteInvokeWebview, 'startDebugTimer').callsFake(() => { + // Simulate immediate timer expiration + setTimeout(async () => { + await (remoteInvokeWebview as any).handleTimerExpired() + }, 10) + }) + + remoteInvokeWebview.startDebugTimer() + + // Wait for timer to expire + await new Promise((resolve) => setTimeout(resolve, 50)) + + assert(stopDebuggingStub.calledOnce, 'stopDebugging should be called when timer expires') + }) + }) + + describe('Debug State Management', () => { + it('should reset server state correctly', () => { + // Set up some state + remoteInvokeWebview.startDebugTimer() + + // Mock the debugging state + mockDebugController.isDebugging = true + + remoteInvokeWebview.resetServerState() + + assert.strictEqual(remoteInvokeWebview.getDebugTimeRemaining(), 0) + assert.strictEqual(remoteInvokeWebview.isWebViewDebugging(), false) + }) + + it('should check if ready to invoke when not invoking', () => { + const result = remoteInvokeWebview.checkReadyToInvoke() + assert.strictEqual(result, true) + }) + + it('should show warning when invoke is in progress', () => { + // Mock the window.showWarningMessage through getTestWindow + getTestWindow().onDidShowMessage(() => { + // Message handler for warning + }) + + // Set invoking state + ;(remoteInvokeWebview as any).isInvoking = true + + const result = remoteInvokeWebview.checkReadyToInvoke() + + assert.strictEqual(result, false) + // The warning should be shown but we can't easily verify it in this test setup + }) + + it('should return correct debugging states', () => { + mockDebugController.isDebugging = true + assert.strictEqual(remoteInvokeWebview.isLDKDebugging(), true) + + mockDebugController.isDebugging = false + assert.strictEqual(remoteInvokeWebview.isLDKDebugging(), false) + }) + }) + + describe('Debug Configuration and Validation', () => { + let mockConfig: DebugConfig + + beforeEach(() => { + mockConfig = createMockDebugConfig({ + functionArn: data.FunctionArn, + functionName: data.FunctionName, + }) + }) + + it('should check ready to debug with valid config', async () => { + // Ensure handler file is available to avoid confirmation dialog + ;(remoteInvokeWebview as any).handlerFileAvailable = true + + const result = await remoteInvokeWebview.checkReadyToDebug(mockConfig) + assert.strictEqual(result, true) + }) + + it('should return false when LambdaFunctionNode is undefined', async () => { + remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, { + ...data, + LambdaFunctionNode: undefined, + }) + + const result = await remoteInvokeWebview.checkReadyToDebug(mockConfig) + assert.strictEqual(result, false) + }) + + it('should show warning when handler file is not available', async () => { + const showConfirmationStub = sandbox.stub(messages, 'showConfirmationMessage').resolves(false) + + // Set handler file as not available + ;(remoteInvokeWebview as any).handlerFileAvailable = false + + const result = await remoteInvokeWebview.checkReadyToDebug(mockConfig) + + assert.strictEqual(result, false) + assert(showConfirmationStub.calledOnce) + }) + + it('should show snapstart warning when publishing version with snapstart enabled', async () => { + const showConfirmationStub = sandbox.stub(messages, 'showConfirmationMessage').resolves(false) + + mockConfig.shouldPublishVersion = true + data.LambdaFunctionNode!.configuration.SnapStart = { ApplyOn: 'PublishedVersions' } + + const result = await remoteInvokeWebview.checkReadyToDebug(mockConfig) + + assert.strictEqual(result, false) + assert(showConfirmationStub.calledOnce) + }) + }) + + describe('Debug Session Management', () => { + let mockConfig: DebugConfig + + beforeEach(() => { + mockConfig = createMockDebugConfig({ + functionArn: data.FunctionArn, + functionName: data.FunctionName, + }) + }) + + it('should start debugging successfully', async () => { + // Ensure handler file is available to avoid confirmation dialog + ;(remoteInvokeWebview as any).handlerFileAvailable = true + + mockDebugController.startDebugging.resolves() + mockDebugController.isDebugging = true + + const result = await remoteInvokeWebview.startDebugging(mockConfig) + + assert.strictEqual(result, true) + assert(mockDebugController.startDebugging.calledOnce) + }) + + it('should call stop debugging', async () => { + mockDebugController.isDebugging = true + mockDebugController.stopDebugging.resolves() + + await remoteInvokeWebview.stopDebugging() + + // The method doesn't return a boolean, it returns void + assert(mockDebugController.stopDebugging.calledOnce) + }) + + it('should handle debug pre-check with existing session', async () => { + const showConfirmationStub = sandbox.stub(messages, 'showConfirmationMessage').resolves(true) + const stopDebuggingStub = sandbox.stub(remoteInvokeWebview, 'stopDebugging').resolves(false) + mockDebugController.isDebugging = true + mockDebugController.installDebugExtension.resolves(true) + + // Mock revertExistingConfig - need to import it properly + const ldkController = require('../../../../lambda/remoteDebugging/ldkController') + const revertStub = sandbox.stub(ldkController, 'revertExistingConfig').resolves(true) + + await remoteInvokeWebview.debugPreCheck() + + assert(showConfirmationStub.calledOnce) + assert(stopDebuggingStub.calledOnce) + assert(mockDebugController.installDebugExtension.calledOnce) + assert(revertStub.calledOnce) + }) + }) + + describe('File Operations and Code Management', () => { + it('should prompt for folder selection', async () => { + const mockUri = vscode.Uri.file('/selected/folder') + getTestWindow().onDidShowDialog((d) => d.selectItem(mockUri)) + + const result = await remoteInvokeWebview.promptFolder() + + assert.strictEqual(result, mockUri.fsPath) + assert.strictEqual(remoteInvokeWebview.getLocalPath(), mockUri.fsPath) + }) + + it('should return undefined when no folder is selected', async () => { + getTestWindow().onDidShowDialog((d) => d.close()) + + const result = await remoteInvokeWebview.promptFolder() + + assert.strictEqual(result, undefined) + }) + + it('should try to open handler file successfully', async () => { + const mockHandlerUri = vscode.Uri.file('/local/path/index.js') + sandbox.stub(appBuilderUtils, 'getLambdaHandlerFile').resolves(mockHandlerUri) + sandbox.stub(fs, 'exists').resolves(true) + sandbox.stub(downloadLambda, 'openLambdaFile').resolves() + + const result = await remoteInvokeWebview.tryOpenHandlerFile('/local/path') + + assert.strictEqual(result, true) + assert.strictEqual(remoteInvokeWebview.getHandlerAvailable(), true) + }) + + it('should handle handler file not found', async () => { + sandbox.stub(appBuilderUtils, 'getLambdaHandlerFile').resolves(undefined) + + // Mock the warning message through getTestWindow + getTestWindow().onDidShowMessage(() => { + // Message handler for warning + }) + + const result = await remoteInvokeWebview.tryOpenHandlerFile('/local/path') + + assert.strictEqual(result, false) + assert.strictEqual(remoteInvokeWebview.getHandlerAvailable(), false) + }) + + it('should download remote code successfully', async () => { + const mockUri = vscode.Uri.file('/downloaded/path') + sandbox.stub(downloadLambda, 'runDownloadLambda').resolves(mockUri) + + // Mock workspace state operations + const mockWorkspaceState = { + get: sandbox.stub().returns({}), + update: sandbox.stub().resolves(), + } + sandbox.stub(globals, 'context').value({ + workspaceState: mockWorkspaceState, + }) + + const result = await remoteInvokeWebview.downloadRemoteCode() + + assert.strictEqual(result, mockUri.fsPath) + assert.strictEqual(data.LocalRootPath, mockUri.fsPath) + }) + + it('should handle download failure', async () => { + sandbox.stub(downloadLambda, 'runDownloadLambda').rejects(new Error('Download failed')) + + await assert.rejects( + async () => await remoteInvokeWebview.downloadRemoteCode(), + /Failed to download remote code/ + ) + }) + }) + + describe('File Watching and Code Synchronization', () => { + it('should setup file watcher when local root path exists', () => { + const createFileSystemWatcherStub = sandbox.stub(vscode.workspace, 'createFileSystemWatcher') + const mockWatcher = { + onDidChange: sandbox.stub(), + onDidCreate: sandbox.stub(), + onDidDelete: sandbox.stub(), + } + createFileSystemWatcherStub.returns(mockWatcher as any) + + // Call the private method through reflection + ;(remoteInvokeWebview as any).setupFileWatcher() + + assert(createFileSystemWatcherStub.calledOnce) + assert(mockWatcher.onDidChange.calledOnce) + assert(mockWatcher.onDidCreate.calledOnce) + assert(mockWatcher.onDidDelete.calledOnce) + }) + + it('should handle file changes and prompt for upload', async () => { + const showConfirmationStub = sandbox.stub(messages, 'showMessage').resolves('Yes') + const runUploadDirectoryStub = sandbox.stub(uploadLambda, 'runUploadDirectory').resolves() + + // Mock file watcher setup + let changeHandler: () => Promise + const mockWatcher = { + onDidChange: (handler: () => Promise) => { + changeHandler = handler + }, + onDidCreate: sandbox.stub(), + onDidDelete: sandbox.stub(), + } + sandbox.stub(vscode.workspace, 'createFileSystemWatcher').returns(mockWatcher as any) + + // Setup file watcher + ;(remoteInvokeWebview as any).setupFileWatcher() + + // Trigger file change + await changeHandler!() + + assert(showConfirmationStub.calledOnce) + assert(runUploadDirectoryStub.calledOnce) + }) + }) + + describe('Lambda Invocation with Debugging', () => { + it('should invoke lambda with remote debugging enabled', async () => { + const mockResponse = { + LogResult: Buffer.from('Debug log').toString('base64'), + Payload: '{"result": "debug success"}', + } + client.invoke.resolves(mockResponse) + mockDebugController.isDebugging = true + mockDebugController.qualifier = 'v1' + + const focusStub = sandbox.stub(vscode.commands, 'executeCommand').resolves() + + await remoteInvokeWebview.invokeLambda('{"test": "input"}', 'test', true) + + assert(client.invoke.calledWith(data.FunctionArn, '{"test": "input"}', 'v1')) + assert(focusStub.calledWith('workbench.action.focusFirstEditorGroup')) + }) + + it('should handle timer management during debugging invocation', async () => { + const mockResponse = { + LogResult: Buffer.from('Debug log').toString('base64'), + Payload: '{"result": "debug success"}', + } + client.invoke.resolves(mockResponse) + mockDebugController.isDebugging = true + + const stopTimerStub = sandbox.stub(remoteInvokeWebview, 'stopDebugTimer') + const startTimerStub = sandbox.stub(remoteInvokeWebview, 'startDebugTimer') + + await remoteInvokeWebview.invokeLambda('{"test": "input"}', 'test', true) + + // Timer should be stopped at least once during invoke + assert(stopTimerStub.calledOnce) + assert(startTimerStub.calledOnce) // Called after invoke + }) + }) + + describe('Dispose and Cleanup', () => { + it('should dispose server and clean up resources', async () => { + // Set up debugging state and disposables + ;(remoteInvokeWebview as any).debugging = true + mockDebugController.isDebugging = true + + // Mock disposables + const mockDisposable = { dispose: sandbox.stub() } + ;(remoteInvokeWebview as any).watcherDisposable = mockDisposable + ;(remoteInvokeWebview as any).fileWatcherDisposable = mockDisposable + + await remoteInvokeWebview.disposeServer() + + assert(mockDisposable.dispose.calledTwice) + assert(mockDebugController.stopDebugging.calledOnce) + }) + + it('should handle dispose when not debugging', async () => { + mockDebugController.isDebugging = false + + const mockDisposable = { dispose: sandbox.stub() } + ;(remoteInvokeWebview as any).watcherDisposable = mockDisposable + + await remoteInvokeWebview.disposeServer() + + assert(mockDisposable.dispose.calledOnce) + }) + }) + + describe('Debug Session Event Handling', () => { + it('should handle debug session termination', async () => { + const resetStateStub = sandbox.stub(remoteInvokeWebview, 'resetServerState') + + // Mock debug session termination event + let terminationHandler: (session: vscode.DebugSession) => Promise + sandbox.stub(vscode.debug, 'onDidTerminateDebugSession').callsFake((handler) => { + terminationHandler = handler + return { dispose: sandbox.stub() } + }) + + // Initialize the webview to set up event handlers + remoteInvokeWebview.init() + + // Simulate debug session termination + const mockSession = { name: 'test-session' } as vscode.DebugSession + await terminationHandler!(mockSession) + + assert(resetStateStub.calledOnce) + }) + }) + + describe('Debugging Flow', () => { + let mockConfig: DebugConfig + + beforeEach(() => { + mockConfig = createMockDebugConfig({ + functionArn: data.FunctionArn, + functionName: data.FunctionName, + }) + + // Mock telemetry to avoid issues + sandbox.stub(require('../../../../shared/telemetry/telemetry'), 'telemetry').value({ + lambda_invokeRemote: { + emit: sandbox.stub(), + }, + }) + }) + + it('should handle complete debugging workflow', async () => { + // Setup mocks for successful debugging + mockDebugController.startDebugging.resolves() + mockDebugController.stopDebugging.resolves() + mockDebugController.isDebugging = false + + // Mock the debugging state change after startDebugging is called + mockDebugController.startDebugging.callsFake(async () => { + mockDebugController.isDebugging = true + return Promise.resolve() + }) + + // 1. Start debugging + const startResult = await remoteInvokeWebview.startDebugging(mockConfig) + assert.strictEqual(startResult, true, 'Debug session should start successfully') + + // Set qualifier for invocation + mockDebugController.qualifier = '$LATEST' + + // 2. Test lambda invocation during debugging + const mockResponse = { + LogResult: Buffer.from('Debug invocation log').toString('base64'), + Payload: '{"debugResult": "success"}', + } + client.invoke.resolves(mockResponse) + + await remoteInvokeWebview.invokeLambda('{"debugInput": "test"}', 'integration-test', true) + + // Verify invocation was called with correct parameters + assert(client.invoke.calledWith(data.FunctionArn, '{"debugInput": "test"}', '$LATEST')) + + // 3. Stop debugging + await remoteInvokeWebview.stopDebugging() + + // Verify cleanup operations were called + assert(mockDebugController.stopDebugging.calledOnce, 'Should stop debugging') + }) + + it('should handle debugging failure gracefully', async () => { + // Setup mock for debugging failure + mockDebugController.startDebugging.rejects(new Error('Debug start failed')) + mockDebugController.isDebugging = false + + // Attempt to start debugging - should throw error + try { + await remoteInvokeWebview.startDebugging(mockConfig) + assert.fail('Expected error to be thrown') + } catch (error) { + assert(error instanceof ToolkitError) + assert(error.message.includes('Failed to start debugging')) + assert(error.cause?.message.includes('Debug start failed')) + } + + assert.strictEqual( + remoteInvokeWebview.isWebViewDebugging(), + false, + 'Webview should not be in debugging state' + ) + }) + + it('should handle version publishing workflow', async () => { + // Setup config for version publishing + const versionConfig = { ...mockConfig, shouldPublishVersion: true } + + // Setup mocks for version publishing + mockDebugController.startDebugging.resolves() + mockDebugController.stopDebugging.resolves() + mockDebugController.isDebugging = false + + // Mock the debugging state change after startDebugging is called + mockDebugController.startDebugging.callsFake(async () => { + mockDebugController.isDebugging = true + mockDebugController.qualifier = 'v1' + return Promise.resolve() + }) + + // Start debugging with version publishing + const startResult = await remoteInvokeWebview.startDebugging(versionConfig) + assert.strictEqual(startResult, true, 'Debug session should start successfully') + + // Test invocation with version qualifier + const mockResponse = { + LogResult: Buffer.from('Version debug log').toString('base64'), + Payload: '{"versionResult": "success"}', + } + client.invoke.resolves(mockResponse) + + await remoteInvokeWebview.invokeLambda('{"versionInput": "test"}', 'version-test', true) + + // Should invoke with version qualifier + assert(client.invoke.calledWith(data.FunctionArn, '{"versionInput": "test"}', 'v1')) + + // Stop debugging + await remoteInvokeWebview.stopDebugging() + + assert(mockDebugController.stopDebugging.calledOnce, 'Should stop debugging') + }) + }) +}) diff --git a/packages/core/src/test/shared/applicationBuilder/explorer/nodes/deployedNode.test.ts b/packages/core/src/test/shared/applicationBuilder/explorer/nodes/deployedNode.test.ts index afe8fb54dda..d8c0178593f 100644 --- a/packages/core/src/test/shared/applicationBuilder/explorer/nodes/deployedNode.test.ts +++ b/packages/core/src/test/shared/applicationBuilder/explorer/nodes/deployedNode.test.ts @@ -147,6 +147,7 @@ describe('generateDeployedNode', () => { regionCode: expectedRegionCode, stackName: expectedStackName, resourceTreeEntity: { + Id: 'MyLambdaFunction', Type: 'AWS::Serverless::Function', }, } @@ -237,6 +238,7 @@ describe('generateDeployedNode', () => { regionCode: expectedRegionCode, stackName: expectedStackName, resourceTreeEntity: { + Id: 'my-project-source-bucket-physical-id', Type: 'AWS::S3::Bucket', }, } @@ -284,6 +286,7 @@ describe('generateDeployedNode', () => { regionCode: expectedRegionCode, stackName: expectedStackName, resourceTreeEntity: { + Id: 'my-project-apigw-physical-id', Type: 'AWS::Serverless::Api', }, } @@ -356,6 +359,7 @@ describe('generateDeployedNode', () => { regionCode: expectedRegionCode, stackName: expectedStackName, resourceTreeEntity: { + Id: 'my-unsupported-resource-physical-id', Type: 'AWS::Serverless::UnsupportType', }, } diff --git a/packages/toolkit/.changes/next-release/Feature-ca5ca54f-d5f4-472e-934e-9fa79d783a98.json b/packages/toolkit/.changes/next-release/Feature-ca5ca54f-d5f4-472e-934e-9fa79d783a98.json new file mode 100644 index 00000000000..ab791cd6caa --- /dev/null +++ b/packages/toolkit/.changes/next-release/Feature-ca5ca54f-d5f4-472e-934e-9fa79d783a98.json @@ -0,0 +1,4 @@ +{ + "type": "Feature", + "description": "Lambda Remote Debugging: Remote invoke configuration webview now supports attaching a debugger to directly debug your lambda function in the cloud." +} diff --git a/packages/toolkit/package.json b/packages/toolkit/package.json index 7cb3dfe49cf..86b32c420cd 100644 --- a/packages/toolkit/package.json +++ b/packages/toolkit/package.json @@ -3093,6 +3093,17 @@ } } }, + { + "command": "aws.lambda.remoteDebugging.clearSnapshot", + "title": "%AWS.command.remoteDebugging.clearSnapshot%", + "category": "%AWS.title%", + "enablement": "isCloud9 || !aws.isWebExtHost", + "cloud9": { + "cn": { + "category": "%AWS.title.cn%" + } + } + }, { "command": "aws.invokeLambda", "title": "%AWS.command.invokeLambda%",