sst 2.18.3 → 2.19.0

package/constructs/Function.js

@@ -12,17 +12,20 @@ import * as functionUrlCors from "./util/functionUrlCors.js";
 import url from "url";
 import { useDeferredTasks } from "./deferred_task.js";
 import { useProject } from "../project.js";
+import { VisibleError } from "../error.js";
 import { useRuntimeHandlers } from "../runtime/handlers.js";
 import { createAppContext } from "./context.js";
 import { useWarning } from "./util/warning.js";
-import { Architecture, AssetCode, Code, Function as CDKFunction, FunctionUrlAuthType, LayerVersion, Runtime as CDKRuntime, Tracing, } from "aws-cdk-lib/aws-lambda";
+import { Architecture, AssetCode, Code, Function as CDKFunction, FunctionUrlAuthType, Handler as CDKHandler, LayerVersion, Runtime as CDKRuntime, Tracing, } from "aws-cdk-lib/aws-lambda";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { Token, Size as CDKSize, Duration as CDKDuration, } from "aws-cdk-lib/core";
 import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { StringParameter } from "aws-cdk-lib/aws-ssm";
+import { Platform } from "aws-cdk-lib/aws-ecr-assets";
 import { useBootstrap } from "../bootstrap.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const supportedRuntimes = {
+    container: CDKRuntime.FROM_IMAGE,
     rust: CDKRuntime.PROVIDED_AL2,
     nodejs: CDKRuntime.NODEJS,
     "nodejs4.3": CDKRuntime.NODEJS_4_3,
@@ -38,6 +41,7 @@ const supportedRuntimes = {
     "python3.7": CDKRuntime.PYTHON_3_7,
     "python3.8": CDKRuntime.PYTHON_3_8,
     "python3.9": CDKRuntime.PYTHON_3_9,
+    "python3.10": CDKRuntime.PYTHON_3_10,
     "dotnetcore1.0": CDKRuntime.DOTNET_CORE_1,
     "dotnetcore2.0": CDKRuntime.DOTNET_CORE_2,
     "dotnetcore2.1": CDKRuntime.DOTNET_CORE_2_1,
@@ -95,7 +99,7 @@ export class Function extends CDKFunction {
                 return Architecture.ARM_64;
             if (props.architecture === "x86_64")
                 return Architecture.X86_64;
-            return undefined;
+            return Architecture.X86_64;
         })();
         const memorySize = Function.normalizeMemorySize(props.memorySize);
         const diskSize = Function.normalizeDiskSize(props.diskSize);
@@ -146,17 +150,30 @@ export class Function extends CDKFunction {
             }
             super(scope, id, {
                 ...props,
+                ...(props.runtime === "container"
+                    ? {
+                        code: Code.fromAssetImage(path.resolve(__dirname, "../support/bridge"), {
+                            ...(architecture?.dockerPlatform
+                                ? { platform: Platform.custom(architecture.dockerPlatform) }
+                                : {}),
+                        }),
+                        handler: CDKHandler.FROM_IMAGE,
+                        runtime: CDKRuntime.FROM_IMAGE,
+                        layers: undefined,
+                    }
+                    : {
+                        runtime: CDKRuntime.NODEJS_16_X,
+                        code: Code.fromAsset(path.resolve(__dirname, "../support/bridge")),
+                        handler: "bridge.handler",
+                        layers: [],
+                    }),
                 architecture,
-                code: Code.fromAsset(path.resolve(__dirname, "../support/bridge")),
-                handler: "bridge.handler",
                 functionName,
-                runtime: CDKRuntime.NODEJS_16_X,
                 memorySize,
                 ephemeralStorageSize: diskSize,
                 timeout,
                 tracing,
                 environment: props.environment,
-                layers: [],
                 logRetention,
                 logRetentionRetryOptions: logRetention && { maxRetries: 100 },
                 retryAttempts: 0,
@@ -185,17 +202,30 @@ export class Function extends CDKFunction {
         else {
             super(scope, id, {
                 ...props,
+                ...(props.runtime === "container"
+                    ? {
+                        code: Code.fromAssetImage(props.handler, {
+                            ...(architecture?.dockerPlatform
+                                ? { platform: Platform.custom(architecture.dockerPlatform) }
+                                : {}),
+                        }),
+                        handler: CDKHandler.FROM_IMAGE,
+                        runtime: CDKRuntime.FROM_IMAGE,
+                        layers: undefined,
+                    }
+                    : {
+                        code: Code.fromInline("export function placeholder() {}"),
+                        handler: "index.placeholder",
+                        runtime: CDKRuntime.NODEJS_16_X,
+                        layers: Function.buildLayers(scope, id, props),
+                    }),
                 architecture,
-                code: Code.fromInline("export function placeholder() {}"),
-                handler: "index.placeholder",
                 functionName,
-                runtime: CDKRuntime.NODEJS_16_X,
                 memorySize,
                 ephemeralStorageSize: diskSize,
                 timeout,
                 tracing,
                 environment: props.environment,
-                layers: Function.buildLayers(scope, id, props),
                 logRetention,
                 logRetentionRetryOptions: logRetention && { maxRetries: 100 },
             });
@@ -203,11 +233,14 @@ export class Function extends CDKFunction {
                 // Build function
                 const result = await useRuntimeHandlers().build(this.node.addr, "deploy");
                 if (result.type === "error") {
-                    throw new Error([
+                    throw new VisibleError([
                         `Failed to build function "${props.handler}"`,
                         ...result.errors,
                     ].join("\n"));
                 }
+                // No need to update code if runtime is container
+                if (props.runtime === "container")
+                    return;
                 // Update code
                 const cfnFunction = this.node.defaultChild;
                 const code = AssetCode.fromAsset(result.out);

package/constructs/NextjsSite.js

@@ -5,7 +5,7 @@ import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { Code, Runtime, Architecture, Function as CdkFunction, FunctionUrlAuthType, } from "aws-cdk-lib/aws-lambda";
 import { Distribution, ViewerProtocolPolicy, AllowedMethods, CachedMethods, } from "aws-cdk-lib/aws-cloudfront";
-import { S3Origin, HttpOrigin } from "aws-cdk-lib/aws-cloudfront-origins";
+import { HttpOrigin } from "aws-cdk-lib/aws-cloudfront-origins";
 import { Rule, Schedule } from "aws-cdk-lib/aws-events";
 import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
 import { Queue } from "aws-cdk-lib/aws-sqs";
@@ -29,7 +29,7 @@ import { toCdkSize } from "./util/size.js";
 export class NextjsSite extends SsrSite {
     constructor(scope, id, props) {
         super(scope, id, {
-            buildCommand: "npx --yes open-next@2.0.3 build",
+            buildCommand: "npx --yes open-next@2.0.4 build",
             ...props,
         });
         this.deferredTaskCallbacks.push(() => {
@@ -282,9 +282,6 @@ export class NextjsSite extends SsrSite {
     createCloudFrontDistributionForEdge() {
         const { cdk } = this.props;
         const cfDistributionProps = cdk?.distribution || {};
-        const s3Origin = new S3Origin(this.cdk.bucket, {
-            originPath: "/" + this.buildConfig.clientBuildS3KeyPrefix,
-        });
         const cachePolicy = cdk?.serverCachePolicy ??
             this.buildServerCachePolicy([
                 "accept",
@@ -292,7 +289,7 @@ export class NextjsSite extends SsrSite {
                 "next-router-prefetch",
                 "next-router-state-tree",
             ]);
-        const serverBehavior = this.buildDefaultBehaviorForEdge(s3Origin, cachePolicy);
+        const serverBehavior = this.buildDefaultBehaviorForEdge(cachePolicy);
         return new Distribution(this, "Distribution", {
             // these values can be overwritten by cfDistributionProps
             defaultRootObject: "",

package/constructs/SsrSite.d.ts

@@ -4,7 +4,6 @@ import { IFunction as ICdkFunction, FunctionProps } from "aws-cdk-lib/aws-lambda
 import { IHostedZone } from "aws-cdk-lib/aws-route53";
 import { Distribution, ICachePolicy, IResponseHeadersPolicy, BehaviorOptions, CachePolicy, Function as CfFunction, FunctionEventType as CfFunctionEventType } from "aws-cdk-lib/aws-cloudfront";
 import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
-import { S3Origin } from "aws-cdk-lib/aws-cloudfront-origins";
 import { SSTConstruct } from "./Construct.js";
 import { NodeJSProps } from "./Function.js";
 import { SsrFunction } from "./SsrFunction.js";
@@ -224,6 +223,7 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
     private serverLambdaForDev?;
     protected bucket: Bucket;
     private cfFunction;
+    private s3Origin;
     private distribution;
     private hostedZone?;
     private certificate?;
@@ -286,12 +286,13 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
     private grantServerS3Permissions;
     private grantServerCloudFrontPermissions;
     private validateCloudFrontDistributionSettings;
+    private createCloudFrontS3Origin;
     private createCloudFrontFunction;
     protected createCloudFrontDistributionForRegional(): Distribution;
     protected createCloudFrontDistributionForEdge(): Distribution;
     protected buildDistributionDomainNames(): string[];
     protected buildDefaultBehaviorForRegional(cachePolicy: ICachePolicy): BehaviorOptions;
-    protected buildDefaultBehaviorForEdge(origin: S3Origin, cachePolicy: ICachePolicy): BehaviorOptions;
+    protected buildDefaultBehaviorForEdge(cachePolicy: ICachePolicy): BehaviorOptions;
     protected buildBehaviorFunctionAssociations(): {
         eventType: CfFunctionEventType;
         function: CfFunction;

package/constructs/SsrSite.js

@@ -54,6 +54,7 @@ export class SsrSite extends Construct {
     serverLambdaForDev;
     bucket;
     cfFunction;
+    s3Origin;
     distribution;
     hostedZone;
     certificate;
@@ -79,7 +80,7 @@ export class SsrSite extends Construct {
         useSites().add(id, this.constructor.name, this.props);
         if (this.doNotDeploy) {
             // @ts-ignore
-            this.cfFunction = this.bucket = this.distribution = null;
+            this.cfFunction = this.bucket = this.s3Origin = this.distribution = null;
             this.serverLambdaForDev = this.createFunctionForDev();
             return;
         }
@@ -103,6 +104,7 @@ export class SsrSite extends Construct {
         this.certificate = this.createCertificate();
         // Create CloudFront
         this.validateCloudFrontDistributionSettings();
+        this.s3Origin = this.createCloudFrontS3Origin();
         this.cfFunction = this.createCloudFrontFunction();
         this.distribution = this.props.edge
             ? this.createCloudFrontDistributionForEdge()
@@ -502,6 +504,11 @@ export class SsrSite extends Construct {
             throw new Error(`Do not configure the "cfDistribution.domainNames". Use the "customDomain" to configure the domain name.`);
         }
     }
+    createCloudFrontS3Origin() {
+        return new S3Origin(this.bucket, {
+            originPath: "/" + (this.buildConfig.clientBuildS3KeyPrefix ?? ""),
+        });
+    }
     createCloudFrontFunction() {
         return new CfFunction(this, "CloudFrontFunction", {
             code: CfFunctionCode.fromInline(`
@@ -534,7 +541,6 @@ function handler(event) {
     createCloudFrontDistributionForEdge() {
         const { cdk } = this.props;
         const cfDistributionProps = cdk?.distribution || {};
-        const s3Origin = new S3Origin(this.bucket);
         const cachePolicy = cdk?.serverCachePolicy ?? this.buildServerCachePolicy();
         return new Distribution(this, "Distribution", {
             // these values can be overwritten by cfDistributionProps
@@ -544,7 +550,7 @@ function handler(event) {
             // these values can NOT be overwritten by cfDistributionProps
             domainNames: this.buildDistributionDomainNames(),
             certificate: this.certificate,
-            defaultBehavior: this.buildDefaultBehaviorForEdge(s3Origin, cachePolicy),
+            defaultBehavior: this.buildDefaultBehaviorForEdge(cachePolicy),
             additionalBehaviors: {
                 ...(cfDistributionProps.additionalBehaviors || {}),
             },
@@ -595,12 +601,12 @@ function handler(event) {
             ],
         };
     }
-    buildDefaultBehaviorForEdge(origin, cachePolicy) {
+    buildDefaultBehaviorForEdge(cachePolicy) {
         const { cdk } = this.props;
         const cfDistributionProps = cdk?.distribution || {};
         return {
             viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-            origin,
+            origin: this.s3Origin,
             allowedMethods: AllowedMethods.ALLOW_ALL,
             cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
             compress: true,
@@ -636,9 +642,7 @@ function handler(event) {
         const publicDir = path.join(this.props.path, this.buildConfig.clientBuildOutputDir);
         for (const item of fs.readdirSync(publicDir)) {
             const isDir = fs.statSync(path.join(publicDir, item)).isDirectory();
-            this.distribution.addBehavior(isDir ? `${item}/*` : item, new S3Origin(this.bucket, {
-                originPath: "/" + (this.buildConfig.clientBuildS3KeyPrefix ?? ""),
-            }), {
+            this.distribution.addBehavior(isDir ? `${item}/*` : item, this.s3Origin, {
                 viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
                 allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
                 cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.18.3",
+  "version": "2.19.0",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/container.d.ts

@@ -0,0 +1 @@
+export declare const useContainerHandler: () => Promise<void>;

package/runtime/handlers/container.js

@@ -0,0 +1,124 @@
+import { useRuntimeHandlers } from "../handlers.js";
+import { useRuntimeWorkers } from "../workers.js";
+import { Context } from "../../context/context.js";
+import { VisibleError } from "../../error.js";
+import { spawn } from "child_process";
+import { useRuntimeServerConfig } from "../server.js";
+import { isChild } from "../../util/fs.js";
+import { execAsync } from "../../util/process.js";
+export const useContainerHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
+    const handlers = useRuntimeHandlers();
+    const containers = new Map();
+    const sources = new Map();
+    handlers.register({
+        shouldBuild: (input) => {
+            const parent = sources.get(input.functionID);
+            if (!parent)
+                return false;
+            return isChild(parent, input.file);
+        },
+        canHandle: (input) => input.startsWith("container"),
+        startWorker: async (input) => {
+            const name = `sst-workerID-${input.workerID}-${Date.now()}`;
+            const proc = spawn("docker", [
+                "run",
+                "--rm",
+                "--network=host",
+                `--name=${name}`,
+                ...Object.entries({
+                    ...input.environment,
+                    IS_LOCAL: "true",
+                    AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`,
+                })
+                    .map(([key, value]) => ["-e", `${key}=${value}`])
+                    .flat(),
+                `sst-dev:${input.functionID}`,
+            ], {
+                env: {
+                    ...process.env,
+                },
+                cwd: input.out,
+            });
+            proc.on("exit", () => {
+                workers.exited(input.workerID);
+            });
+            proc.stdout.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            proc.stderr.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            containers.set(input.workerID, name);
+        },
+        stopWorker: async (workerID) => {
+            const name = containers.get(workerID);
+            if (name) {
+                try {
+                    // note:
+                    // - calling `docker kill` kills the docker process much faster than `docker stop`
+                    // - process.kill() does not work on docker processes
+                    await execAsync(`docker kill ${name}`, {
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    console.error(ex);
+                    throw new VisibleError(`Could not stop docker container ${name}`);
+                }
+                containers.delete(workerID);
+            }
+        },
+        build: async (input) => {
+            const project = input.props.handler;
+            sources.set(input.functionID, project);
+            if (input.mode === "start") {
+                try {
+                    const result = await execAsync(`docker build -t sst-dev:${input.functionID} .`, {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    return {
+                        type: "error",
+                        errors: [String(ex)],
+                    };
+                }
+            }
+            if (input.mode === "deploy") {
+                try {
+                    const platform = input.props.architecture === "arm_64"
+                        ? "linux/arm64"
+                        : "linux/amd64";
+                    await execAsync([
+                        `docker build`,
+                        `-t sst-build:${input.functionID}`,
+                        `--platform ${platform}`,
+                        `.`,
+                    ].join(" "), {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    return {
+                        type: "error",
+                        errors: [String(ex)],
+                    };
+                }
+            }
+            return {
+                type: "success",
+                handler: "not required for container",
+            };
+        },
+    });
+});

package/runtime/handlers/node.js

@@ -177,7 +177,7 @@ export const useNodeHandler = Context.memo(async () => {
                     const json = JSON.parse(await fs
                         .readFile(path.join(src, "package.json"))
                         .then((x) => x.toString()));
-                    fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
+                    await fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
                         dependencies: Object.fromEntries(installPackages.map((x) => [x, json.dependencies?.[x] || "*"])),
                     }));
                     const cmd = ["npm install"];

package/runtime/handlers/python.js

@@ -17,6 +17,7 @@ const RUNTIME_MAP = {
     "python3.7": Runtime.PYTHON_3_7,
     "python3.8": Runtime.PYTHON_3_8,
     "python3.9": Runtime.PYTHON_3_9,
+    "python3.10": Runtime.PYTHON_3_10,
 };
 export const usePythonHandler = Context.memo(async () => {
     const workers = await useRuntimeWorkers();

package/runtime/handlers.d.ts

@@ -1,6 +1,9 @@
 import { FunctionProps } from "../constructs/Function.js";
 declare module "../bus.js" {
     interface Events {
+        "function.build.started": {
+            functionID: string;
+        };
         "function.build.success": {
             functionID: string;
         };
@@ -19,6 +22,7 @@ interface BuildInput {
 interface StartWorkerInput {
     url: string;
     workerID: string;
+    functionID: string;
     environment: Record<string, string>;
     out: string;
     handler: string;

package/runtime/handlers.js

@@ -34,6 +34,7 @@ export const useRuntimeHandlers = Context.memo(() => {
                 const out = path.join(project.paths.artifacts, functionID);
                 await fs.rm(out, { recursive: true, force: true });
                 await fs.mkdir(out, { recursive: true });
+                bus.publish("function.build.started", { functionID });
                 if (func.hooks?.beforeBuild)
                     await func.hooks.beforeBuild(func, out);
                 const built = await handler.build({

package/runtime/workers.js

@@ -43,6 +43,7 @@ export const useRuntimeWorkers = Context.memo(async () => {
         await handler.startWorker({
             ...build,
             workerID: evt.properties.workerID,
+            functionID: evt.properties.functionID,
             environment: evt.properties.env,
             url: `${server.url}/${evt.properties.workerID}/${server.API_VERSION}`,
             runtime: props.runtime,