serverless-offline 13.3.4 → 13.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "13.3.4",
+  "version": "13.4.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "exports": {
@@ -22,7 +22,8 @@
     "test:cov": "NODE_OPTIONS='--experimental-loader @istanbuljs/esm-loader-hook' nyc --reporter=html npm test",
     "test:node": "TEST=node mocha --require ./tests/mochaHooks.cjs",
     "test:unit": "TEST=unit mocha --require ./tests/mochaHooks.cjs",
-    "test:e2e": "TEST=e2e mocha --require ./tests/mochaHooks.cjs"
+    "test:e2e": "TEST=e2e mocha --require ./tests/mochaHooks.cjs",
+    "test:docker": "TEST=docker mocha --require ./tests/mochaHooks.cjs"
   },
   "repository": {
     "type": "git",
@@ -96,7 +97,6 @@
     "luxon": "^3.4.4",
     "node-schedule": "^2.1.1",
     "p-memoize": "^7.1.1",
-    "p-retry": "^6.2.0",
     "velocityjs": "^2.0.6",
     "ws": "^8.16.0"
   },

package/src/config/constants.js

@@ -6,6 +6,8 @@ export const CUSTOM_OPTION = "serverless-offline"
 
 export const DEFAULT_LAMBDA_RUNTIME = "nodejs14.x"
 
+export const DEFAULT_LAMBDA_ARCHITECTURE = "arm64"
+
 // https://docs.aws.amazon.com/lambda/latest/dg/limits.html
 export const DEFAULT_LAMBDA_MEMORY_SIZE = 1024
 // default function timeout in seconds

package/src/config/supportedRuntimes.js

@@ -1,3 +1,4 @@
+/* eslint-disable sort-keys */
 // native runtime support for AWS
 // https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html
 
@@ -6,6 +7,32 @@
 // 'dotnet6',
 // ])
 
+const X86_64 = "x86_64"
+const ARM64 = "arm64"
+
+export const supportedRuntimesArchitecture = {
+  "nodejs14.x": [ARM64, X86_64],
+  "nodejs16.x": [ARM64, X86_64],
+  "nodejs18.x": [ARM64, X86_64],
+  "nodejs20.x": [ARM64, X86_64],
+  "python3.7": [X86_64],
+  "python3.8": [ARM64, X86_64],
+  "python3.9": [ARM64, X86_64],
+  "python3.10": [ARM64, X86_64],
+  "python3.11": [ARM64, X86_64],
+  "ruby2.7": [ARM64, X86_64],
+  "ruby3.2": [ARM64, X86_64],
+  java8: [X86_64],
+  "java8.al2": [ARM64, X86_64],
+  java11: [ARM64, X86_64],
+  java17: [ARM64, X86_64],
+  "go1.x": [X86_64],
+  "dotnetcore3.1": [ARM64, X86_64],
+  provided: [X86_64],
+  dotnet6: [ARM64, X86_64],
+  "provided.al2": [ARM64, X86_64],
+}
+
 // GO
 export const supportedGo = new Set(["go1.x"])
 
@@ -35,8 +62,6 @@ export const supportedPython = new Set([
 // RUBY
 export const supportedRuby = new Set(["ruby2.7", "ruby3.2"])
 
-// deprecated runtimes
-// https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html
 export const supportedRuntimes = new Set([
   // ...supportedDotnetcore,
   ...supportedGo,
@@ -47,10 +72,6 @@ export const supportedRuntimes = new Set([
   ...supportedRuby,
 ])
 
-export const unsupportedDockerRuntimes = new Set([
-  "nodejs14.x",
-  "nodejs16.x",
-  "nodejs18.x",
-  "nodejs20.x",
-  "python3.9",
-])
+// deprecated runtimes
+// https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html
+export const unsupportedDockerRuntimes = new Set([])

package/src/lambda/LambdaFunction.js

@@ -10,6 +10,7 @@ import jszip from "jszip"
 import HandlerRunner from "./handler-runner/index.js"
 import LambdaContext from "./LambdaContext.js"
 import {
+  DEFAULT_LAMBDA_ARCHITECTURE,
   DEFAULT_LAMBDA_MEMORY_SIZE,
   DEFAULT_LAMBDA_RUNTIME,
   DEFAULT_LAMBDA_TIMEOUT,
@@ -57,6 +58,8 @@ export default class LambdaFunction {
 
   #runtime = null
 
+  #architecture = null
+
   #status = "IDLE" // can be 'BUSY' or 'IDLE'
 
   #timeout = null
@@ -91,6 +94,10 @@ export default class LambdaFunction {
 
     this.#runtime =
       functionDefinition.runtime ?? provider.runtime ?? DEFAULT_LAMBDA_RUNTIME
+    this.#architecture =
+      functionDefinition.architecture ??
+      provider.architecture ??
+      DEFAULT_LAMBDA_ARCHITECTURE
 
     this.#timeout =
       (functionDefinition.timeout ??
@@ -136,6 +143,7 @@ export default class LambdaFunction {
 
     // TEMP
     const funOptions = {
+      architecture: this.#architecture,
       codeDir: this.#codeDir,
       functionKey,
       functionName: name,

package/src/lambda/handler-runner/HandlerRunner.js

@@ -32,7 +32,7 @@ export default class HandlerRunner {
     if (useDocker) {
       if (unsupportedDockerRuntimes.has(runtime)) {
         log.warning(
-          `"${runtime}" runtime is not supported with docker. See https://github.com/lambci/docker-lambda`,
+          `"${runtime}" runtime is not supported with docker. See https://github.com/aws/aws-lambda-base-images`,
         )
         throw new Error("Unsupported runtime")
       }

package/src/lambda/handler-runner/docker-runner/DockerContainer.js

@@ -9,8 +9,8 @@ import { execa } from "execa"
 import { ensureDir, pathExists } from "fs-extra"
 import isWsl from "is-wsl"
 import jszip from "jszip"
-import pRetry from "p-retry"
 import DockerImage from "./DockerImage.js"
+import Runtime from "./DockerRuntime.js"
 
 const { stringify } = JSON
 const { floor, log: mathLog } = Math
@@ -24,8 +24,6 @@ export default class DockerContainer {
 
   #env = null
 
-  #functionKey = null
-
   #handler = null
 
   #image = null
@@ -42,13 +40,15 @@ export default class DockerContainer {
 
   #runtime = null
 
+  #architecture = null
+
   #servicePath = null
 
   constructor(
     env,
-    functionKey,
     handler,
     runtime,
+    architecture,
     layers,
     provider,
     servicePath,
@@ -56,23 +56,24 @@ export default class DockerContainer {
   ) {
     this.#dockerOptions = dockerOptions
     this.#env = env
-    this.#functionKey = functionKey
     this.#handler = handler
-    this.#imageNameTag = this.#baseImage(runtime)
+    this.#imageNameTag = this.#baseImage(runtime, architecture)
     this.#image = new DockerImage(this.#imageNameTag)
     this.#layers = layers
     this.#provider = provider
     this.#runtime = runtime
+    this.#architecture = architecture
     this.#servicePath = servicePath
   }
 
-  #baseImage(runtime) {
-    return `lambci/lambda:${runtime}`
+  #baseImage(runtime, architecture) {
+    const runtimeImageTag = new Runtime().getImageNameTag(runtime, architecture)
+    // # Gets the ECR image format like `python:3.7` or `nodejs:16-x86_64`
+    return `public.ecr.aws/lambda/${runtimeImageTag}`
   }
 
   async start(codeDir) {
     await this.#image.pull()
-
     log.debug("Run Docker container...")
 
     let permissions = "ro"
@@ -85,19 +86,17 @@ export default class DockerContainer {
       "-v",
       `${codeDir}:/var/task:${permissions},delegated`,
       "-p",
-      9001,
+      8080,
       "-e",
       "DOCKER_LAMBDA_STAY_OPEN=1", // API mode
       "-e",
       "DOCKER_LAMBDA_WATCH=1", // Watch mode
     ]
-
     if (this.#layers.length > 0) {
       log.verbose(`Found layers, checking provider type`)
 
       if (this.#provider.name.toLowerCase() === "aws") {
         let layerDir = this.#dockerOptions.layersDir
-
         if (!layerDir) {
           layerDir = join(this.#servicePath, ".serverless-offline", "layers")
         }
@@ -135,12 +134,22 @@ export default class DockerContainer {
             this.#dockerOptions.hostServicePath,
           )
         }
-        dockerArgs.push("-v", `${layerDir}:/opt:ro,delegated`)
+        dockerArgs.push("-v", `${layerDir}:/var/runtime:ro,delegated`)
       } else {
         log.warning(
           `Provider ${this.#provider.name} is Unsupported. Layers are only supported on aws.`,
         )
       }
+    } else {
+      log.debug("Looking for bootstrap file")
+      const bootstrapDir = join(this.#servicePath, "bootstrap")
+      if (await pathExists(bootstrapDir)) {
+        log.debug(`Found bootstrap file at ${bootstrapDir}`)
+        dockerArgs.push(
+          "-v",
+          `${bootstrapDir}:/var/runtime/bootstrap:ro,delegated`,
+        )
+      }
     }
 
     entries(this.#env).forEach(([key, value]) => {
@@ -176,7 +185,7 @@ export default class DockerContainer {
         const str = String(data)
         log.error(str)
 
-        if (str.includes("Lambda API listening on port")) {
+        if (str.includes("(cwd=/var/task, handler=)")) {
           resolve()
         }
       })
@@ -195,12 +204,12 @@ export default class DockerContainer {
     // NOTE: `docker port` may output multiple lines.
     //
     // e.g.:
-    // 9001/tcp -> 0.0.0.0:49153
-    // 9001/tcp -> :::49153
+    // 8080/tcp -> 0.0.0.0:49153
+    // 8080/tcp -> :::49153
     //
     // Parse each line until it finds the mapped port.
     for (const line of dockerPortOutput.split("\n")) {
-      const result = line.match(/^9001\/tcp -> (.*):(\d+)$/)
+      const result = line.match(/^8080\/tcp -> (.*):(\d+)$/)
       if (result && result.length > 2) {
         ;[, , containerPort] = result
         break
@@ -212,15 +221,6 @@ export default class DockerContainer {
 
     this.#containerId = containerId
     this.#port = containerPort
-
-    await pRetry(() => this.#ping(), {
-      // default,
-      factor: 2,
-      // milliseconds
-      minTimeout: 10,
-      // default
-      retries: 10,
-    })
   }
 
   async #downloadLayer(layerArn, layerDir) {
@@ -344,19 +344,8 @@ export default class DockerContainer {
     return gateway.split("/")[0]
   }
 
-  async #ping() {
-    const url = `http://${this.#dockerOptions.host}:${this.#port}/2018-06-01/ping`
-    const res = await fetch(url)
-
-    if (!res.ok) {
-      throw new Error(`Failed to fetch from ${url} with ${res.statusText}`)
-    }
-
-    return res.text()
-  }
-
   async request(event) {
-    const url = `http://${this.#dockerOptions.host}:${this.#port}/2015-03-31/functions/${this.#functionKey}/invocations`
+    const url = `http://${this.#dockerOptions.host}:${this.#port}/2015-03-31/functions/function/invocations`
 
     const res = await fetch(url, {
       body: stringify(event),

package/src/lambda/handler-runner/docker-runner/DockerImage.js

@@ -17,11 +17,7 @@ export default class DockerImage {
     log.debug(`Downloading base Docker image... (${imageNameTag})`)
 
     try {
-      await execa("docker", [
-        "pull",
-        "--disable-content-trust=false",
-        imageNameTag,
-      ])
+      await execa("docker", ["pull", imageNameTag])
     } catch (err) {
       log.error(err.stderr)
 

package/src/lambda/handler-runner/docker-runner/DockerRunner.js

@@ -9,9 +9,9 @@ export default class DockerRunner {
   constructor(funOptions, env, dockerOptions) {
     const {
       codeDir,
-      functionKey,
       handler,
       runtime,
+      architecture,
       layers,
       provider,
       servicePath,
@@ -31,9 +31,9 @@ export default class DockerRunner {
 
     this.#container = new DockerContainer(
       env,
-      functionKey,
       handler,
       runtime,
+      architecture,
       layers,
       provider,
       servicePath,

package/src/lambda/handler-runner/docker-runner/DockerRuntime.js

@@ -0,0 +1,33 @@
+import { supportedRuntimesArchitecture } from "../../../config/supportedRuntimes.js"
+
+export default class Runtime {
+  getImageNameTag(runtime, architecture) {
+    let runtimeImageTag = ""
+
+    if (runtime === this.provided) {
+      runtimeImageTag = "provided:alami"
+    } else if (runtime.startsWith("provided")) {
+      runtimeImageTag = runtime.replace(".", ":")
+    } else if (runtime.startsWith("dotnet")) {
+      runtimeImageTag = runtime.replace("dotnet", "dotnet:")
+    } else {
+      const match = /^([a-z]+)(\d[\d.a-z]*)$/.exec(runtime)
+      runtimeImageTag = match ? `${match[1]}:${match[2]}` : runtime
+      runtimeImageTag = runtimeImageTag.replace(".x", "")
+    }
+
+    if (this.hasRuntimeMultiArchImage(runtime)) {
+      runtimeImageTag = `${runtimeImageTag}-${architecture}`
+    }
+
+    return runtimeImageTag
+  }
+
+  hasRuntimeMultiArchImage(runtime) {
+    return (
+      (supportedRuntimesArchitecture[runtime] &&
+        supportedRuntimesArchitecture[runtime].length > 1) ||
+      false
+    )
+  }
+}