fix(aws-lambda, nextjs-component): ensure we wait until lambda functions are ready before using them (#1982)

Author: dphang

packages/serverless-components/aws-lambda/__mocks__/aws-sdk.mock.ts

@@ -15,6 +15,9 @@ export const mockCreateFunctionPromise = promisifyMock(mockCreateFunction);
 export const mockPublishVersion = jest.fn();
 export const mockPublishVersionPromise = promisifyMock(mockPublishVersion);
 
+export const mockGetFunction = jest.fn();
+export const mockGetFunctionPromise = promisifyMock(mockGetFunction);
+
 export const mockGetFunctionConfiguration = jest.fn();
 export const mockGetFunctionConfigurationPromise = promisifyMock(
   mockGetFunctionConfiguration
@@ -87,6 +90,7 @@ export default {
     tagResource: mockTagResource,
     untagResource: mockUntagResource,
     listVersionsByFunction: mockListVersionsByFunction,
-    deleteFunction: mockDeleteFunction
+    deleteFunction: mockDeleteFunction,
+    getFunction: mockGetFunction
   }))
 };

packages/serverless-components/aws-lambda/__tests__/publishVersion.test.ts

@@ -3,6 +3,8 @@ import { createComponent, createTmpDir } from "../test-utils";
 import {
   mockCreateFunction,
   mockCreateFunctionPromise,
+  mockGetFunction,
+  mockGetFunctionPromise,
   mockPublishVersion,
   mockPublishVersionPromise,
   mockGetFunctionConfigurationPromise,
@@ -44,6 +46,12 @@ describe("publishVersion", () => {
       FunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:my-func",
       CodeSha256: "LQT0VA="
     });
+    mockGetFunctionPromise.mockResolvedValue({
+      Configuration: {
+        State: "Active",
+        LastUpdateStatus: "Successful"
+      }
+    });
 
     component = await createComponent();
   });

packages/serverless-components/aws-lambda/__tests__/waitLambdaReady.test.ts

@@ -0,0 +1,44 @@
+import {
+  mockGetFunctionPromise,
+  mockGetFunction
+} from "../__mocks__/aws-sdk.mock";
+import { waitUntilReady } from "../src/waitUntilReady";
+import { jest } from "@jest/globals";
+
+jest.mock("aws-sdk", () => require("../__mocks__/aws-sdk.mock"));
+
+describe("waitLambdaReady", () => {
+  it("waits until lambda is ready", async () => {
+    mockGetFunctionPromise.mockResolvedValueOnce({
+      Configuration: {
+        State: "Pending",
+        LastUpdateStatus: "InProgress"
+      }
+    });
+
+    mockGetFunctionPromise.mockResolvedValueOnce({
+      Configuration: {
+        State: "Active",
+        LastUpdateStatus: "Successful"
+      }
+    });
+
+    const ready = await waitUntilReady(
+      {
+        debug: () => {
+          // intentionally empty
+        }
+      },
+      "test-function",
+      "us-east-1",
+      1
+    );
+
+    expect(ready).toBe(true);
+
+    expect(mockGetFunction).toBeCalledWith({
+      FunctionName: "test-function"
+    });
+    expect(mockGetFunction).toBeCalledTimes(2); // since first time it's mocked as not ready
+  });
+});

packages/serverless-components/aws-lambda/src/component.ts

@@ -11,6 +11,7 @@ import {
   configChanged,
   pack
 } from "./utils";
+import { waitUntilReady } from "./waitUntilReady";
 
 const outputsList = [
   "name",
@@ -121,6 +122,9 @@ class AwsLambda extends Component {
       await deleteLambda({ lambda, name: this.state.name });
     }
 
+    // Wait for Lambda to be in a ready state
+    await waitUntilReady(this.context, config.name, config.region);
+
     this.context.debug(
       `Successfully deployed lambda ${config.name} in the ${config.region} region.`
     );

packages/serverless-components/aws-lambda/src/waitUntilReady.ts

@@ -0,0 +1,32 @@
+import AWS from "aws-sdk";
+
+/**
+ * Wait up to 10 minutes for the Lambda to be ready.
+ * This is needed due to: https://docs.aws.amazon.com/lambda/latest/dg/functions-states.html
+ */
+export const waitUntilReady = async (
+  context: any,
+  fnName: string,
+  region: string,
+  pollInterval = 5000
+): Promise<boolean> => {
+  const lambda: AWS.Lambda = new AWS.Lambda({ region });
+  const startDate = new Date();
+  const startTime = startDate.getTime();
+  const waitDurationMillis = 600000; // 10 minutes max wait time
+
+  context.debug(`Waiting up to 600 seconds for Lambda ${fnName} to be ready.`);
+
+  while (new Date().getTime() - startTime < waitDurationMillis) {
+    const {
+      Configuration: { LastUpdateStatus, State }
+    } = await lambda.getFunction({ FunctionName: fnName }).promise();
+
+    if (State === "Active" && LastUpdateStatus === "Successful") {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, pollInterval)); // retry every 5 seconds
+  }
+
+  return false;
+};

packages/serverless-components/nextjs-component/__mocks__/@sls-next/aws-lambda/dist/waitUntilReady.js

@@ -0,0 +1,8 @@
+import { jest } from "@jest/globals";
+
+const mockWaitUtilReady = jest.fn();
+
+module.exports = {
+  mockWaitUtilReady,
+  waitUntilReady: mockWaitUtilReady
+};

packages/serverless-components/nextjs-component/src/component.ts

@@ -33,7 +33,6 @@ import type {
 import { execSync } from "child_process";
 import AWS from "aws-sdk";
 import { removeLambdaVersions } from "@sls-next/aws-lambda/dist/removeLambdaVersions";
-
 // Message when deployment is explicitly skipped
 const SKIPPED_DEPLOY = "SKIPPED_DEPLOY";