add support for extra env variable

function-deployer/app.js

@@ -17,15 +17,27 @@ const {
 const REGION = process.env.AWS_REGION;
 const ROLE_ARN = process.env.ROLE_ARN;
 const LOG_PROCESSOR_ARN = process.env.LOG_PROCESSOR_ARN;
-const PROJECT = `lambda-perf`;
+const PROJECT = "lambda-perf";
+const MAX_RETRY = 20;
+
+const randomIntFromInterval = (min, max) => {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+};
+
+const SHORT_DELAY = randomIntFromInterval(3000, 5000);
+const RETRY_DELAY = randomIntFromInterval(25000, 30000);
 
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const deleteFunction = async (client, functionName) => {
+const deleteFunction = async (client, functionName, nbRetry) => {
+  if (nbRetry > MAX_RETRY) {
+    throw "max retries exceeded";
+  }
   const params = {
     FunctionName: functionName,
   };
   try {
+    console.log(`function ${functionName} is about to be deleted`);
     const command = new DeleteFunctionCommand(params);
     await client.send(command);
     console.log(`function ${functionName} deleted`);
@@ -34,16 +46,17 @@ const deleteFunction = async (client, functionName) => {
       console.log(`function ${functionName} does not exist, skipping deletion`);
     } else {
       console.error(e);
-      throw e;
+      await delay(RETRY_DELAY);
+      await deleteFunction(client, functionName, nbRetry + 1);
     }
   }
 };
 
-async function updateFunction(client, functionName) {
+async function updateFunction(client, functionName, environment) {
   const params = {
     FunctionName: functionName,
     Environment: {
-      Variables: { coldStart: `${Math.random()}` },
+      Variables: { coldStart: `${Math.random()}`, ...environment },
     },
   };
   try {
@@ -58,47 +71,55 @@ async function updateFunction(client, functionName) {
 const createFunction = async (
   client,
   functionName,
-  singleFunction,
+  path,
+  handler,
+  runtime,
   memorySize,
-  architecture
+  architecture,
+  environment,
+  snapStart,
+  nbRetry
 ) => {
-  const sanitizedRuntime = singleFunction.path
-    ? singleFunction.path
-    : singleFunction.runtime.replace(".", "");
+  if (nbRetry > MAX_RETRY) {
+    throw "max retries exceeded";
+  }
   const params = {
     FunctionName: functionName,
-    Handler: singleFunction.handler,
-    Runtime: singleFunction.runtime,
+    Handler: handler,
+    Runtime: runtime,
     Code: {
       S3Bucket: `${PROJECT}-${REGION}`,
-      S3Key: `${sanitizedRuntime}/code_${architecture}.zip`,
+      S3Key: `${path}/code_${architecture}.zip`,
     },
     Role: ROLE_ARN,
-    ...(singleFunction.snapStart && singleFunction.snapStart),
+    ...snapStart,
     MemorySize: memorySize,
     Architectures: [architecture],
+    Environment: {
+      Variables: environment,
+    },
   };
   try {
     console.log(
       `Creation function ${functionName} for ${architecture} (${memorySize})`
     );
     const command = new CreateFunctionCommand(params);
     await client.send(command);
-
-    if (singleFunction.snapStart) {
-      await waitForActive(client, functionName);
-
-      //publish 10 versions
-      for (let i = 0; i < 10; i++) {
-        //update variables for publishing new version
-        await updateFunction(client, functionName);
-        await delay(10000);
-        const resp = await publishVersion(client, functionName, 0);
-      }
-    }
   } catch (e) {
     console.error(e);
-    throw e;
+    await delay(RETRY_DELAY);
+    await createFunction(
+      client,
+      functionName,
+      path,
+      handler,
+      runtime,
+      memorySize,
+      architecture,
+      environment,
+      snapStart,
+      nbRetry + 1
+    );
   }
 };
 
@@ -108,7 +129,7 @@ const waitForActive = async (client, functionName) => {
   console.log(`waiting for function ${functionName} to be active`, func);
   while (func.Configuration.State !== "Active") {
     console.log(`waiting for function ${functionName} to be active`);
-    await delay(1000);
+    await delay(SHORT_DELAY);
     func = await getFunction(client, functionName);
   }
 };
@@ -126,7 +147,7 @@ const getFunction = async (client, functionName) => {
   }
 };
 const publishVersion = async (client, functionName, nbRetry) => {
-  if (nbRetry > 5) {
+  if (nbRetry > MAX_RETRY) {
     throw "max retries exceeded";
   }
   const params = {
@@ -140,12 +161,15 @@ const publishVersion = async (client, functionName, nbRetry) => {
     );
   } catch (e) {
     console.error(e);
-    await delay(20000);
+    await delay(RETRY_DELAY);
     await publishVersion(client, functionName, nbRetry + 1);
   }
 };
 
-const deleteLogGroup = async (client, functionName) => {
+const deleteLogGroup = async (client, functionName, nbRetry) => {
+  if (nbRetry > MAX_RETRY) {
+    throw "max retries exceeded";
+  }
   const params = {
     logGroupName: `/aws/lambda/${functionName}`,
   };
@@ -159,13 +183,16 @@ const deleteLogGroup = async (client, functionName) => {
         `loggroup ${params.logGroupName} does not exist, skipping deletion`
       );
     } else {
-      console.error(e);
-      throw e;
+      await delay(RETRY_DELAY);
+      await deleteLogGroup(client, functionName, nbRetry + 1);
     }
   }
 };
 
-const createLogGroup = async (client, functionName) => {
+const createLogGroup = async (client, functionName, nbRetry) => {
+  if (nbRetry > MAX_RETRY) {
+    throw "max retries exceeded";
+  }
   const params = {
     logGroupName: `/aws/lambda/${functionName}`,
   };
@@ -174,12 +201,15 @@ const createLogGroup = async (client, functionName) => {
     await client.send(command);
     console.log(`log group ${params.logGroupName} created`);
   } catch (e) {
-    console.error(e);
-    throw e;
+    await delay(RETRY_DELAY);
+    await createLogGroup(client, functionName, nbRetry + 1);
   }
 };
 
-const createSubscriptionFilter = async (client, functionName) => {
+const createSubscriptionFilter = async (client, functionName, nbRetry) => {
+  if (nbRetry > MAX_RETRY) {
+    throw "max retries exceeded";
+  }
   const params = {
     destinationArn: LOG_PROCESSOR_ARN,
     filterName: `report-log-from-${functionName}`,
@@ -191,12 +221,15 @@ const createSubscriptionFilter = async (client, functionName) => {
     await client.send(command);
     console.log(`subscription ${params.filterName} created`);
   } catch (e) {
-    console.error(e);
-    throw e;
+    await delay(RETRY_DELAY);
+    await createSubscriptionFilter(client, functionName, nbRetry + 1);
   }
 };
 
-const addPermission = async (client, functionName) => {
+const addPermission = async (client, functionName, nbRetry) => {
+  if (nbRetry > MAX_RETRY) {
+    throw "max retries exceeded";
+  }
   const params = {
     FunctionName: functionName,
     Action: "lambda:InvokeFunction",
@@ -209,57 +242,88 @@ const addPermission = async (client, functionName) => {
     console.log(`permission added to ${functionName}`);
   } catch (e) {
     console.error(e);
+    await delay(RETRY_DELAY);
+    await addPermission(client, functionName, nbRetry + 1);
   }
 };
 
 const deploy = async (
   lambdaClient,
   cloudWatchLogsClient,
+  path,
+  slug,
+  handler,
+  runtime,
   memorySize,
-  architecture
+  architecture,
+  environment,
+  snapStart
 ) => {
-  const runtimes = require("../manifest.json").runtimes;
-  for (const singleFunction of runtimes) {
-    if (singleFunction.architectures.includes(architecture)) {
-      const functionSufix = singleFunction.path
-        ? singleFunction.path
-        : singleFunction.runtime.replace(".", "");
-      const functionName = `${PROJECT}-${functionSufix}-${memorySize}-${architecture}`;
-      try {
-        await deleteFunction(lambdaClient, functionName);
-        await createFunction(
-          lambdaClient,
-          functionName,
-          singleFunction,
-          memorySize,
-          architecture
-        );
-        await deleteLogGroup(cloudWatchLogsClient, functionName);
-        await createLogGroup(cloudWatchLogsClient, functionName);
-        await createSubscriptionFilter(cloudWatchLogsClient, functionName);
-      } catch (e) {
-        console.error(e);
-        throw e;
+  const functionSufix = slug ? slug : path;
+  const functionName = `${PROJECT}-${functionSufix}-${memorySize}-${architecture}`;
+  try {
+    await deleteFunction(lambdaClient, functionName, 0);
+    await createFunction(
+      lambdaClient,
+      functionName,
+      path,
+      handler,
+      runtime,
+      memorySize,
+      architecture,
+      environment,
+      snapStart,
+      0
+    );
+    if (snapStart) {
+      await waitForActive(lambdaClient, functionName);
+
+      //publish 10 versions
+      for (let i = 0; i < 10; i++) {
+        //update variables for publishing new version
+        await updateFunction(lambdaClient, functionName, environment);
+        await delay(SHORT_DELAY);
+        await publishVersion(lambdaClient, functionName, 0);
       }
-      await delay(5000);
-    } else {
-      console.log(
-        `Skipping ${singleFunction.path} as it's not available for ${architecture}`
-      );
     }
+    await deleteLogGroup(cloudWatchLogsClient, functionName, 0);
+    await createLogGroup(cloudWatchLogsClient, functionName, 0);
+    await createSubscriptionFilter(cloudWatchLogsClient, functionName, 0);
+  } catch (e) {
+    throw e;
   }
 };
 
-exports.handler = async (_, context) => {
+exports.handler = async (event, context) => {
   try {
-    console.log("clientContext = ", context.clientContext);
-    const { memorySize, architecture } = context.clientContext;
+    console.log("event = ", event);
+    const {
+      memorySize,
+      architecture,
+      path,
+      slug,
+      handler,
+      runtime,
+      environment,
+      snapStart,
+    } = event;
     const lambdaClient = new LambdaClient({ region: REGION });
     const cloudWatchLogsClient = new CloudWatchLogsClient({
       region: REGION,
     });
-    await addPermission(lambdaClient, LOG_PROCESSOR_ARN);
-    await deploy(lambdaClient, cloudWatchLogsClient, memorySize, architecture);
+    //await addPermission(lambdaClient, LOG_PROCESSOR_ARN);
+    await deploy(
+      lambdaClient,
+      cloudWatchLogsClient,
+      path,
+      slug,
+      handler,
+      runtime,
+      memorySize,
+      architecture,
+      environment,
+      snapStart
+    );
     return {
       statusCode: 200,
       body: JSON.stringify("success"),