Skip to content

🎥 Make videos programmatically with React

Move Lambda invocation and runtime policies behind provider adapters

JonnyBurgerdfda40549da2
diff --git a/packages/lambda/src/functions/aws-server-implementation.ts b/packages/lambda/src/functions/aws-server-implementation.ts
index f6ed501fd4..710c4b17d9 100644
--- a/packages/lambda/src/functions/aws-server-implementation.ts
+++ b/packages/lambda/src/functions/aws-server-implementation.ts
@@ -1,4 +1,5 @@
import {LambdaClientInternals, type AwsProvider} from '@remotion/lambda-client';
+import {RenderInternals} from '@remotion/renderer';
import type {InsideFunctionSpecifics} from '@remotion/serverless';
import {
closeBrowserInstanceImplementation,
@@ -9,9 +10,13 @@ import {
import {NoReactInternals} from 'remotion/no-react';
import {deleteTmpDir} from './helpers/clean-tmpdir';
import {getCurrentRegionInFunctionImplementation} from './helpers/get-current-region';
-import {getFolderFiles} from './helpers/get-folder-files';
+import {getTmpDirStateIfENoSp} from './helpers/get-tmp-dir';
+import {startLeakDetection} from './helpers/leak-detection';
import {makeAwsArtifact} from './helpers/make-aws-artifact';
import {timer} from './helpers/timer';
+import {enableNodeIntrospection} from './helpers/why-is-node-running';
+
+const ENABLE_SLOW_LEAK_DETECTION = false;
export const serverAwsImplementation: InsideFunctionSpecifics<AwsProvider> = {
defaultX264Preset: NoReactInternals.ENABLE_V5_BREAKING_CHANGES
@@ -19,7 +24,16 @@ export const serverAwsImplementation: InsideFunctionSpecifics<AwsProvider> = {
: null,
forgetBrowserEventLoop: forgetBrowserEventLoopImplementation,
closeBrowserInstance: closeBrowserInstanceImplementation,
- getBrowserInstance: getBrowserInstanceImplementation,
+ getBrowserInstance: (options) =>
+ getBrowserInstanceImplementation({
+ ...options,
+ chromiumOptions: {
+ ...options.chromiumOptions,
+ // The CLI can pass null; Lambda still needs software rendering.
+ gl: options.chromiumOptions.gl ?? 'swangle',
+ enableMultiProcessOnLinux: false,
+ },
+ }),
timer,
getCurrentRegionInFunction: getCurrentRegionInFunctionImplementation,
@@ -42,5 +56,22 @@ export const serverAwsImplementation: InsideFunctionSpecifics<AwsProvider> = {
},
invokeWebhook,
makeArtifactWithDetails: makeAwsArtifact,
- getFolderFiles,
+ normalizeChromiumOptions: ({chromiumOptions, logLevel}) => {
+ if (chromiumOptions.gl !== 'angle') {
+ return chromiumOptions;
+ }
+
+ RenderInternals.Log.warn(
+ {indent: false, logLevel},
+ 'gl=angle is not supported in Lambda. Changing to gl=swangle instead.',
+ );
+ return {...chromiumOptions, gl: 'swangle'};
+ },
+ getTmpDirState: getTmpDirStateIfENoSp,
+ startRendererDiagnostics: ENABLE_SLOW_LEAK_DETECTION
+ ? (requestId) => {
+ const diagnostics = enableNodeIntrospection(true);
+ return () => startLeakDetection(diagnostics, requestId);
+ }
+ : null,
};
diff --git a/packages/lambda/src/functions/helpers/get-tmp-dir.ts b/packages/lambda/src/functions/helpers/get-tmp-dir.ts
new file mode 100644
index 0000000000..93665a8746
--- /dev/null
+++ b/packages/lambda/src/functions/helpers/get-tmp-dir.ts
@@ -0,0 +1,21 @@
+import type {FunctionErrorInfo} from '@remotion/serverless';
+import {errorIsOutOfSpaceError} from '@remotion/serverless';
+import {getFolderFiles} from './get-folder-files';
+
+export const getTmpDirStateIfENoSp = (
+ err: string,
+): FunctionErrorInfo['tmpDir'] => {
+ if (!errorIsOutOfSpaceError(err)) {
+ return null;
+ }
+
+ const files = getFolderFiles('/tmp');
+ return {
+ files: files
+ .slice(0)
+ .sort((a, b) => a.size - b.size)
+ .reverse()
+ .slice(0, 100),
+ total: files.reduce((a, b) => a + b.size, 0),
+ };
+};
diff --git a/packages/serverless/src/leak-detection.ts b/packages/lambda/src/functions/helpers/leak-detection.ts
similarity index 80%
rename from packages/serverless/src/leak-detection.ts
rename to packages/lambda/src/functions/helpers/leak-detection.ts
index ddf4e3646c..94f38efe43 100644
--- a/packages/serverless/src/leak-detection.ts
+++ b/packages/lambda/src/functions/helpers/leak-detection.ts
@@ -1,10 +1,9 @@
-/* eslint-disable no-console */
import type {NodeIntrospection} from './why-is-node-running';
import {whyIsNodeRunning} from './why-is-node-running';
type LeakTimeout = {
timeout: Timer;
- awsRequestId: string;
+ requestId: string;
};
let currentRequestId: string | null = null;
@@ -17,21 +16,21 @@ export const stopLeakDetection = () => {
}
};
-export const setCurrentRequestId = (awsRequestId: string) => {
- currentRequestId = awsRequestId;
+export const setCurrentRequestId = (requestId: string) => {
+ currentRequestId = requestId;
};
export const startLeakDetection = (
leakDetection: NodeIntrospection,
- awsRequestId: string,
+ requestId: string,
) => {
- currentRequestId = awsRequestId;
+ currentRequestId = requestId;
leakDetectionTimeout = {
- awsRequestId,
+ requestId,
timeout: setTimeout(() => {
// First allow request ID to be set
setTimeout(() => {
- if (currentRequestId !== awsRequestId) {
+ if (currentRequestId !== requestId) {
// New function, all good
return;
}
diff --git a/packages/serverless/src/stackback.ts b/packages/lambda/src/functions/helpers/stackback.ts
similarity index 100%
rename from packages/serverless/src/stackback.ts
rename to packages/lambda/src/functions/helpers/stackback.ts
diff --git a/packages/serverless/src/why-is-node-running.ts b/packages/lambda/src/functions/helpers/why-is-node-running.ts
similarity index 98%
rename from packages/serverless/src/why-is-node-running.ts
rename to packages/lambda/src/functions/helpers/why-is-node-running.ts
index 95a54b61e7..8a370ab316 100644
--- a/packages/serverless/src/why-is-node-running.ts
+++ b/packages/lambda/src/functions/helpers/why-is-node-running.ts
@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
import asyncHooks from 'async_hooks';
import fs from 'fs';
import {sep} from 'path';
diff --git a/packages/lambda/src/functions/index.ts b/packages/lambda/src/functions/index.ts
index 550d688649..e3fd9f51fb 100644
--- a/packages/lambda/src/functions/index.ts
+++ b/packages/lambda/src/functions/index.ts
@@ -1,40 +1,78 @@
import type {AwsProvider} from '@remotion/lambda-client';
import {LambdaClientInternals} from '@remotion/lambda-client';
import type {
- RequestContext,
+ OrError,
ResponseStream,
ServerlessPayload,
} from '@remotion/serverless';
import {
innerHandler,
- innerRoutine,
ServerlessRoutines,
streamWriter,
} from '@remotion/serverless';
import {serverAwsImplementation} from './aws-server-implementation';
+import {setCurrentRequestId, stopLeakDetection} from './helpers/leak-detection';
import {streamifyResponse} from './helpers/streamify-response';
-export const routine = (
+type LambdaRequestContext = {
+ invokedFunctionArn: string;
+ getRemainingTimeInMillis: () => number;
+ awsRequestId: string;
+};
+
+export const routine = async (
params: ServerlessPayload<AwsProvider>,
responseStream: ResponseStream,
- context: RequestContext,
+ context: LambdaRequestContext,
): Promise<void> => {
const responseWriter = streamWriter(responseStream);
- const handle =
+ const buffered =
params.type === ServerlessRoutines.info ||
params.type === ServerlessRoutines.start ||
- params.type === ServerlessRoutines.compositions
- ? innerRoutine
- : innerHandler;
-
- return handle({
- params,
- responseWriter,
- context,
- providerSpecifics: LambdaClientInternals.awsImplementation,
- insideFunctionSpecifics: serverAwsImplementation,
- });
+ params.type === ServerlessRoutines.compositions;
+
+ try {
+ process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
+ setCurrentRequestId(context.awsRequestId);
+ stopLeakDetection();
+ if (!context?.invokedFunctionArn) {
+ throw new Error(
+ 'Lambda function unexpectedly does not have context.invokedFunctionArn',
+ );
+ }
+
+ const expectedBucketOwner = context.invokedFunctionArn.split(':')[4];
+ if (!expectedBucketOwner) {
+ throw new Error('Expected current user ID');
+ }
+
+ await innerHandler({
+ params,
+ responseWriter,
+ context: {
+ requestId: context.awsRequestId,
+ expectedBucketOwner,
+ getRemainingTimeInMillis: () => context.getRemainingTimeInMillis(),
+ },
+ providerSpecifics: LambdaClientInternals.awsImplementation,
+ insideFunctionSpecifics: serverAwsImplementation,
+ });
+ } catch (err) {
+ if (!buffered) {
+ throw err;
+ }
+
+ const response: OrError<0> = {
+ type: 'error',
+ message: (err as Error).message,
+ stack: (err as Error).stack as string,
+ };
+ await responseWriter.write(
+ new TextEncoder().encode(JSON.stringify(response)),
+ );
+ await responseWriter.end();
+ }
};
export const handler = streamifyResponse(routine);
diff --git a/packages/lambda/src/test/mock-implementation.ts b/packages/lambda/src/test/mock-implementation.ts
index efbbcf5528..dede673b2d 100644
--- a/packages/lambda/src/test/mock-implementation.ts
+++ b/packages/lambda/src/test/mock-implementation.ts
@@ -66,12 +66,9 @@ export const mockServerImplementation: InsideFunctionSpecifics<AwsProvider> = {
paramsArray.push(params);
return Promise.resolve();
},
- getFolderFiles: () => [
- {
- filename: 'something',
- size: 0,
- },
- ],
+ normalizeChromiumOptions: serverAwsImplementation.normalizeChromiumOptions,
+ getTmpDirState: null,
+ startRendererDiagnostics: null,
makeArtifactWithDetails: () => ({
filename: 'something',
sizeInBytes: 0,
diff --git a/packages/lambda/src/test/mocks/aws-clients.ts b/packages/lambda/src/test/mocks/aws-clients.ts
index 5585abca44..9f7bc3d32d 100644
--- a/packages/lambda/src/test/mocks/aws-clients.ts
+++ b/packages/lambda/src/test/mocks/aws-clients.ts
@@ -80,9 +80,9 @@ export const getMockCallFunctionStreaming: CallFunctionStreaming<
},
},
context: {
- invokedFunctionArn: 'arn:fake:1234:1234:124',
+ expectedBucketOwner: '124',
getRemainingTimeInMillis: () => params.timeoutInTest ?? 120000,
- awsRequestId: 'fake',
+ requestId: 'fake',
},
providerSpecifics: mockImplementation,
insideFunctionSpecifics: mockServerImplementation,
@@ -101,9 +101,9 @@ export const getMockCallFunctionAsync: CallFunctionAsync<AwsProvider> = async <
const responseStream = new ResponseStream();
await innerHandler<AwsProvider>({
context: {
- invokedFunctionArn: 'arn:fake:1234:1234:124',
+ expectedBucketOwner: '124',
getRemainingTimeInMillis: () => params.timeoutInTest ?? 120000,
- awsRequestId: 'fake',
+ requestId: 'fake',
},
providerSpecifics: mockImplementation,
insideFunctionSpecifics: mockServerImplementation,
@@ -123,9 +123,9 @@ export const getMockCallFunctionSync: CallFunctionSync<AwsProvider> = async <
const responseStream = new ResponseStream();
await innerHandler<AwsProvider>({
context: {
- invokedFunctionArn: 'arn:fake:1234:1234:124',
+ expectedBucketOwner: '124',
getRemainingTimeInMillis: () => params.timeoutInTest ?? 120000,
- awsRequestId: 'fake',
+ requestId: 'fake',
},
params: params.payload,
responseWriter: streamWriter(responseStream),
diff --git a/packages/lambda/src/test/unit/routine.test.ts b/packages/lambda/src/test/unit/routine.test.ts
index c2b1346509..c4b17e81c9 100644
--- a/packages/lambda/src/test/unit/routine.test.ts
+++ b/packages/lambda/src/test/unit/routine.test.ts
@@ -1,10 +1,94 @@
-import {expect, test} from 'bun:test';
+import {expect, spyOn, test} from 'bun:test';
+import {LambdaClientInternals} from '@remotion/lambda-client';
import {
ResponseStream,
ServerlessRoutines,
VERSION,
} from '@remotion/serverless';
import {routine} from '../../functions';
+import {serverAwsImplementation} from '../../functions/aws-server-implementation';
+
+test('Lambda context is normalized while preserving storage ownership', async () => {
+ const previousFlag = process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA;
+ // Replace Lambda's filesystem and runtime environment, keeping dispatch and
+ // progress handling real. The real cleanup deletes the Lambda /tmp directory.
+ const cleanup = spyOn(
+ serverAwsImplementation,
+ 'deleteTmpDir',
+ ).mockResolvedValue();
+ const region = spyOn(
+ serverAwsImplementation,
+ 'getCurrentRegionInFunction',
+ ).mockReturnValue('us-east-1');
+ const memory = spyOn(
+ serverAwsImplementation,
+ 'getCurrentMemorySizeInMb',
+ ).mockReturnValue(2048);
+ const name = spyOn(
+ serverAwsImplementation,
+ 'getCurrentFunctionName',
+ ).mockReturnValue('render-worker');
+ const storageError = new Error('Storage unavailable');
+ const read = spyOn(
+ LambdaClientInternals.awsImplementation,
+ 'readFile',
+ ).mockRejectedValue(storageError);
+ const context = {
+ awsRequestId: 'request-id',
+ invokedFunctionArn:
+ 'arn:aws:lambda:us-east-1:123456789012:function:render-worker',
+ getRemainingTimeInMillis: () => 120_000,
+ };
+
+ try {
+ const infoStream = new ResponseStream();
+ await routine(
+ {type: ServerlessRoutines.info, logLevel: 'error'},
+ infoStream,
+ context,
+ );
+ expect(JSON.parse(infoStream.getBufferedData().toString())).toEqual({
+ type: 'success',
+ version: VERSION,
+ });
+ expect(infoStream.writableEnded).toBe(true);
+ expect(process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA).toBe('true');
+
+ await expect(
+ routine(
+ {
+ type: ServerlessRoutines.status,
+ version: VERSION,
+ logLevel: 'error',
+ bucketName: 'render-storage',
+ renderId: 'render-id',
+ forcePathStyle: false,
+ s3OutputProvider: null,
+ },
+ new ResponseStream(),
+ context,
+ ),
+ ).rejects.toBe(storageError);
+ expect(read).toHaveBeenCalledWith(
+ expect.objectContaining({
+ expectedBucketOwner: '123456789012',
+ bucketName: 'render-storage',
+ key: 'renders/render-id/progress.json',
+ }),
+ );
+ } finally {
+ cleanup.mockRestore();
+ region.mockRestore();
+ memory.mockRestore();
+ name.mockRestore();
+ read.mockRestore();
+ if (previousFlag === undefined) {
+ delete process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA;
+ } else {
+ process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = previousFlag;
+ }
+ }
+});
test('buffered routines serialize exceptions and end the response', async () => {
for (const type of [
diff --git a/packages/lambda/src/test/unit/runtime-policies.test.ts b/packages/lambda/src/test/unit/runtime-policies.test.ts
new file mode 100644
index 0000000000..9a3efa5f6b
--- /dev/null
+++ b/packages/lambda/src/test/unit/runtime-policies.test.ts
@@ -0,0 +1,122 @@
+import {expect, mock, spyOn, test} from 'bun:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {LambdaClientInternals} from '@remotion/lambda-client';
+import type {AwsProvider} from '@remotion/lambda-client';
+import type * as Renderer from '@remotion/renderer';
+import {rendererHandler, VERSION} from '@remotion/serverless';
+import type {StreamingPayload} from '@remotion/serverless';
+import {serverAwsImplementation} from '../../functions/aws-server-implementation';
+
+// Serverless is published as CommonJS, so intercept its renderer instance.
+const {RenderInternals} = require('@remotion/renderer') as typeof Renderer;
+
+test.each(['angle', null] as const)(
+ 'Lambda renders with software GL and one browser process for gl=%s',
+ async (gl) => {
+ const testRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'lambda-runtime-'));
+ const tmpDirSpy = spyOn(RenderInternals, 'tmpDir').mockImplementation(() =>
+ fs.mkdtempSync(path.join(testRoot, 'render-')),
+ );
+ // Fake the Chromium process and encoder, keeping the shared handler,
+ // browser cache, and Lambda runtime policy wired together.
+ const browser = {
+ on: mock(() => undefined),
+ close: mock(() => Promise.resolve()),
+ runner: {
+ forgetEventLoop: () => undefined,
+ deleteBrowserCaches: () => undefined,
+ },
+ };
+ const openBrowserSpy = spyOn(
+ RenderInternals,
+ 'internalOpenBrowser',
+ ).mockResolvedValue(browser as never);
+ const renderMediaSpy = spyOn(
+ RenderInternals,
+ 'internalRenderMedia',
+ ).mockResolvedValue({slowestFrames: []} as never);
+ const messages: StreamingPayload<AwsProvider>[] = [];
+ let launchedBrowser: Awaited<
+ ReturnType<typeof serverAwsImplementation.getBrowserInstance>
+ > | null = null;
+ const chromiumOptions = {gl, enableMultiProcessOnLinux: true};
+
+ try {
+ await rendererHandler<AwsProvider>({
+ params: {
+ type: 'renderer',
+ chromiumOptions,
+ launchFunctionConfig: {version: VERSION},
+ inputProps: {type: 'payload', payload: '{}'},
+ resolvedProps: {type: 'payload', payload: '{}'},
+ bucketName: 'bucket',
+ forcePathStyle: false,
+ frameRange: [0, 0],
+ everyNthFrame: 1,
+ codec: 'h264',
+ muted: true,
+ framesPerLambda: 1,
+ logLevel: 'error',
+ retriesLeft: 0,
+ attempt: 1,
+ chunk: 0,
+ enableCancellation: false,
+ } as never,
+ options: {expectedBucketOwner: '123456789012', isWarm: false},
+ onStream: (message) => {
+ messages.push(message);
+ return Promise.resolve();
+ },
+ providerSpecifics: LambdaClientInternals.awsImplementation,
+ insideFunctionSpecifics: {
+ ...serverAwsImplementation,
+ getCurrentRegionInFunction: () => 'us-east-1',
+ getBrowserInstance: async (options) => {
+ launchedBrowser =
+ await serverAwsImplementation.getBrowserInstance(options);
+ return launchedBrowser;
+ },
+ },
+ requestContext: {
+ requestId: 'request-id',
+ expectedBucketOwner: '123456789012',
+ getRemainingTimeInMillis: () => 120_000,
+ },
+ onMediaFiles: () => Promise.resolve(),
+ executionMode: 'invoked',
+ });
+
+ expect(messages).toContainEqual(
+ expect.objectContaining({type: 'chunk-complete'}),
+ );
+ expect(openBrowserSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ chromiumOptions: expect.objectContaining({
+ gl: 'swangle',
+ enableMultiProcessOnLinux: false,
+ }),
+ }),
+ );
+ expect(renderMediaSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ chromiumOptions: expect.objectContaining({
+ gl: gl === 'angle' ? 'swangle' : null,
+ }),
+ }),
+ );
+ expect(chromiumOptions).toEqual({gl, enableMultiProcessOnLinux: true});
+ expect(serverAwsImplementation.startRendererDiagnostics).toBeNull();
+ } finally {
+ if (launchedBrowser) {
+ await serverAwsImplementation.closeBrowserInstance({launchedBrowser});
+ }
+
+ tmpDirSpy.mockRestore();
+ openBrowserSpy.mockRestore();
+ renderMediaSpy.mockRestore();
+ fs.rmSync(testRoot, {recursive: true, force: true});
+ }
+ },
+);
diff --git a/packages/serverless-client/src/compress-props.ts b/packages/serverless-client/src/compress-props.ts
index 9392297cae..4802ad3662 100644
--- a/packages/serverless-client/src/compress-props.ts
+++ b/packages/serverless-client/src/compress-props.ts
@@ -149,7 +149,7 @@ export const decompressInputProps = async <Provider extends CloudProvider>({
serialized: SerializedInputProps;
region: Provider['region'];
bucketName: string;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
propsType: PropsType;
providerSpecifics: ProviderSpecifics<Provider>;
forcePathStyle: boolean;
diff --git a/packages/serverless-client/src/webhook-types.ts b/packages/serverless-client/src/webhook-types.ts
index 773fd29461..55b5d91e84 100644
--- a/packages/serverless-client/src/webhook-types.ts
+++ b/packages/serverless-client/src/webhook-types.ts
@@ -1,36 +1,39 @@
import type {AfterRenderCost} from './constants';
import type {EnhancedErrorInfo} from './write-error-to-storage';
-type StaticWebhookPayload = {
+type StaticWebhookPayload<BucketOwner extends string | null> = {
renderId: string;
- expectedBucketOwner: string;
+ expectedBucketOwner: BucketOwner;
bucketName: string;
customData: Record<string, unknown> | null;
};
-export type WebhookErrorPayload = StaticWebhookPayload & {
- type: 'error';
- errors: {
- message: string;
- name: string;
- stack: string;
- }[];
-};
+export type WebhookErrorPayload<BucketOwner extends string | null = string> =
+ StaticWebhookPayload<BucketOwner> & {
+ type: 'error';
+ errors: {
+ message: string;
+ name: string;
+ stack: string;
+ }[];
+ };
-export type WebhookSuccessPayload = StaticWebhookPayload & {
- type: 'success';
- lambdaErrors: EnhancedErrorInfo[];
- outputUrl: string | undefined;
- outputFile: string | undefined;
- timeToFinish: number | undefined;
- costs: AfterRenderCost;
-};
+export type WebhookSuccessPayload<BucketOwner extends string | null = string> =
+ StaticWebhookPayload<BucketOwner> & {
+ type: 'success';
+ lambdaErrors: EnhancedErrorInfo[];
+ outputUrl: string | undefined;
+ outputFile: string | undefined;
+ timeToFinish: number | undefined;
+ costs: AfterRenderCost;
+ };
-export type WebhookTimeoutPayload = StaticWebhookPayload & {
- type: 'timeout';
-};
+export type WebhookTimeoutPayload<BucketOwner extends string | null = string> =
+ StaticWebhookPayload<BucketOwner> & {
+ type: 'timeout';
+ };
-export type WebhookPayload =
- | WebhookErrorPayload
- | WebhookSuccessPayload
- | WebhookTimeoutPayload;
+export type WebhookPayload<BucketOwner extends string | null = string> =
+ | WebhookErrorPayload<BucketOwner>
+ | WebhookSuccessPayload<BucketOwner>
+ | WebhookTimeoutPayload<BucketOwner>;
diff --git a/packages/serverless-client/src/write-cancellation-signal.ts b/packages/serverless-client/src/write-cancellation-signal.ts
index 2c121106b4..6a976733b7 100644
--- a/packages/serverless-client/src/write-cancellation-signal.ts
+++ b/packages/serverless-client/src/write-cancellation-signal.ts
@@ -14,7 +14,7 @@ export const writeCancellationSignal = async <Provider extends CloudProvider>({
bucketName: string;
renderId: string;
region: Provider['region'];
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
providerSpecifics: ProviderSpecifics<Provider>;
forcePathStyle: boolean;
requestHandler: Provider['requestHandler'] | null;
diff --git a/packages/serverless/src/finish-render.ts b/packages/serverless/src/finish-render.ts
index 7e5a374c2e..25e170dbdb 100644
--- a/packages/serverless/src/finish-render.ts
+++ b/packages/serverless/src/finish-render.ts
@@ -38,7 +38,7 @@ export const finishRender = async <Provider extends CloudProvider>({
outputFile,
timeToCombine,
}: {
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
renderBucketName: string;
customCredentials: CustomCredentials<Provider> | null;
downloadBehavior: DownloadBehavior;
diff --git a/packages/serverless/src/get-browser-instance.ts b/packages/serverless/src/get-browser-instance.ts
index 3a63a1bbd7..30006a7404 100644
--- a/packages/serverless/src/get-browser-instance.ts
+++ b/packages/serverless/src/get-browser-instance.ts
@@ -24,7 +24,7 @@ const makeConfigurationString = (
): string => {
return [
`web-security-${Boolean(options.disableWebSecurity)}`,
- `multi-process-${Boolean(options.enableMultiProcessOnLinux)}`,
+ `multi-process-${options.enableMultiProcessOnLinux ?? true}`,
`ignore-certificate-errors-${Boolean(options.ignoreCertificateErrors)}`,
`log-level-${logLevel}`,
`gl-${options.gl ?? null}`,
@@ -90,16 +90,13 @@ export const getBrowserInstanceImplementation: GetBrowserInstance = async <
providerSpecifics: ProviderSpecifics<Provider>;
insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
}): Promise<LaunchedBrowser> => {
- const actualChromiumOptions: Required<ChromiumOptions> = {
+ const actualChromiumOptions: ChromiumOptions = {
...chromiumOptions,
darkMode: chromiumOptions.darkMode ?? false,
disableWebSecurity: chromiumOptions.disableWebSecurity ?? false,
headless: chromiumOptions.headless ?? true,
userAgent: chromiumOptions.userAgent ?? null,
ignoreCertificateErrors: chromiumOptions.ignoreCertificateErrors ?? false,
- // Override the `null` value, which might come from CLI with swANGLE
- gl: chromiumOptions.gl ?? 'swangle',
- enableMultiProcessOnLinux: false,
};
const configurationString = makeConfigurationString(
actualChromiumOptions,
diff --git a/packages/serverless/src/get-tmp-dir.ts b/packages/serverless/src/get-tmp-dir.ts
deleted file mode 100644
index cf948246bf..0000000000
--- a/packages/serverless/src/get-tmp-dir.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import type {
- CloudProvider,
- FunctionErrorInfo,
-} from '@remotion/serverless-client';
-import {errorIsOutOfSpaceError} from '@remotion/serverless-client';
-import type {InsideFunctionSpecifics} from './provider-implementation';
-
-export const getTmpDirStateIfENoSp = <Provider extends CloudProvider>(
- err: string,
- insideFunctionSpecifics: InsideFunctionSpecifics<Provider>,
-): FunctionErrorInfo['tmpDir'] => {
- if (!errorIsOutOfSpaceError(err)) {
- return null;
- }
-
- const files = insideFunctionSpecifics.getFolderFiles('/tmp');
- return {
- files: files
- .slice(0)
- .sort((a, b) => a.size - b.size)
- .reverse()
- .slice(0, 100),
- total: files.reduce((a, b) => a + b.size, 0),
- };
-};
diff --git a/packages/serverless/src/handlers/compositions.ts b/packages/serverless/src/handlers/compositions.ts
index 5ad3eb1698..00bd15899d 100644
--- a/packages/serverless/src/handlers/compositions.ts
+++ b/packages/serverless/src/handlers/compositions.ts
@@ -14,7 +14,7 @@ import type {InsideFunctionSpecifics} from '../provider-implementation';
import {checkVersionMismatch} from './check-version-mismatch';
type Options = {
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
};
export const compositionsHandler = async <Provider extends CloudProvider>({
diff --git a/packages/serverless/src/handlers/launch.ts b/packages/serverless/src/handlers/launch.ts
index 0ca6793155..9d709c3bd4 100644
--- a/packages/serverless/src/handlers/launch.ts
+++ b/packages/serverless/src/handlers/launch.ts
@@ -39,7 +39,6 @@ import {cleanupProps} from '../cleanup-props';
import {findOutputFileInBucket} from '../find-output-file-in-bucket';
import {finishRender} from '../finish-render';
import type {LaunchedBrowser} from '../get-browser-instance';
-import {getTmpDirStateIfENoSp} from '../get-tmp-dir';
import {mergeChunksAndFinishRender} from '../merge-chunks';
import type {OverallProgressHelper} from '../overall-render-progress';
import {makeOverallRenderProgress} from '../overall-render-progress';
@@ -53,7 +52,7 @@ import type {RequestContext} from './renderer';
import {sendTelemetryEvent} from './send-telemetry-event';
type Options = {
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
getRemainingTimeInMillis: () => number;
requestContext: RequestContext | null;
};
@@ -81,15 +80,10 @@ const innerLaunchHandler = async <Provider extends CloudProvider>({
const startedDate = Date.now();
- const chromiumParams = {...(params.chromiumOptions ?? {})};
-
- if (params.chromiumOptions?.gl === 'angle') {
- RenderInternals.Log.warn(
- {indent: false, logLevel: params.logLevel},
- 'gl=angle is not supported in Lambda. Changing to gl=swangle instead.',
- );
- chromiumParams.gl = 'swangle';
- }
+ const chromiumParams = insideFunctionSpecifics.normalizeChromiumOptions?.({
+ chromiumOptions: params.chromiumOptions ?? {},
+ logLevel: params.logLevel,
+ }) ?? {...(params.chromiumOptions ?? {})};
const browserInstance = insideFunctionSpecifics.getBrowserInstance({
logLevel: params.logLevel,
@@ -949,10 +943,10 @@ export const launchHandler = async <Provider extends CloudProvider>({
stack: (err as Error).stack as string,
type: 'stitcher',
isFatal: true,
- tmpDir: getTmpDirStateIfENoSp(
- (err as Error).stack as string,
- insideFunctionSpecifics,
- ),
+ tmpDir:
+ insideFunctionSpecifics.getTmpDirState?.(
+ (err as Error).stack as string,
+ ) ?? null,
attempt: 1,
totalAttempts: 1,
willRetry: false,
diff --git a/packages/serverless/src/handlers/progress.ts b/packages/serverless/src/handlers/progress.ts
index b1c2650437..9b12fc7844 100644
--- a/packages/serverless/src/handlers/progress.ts
+++ b/packages/serverless/src/handlers/progress.ts
@@ -9,7 +9,7 @@ import type {InsideFunctionSpecifics} from '../provider-implementation';
import {checkVersionMismatch} from './check-version-mismatch';
type Options<Provider extends CloudProvider> = {
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
timeoutInMilliseconds: number;
retriesRemaining: number;
providerSpecifics: ProviderSpecifics<Provider>;
diff --git a/packages/serverless/src/handlers/renderer.ts b/packages/serverless/src/handlers/renderer.ts
index ce45c9a56a..a9c430f0f2 100644
--- a/packages/serverless/src/handlers/renderer.ts
+++ b/packages/serverless/src/handlers/renderer.ts
@@ -26,21 +26,18 @@ import {
} from '@remotion/serverless-client';
import {startCancellationPolling} from '../cancellation-polling';
import type {LaunchedBrowser} from '../get-browser-instance';
-import {getTmpDirStateIfENoSp} from '../get-tmp-dir';
-import {startLeakDetection} from '../leak-detection';
import {onDownloadsHelper} from '../on-downloads-helpers';
import type {InsideFunctionSpecifics} from '../provider-implementation';
-import {enableNodeIntrospection} from '../why-is-node-running';
type Options = {
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
isWarm: boolean;
};
export type RequestContext = {
- invokedFunctionArn: string;
+ expectedBucketOwner: string | null;
getRemainingTimeInMillis: () => number;
- awsRequestId: string;
+ requestId: string;
};
const renderHandler = async <Provider extends CloudProvider>({
@@ -75,13 +72,11 @@ const renderHandler = async <Provider extends CloudProvider>({
throw new Error('Params must be renderer');
}
- if (params.chromiumOptions.gl === 'angle') {
- RenderInternals.Log.warn(
- {indent: false, logLevel: params.logLevel},
- 'gl=angle is not supported in Lambda. Changing to gl=swangle instead.',
- );
- params.chromiumOptions.gl = 'swangle';
- }
+ const chromiumOptions =
+ insideFunctionSpecifics.normalizeChromiumOptions?.({
+ chromiumOptions: params.chromiumOptions,
+ logLevel: params.logLevel,
+ }) ?? params.chromiumOptions;
if (params.launchFunctionConfig.version !== VERSION) {
throw new Error(
@@ -119,7 +114,7 @@ const renderHandler = async <Provider extends CloudProvider>({
const browserInstance = await insideFunctionSpecifics.getBrowserInstance({
logLevel: params.logLevel,
indent: false,
- chromiumOptions: params.chromiumOptions,
+ chromiumOptions,
providerSpecifics,
insideFunctionSpecifics,
});
@@ -330,7 +325,7 @@ const renderHandler = async <Provider extends CloudProvider>({
gopSize: params.gopSize ?? null,
onDownload: onDownloadsHelper(params.logLevel),
overwrite: false,
- chromiumOptions: params.chromiumOptions,
+ chromiumOptions,
scale: params.scale,
timeoutInMilliseconds: params.timeoutInMilliseconds,
port: null,
@@ -460,8 +455,6 @@ const renderHandler = async <Provider extends CloudProvider>({
return {};
};
-const ENABLE_SLOW_LEAK_DETECTION = false;
-
export const rendererHandler = async <Provider extends CloudProvider>({
onStream,
options,
@@ -494,7 +487,10 @@ export const rendererHandler = async <Provider extends CloudProvider>({
const logs: BrowserLog[] = [];
- const leakDetection = enableNodeIntrospection(ENABLE_SLOW_LEAK_DETECTION);
+ const finishRendererDiagnostics =
+ insideFunctionSpecifics.startRendererDiagnostics?.(
+ requestContext.requestId,
+ ) ?? null;
let shouldKeepBrowserOpen = true;
let instance: LaunchedBrowser | undefined;
let cancellationRequested = false;
@@ -571,10 +567,10 @@ export const rendererHandler = async <Provider extends CloudProvider>({
frame: null,
type: 'renderer',
isFatal: !shouldRetry,
- tmpDir: getTmpDirStateIfENoSp(
- (err as Error).stack as string,
- insideFunctionSpecifics,
- ),
+ tmpDir:
+ insideFunctionSpecifics.getTmpDirState?.(
+ (err as Error).stack as string,
+ ) ?? null,
attempt: params.attempt,
totalAttempts: params.retriesLeft + params.attempt,
willRetry: shouldRetry,
@@ -613,8 +609,6 @@ export const rendererHandler = async <Provider extends CloudProvider>({
);
}
- if (ENABLE_SLOW_LEAK_DETECTION) {
- startLeakDetection(leakDetection, requestContext.awsRequestId);
- }
+ finishRendererDiagnostics?.();
}
};
diff --git a/packages/serverless/src/handlers/start.ts b/packages/serverless/src/handlers/start.ts
index 3ac7e3b3e0..00d3e17425 100644
--- a/packages/serverless/src/handlers/start.ts
+++ b/packages/serverless/src/handlers/start.ts
@@ -13,7 +13,7 @@ import type {InsideFunctionSpecifics} from '../provider-implementation';
import {checkVersionMismatch} from './check-version-mismatch';
type Options = {
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
timeoutInMilliseconds: number;
renderId: string;
};
diff --git a/packages/serverless/src/handlers/still.ts b/packages/serverless/src/handlers/still.ts
index e6295f8019..ecb6abc7c5 100644
--- a/packages/serverless/src/handlers/still.ts
+++ b/packages/serverless/src/handlers/still.ts
@@ -27,7 +27,6 @@ import {
VERSION,
} from '@remotion/serverless-client';
import {cleanupSerializedInputProps} from '../cleanup-serialized-input-props';
-import {getTmpDirStateIfENoSp} from '../get-tmp-dir';
import {onDownloadsHelper} from '../on-downloads-helpers';
import {makeInitialOverallRenderProgress} from '../overall-render-progress';
import type {InsideFunctionSpecifics} from '../provider-implementation';
@@ -39,7 +38,7 @@ import {sendTelemetryEvent} from './send-telemetry-event';
type Options<Provider extends CloudProvider> = {
params: ServerlessPayload<Provider>;
renderId: string;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
onStream: OnStream<Provider>;
timeoutInMilliseconds: number;
providerSpecifics: ProviderSpecifics<Provider>;
@@ -470,10 +469,10 @@ export const stillHandler = async <Provider extends CloudProvider>(
frame: params.frame,
type: 'renderer',
isFatal: false,
- tmpDir: getTmpDirStateIfENoSp(
- (err as Error).stack as string,
- options.insideFunctionSpecifics,
- ),
+ tmpDir:
+ options.insideFunctionSpecifics.getTmpDirState?.(
+ (err as Error).stack as string,
+ ) ?? null,
attempt: params.attempt,
totalAttempts: 1 + params.maxRetries,
willRetry,
diff --git a/packages/serverless/src/index.ts b/packages/serverless/src/index.ts
index b60f7b9f95..e74dac86bb 100644
--- a/packages/serverless/src/index.ts
+++ b/packages/serverless/src/index.ts
@@ -13,7 +13,6 @@ export {stillHandler} from './handlers/still';
export {infoHandler} from './info';
export {innerHandler, innerRoutine} from './inner-routine';
export {invokeWebhook} from './invoke-webhook';
-export {setCurrentRequestId, stopLeakDetection} from './leak-detection';
export * from './provider-implementation';
export {ResponseStream} from './streaming/response-stream';
export {
diff --git a/packages/serverless/src/inner-routine.ts b/packages/serverless/src/inner-routine.ts
index 3b5b241290..dac5edf865 100644
--- a/packages/serverless/src/inner-routine.ts
+++ b/packages/serverless/src/inner-routine.ts
@@ -20,7 +20,6 @@ import {startHandler} from './handlers/start';
import {stillHandler} from './handlers/still';
import {infoHandler} from './info';
import {getWarm, setWarm} from './is-warm';
-import {setCurrentRequestId, stopLeakDetection} from './leak-detection';
import {printLoggingGrepHelper} from './print-logging-grep-helper';
import type {InsideFunctionSpecifics} from './provider-implementation';
import {makeS3RendererOutput} from './s3-renderer-output';
@@ -39,31 +38,18 @@ export const innerHandler = async <Provider extends CloudProvider>({
providerSpecifics: ProviderSpecifics<Provider>;
insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
}): Promise<void> => {
- setCurrentRequestId(context.awsRequestId);
- process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
const timeoutInMilliseconds = context.getRemainingTimeInMillis();
RenderInternals.Log.verbose(
{indent: false, logLevel: params.logLevel},
- 'AWS Request ID:',
- context.awsRequestId,
+ 'Request ID:',
+ context.requestId,
);
- stopLeakDetection();
- if (!context?.invokedFunctionArn) {
- throw new Error(
- 'Lambda function unexpectedly does not have context.invokedFunctionArn',
- );
- }
await insideFunctionSpecifics.deleteTmpDir();
const isWarm = getWarm();
setWarm();
- const currentUserId = context.invokedFunctionArn.split(':')[4];
- if (!currentUserId) {
- throw new Error('Expected current user ID');
- }
-
if (params.type === ServerlessRoutines.still) {
providerSpecifics.validateDeleteAfter(params.deleteAfter);
const renderId = insideFunctionSpecifics.generateRandomId({
@@ -120,7 +106,7 @@ export const innerHandler = async <Provider extends CloudProvider>({
}
stillHandler({
- expectedBucketOwner: currentUserId,
+ expectedBucketOwner: context.expectedBucketOwner,
params,
renderId,
onStream,
@@ -175,7 +161,7 @@ export const innerHandler = async <Provider extends CloudProvider>({
const response = await startHandler({
params,
options: {
- expectedBucketOwner: currentUserId,
+ expectedBucketOwner: context.expectedBucketOwner,
timeoutInMilliseconds,
renderId,
},
@@ -220,7 +206,7 @@ export const innerHandler = async <Provider extends CloudProvider>({
await launchHandler({
params,
options: {
- expectedBucketOwner: currentUserId,
+ expectedBucketOwner: context.expectedBucketOwner,
getRemainingTimeInMillis: context.getRemainingTimeInMillis,
requestContext: context,
},
@@ -248,7 +234,7 @@ export const innerHandler = async <Provider extends CloudProvider>({
const response = await progressHandler({
params,
options: {
- expectedBucketOwner: currentUserId,
+ expectedBucketOwner: context.expectedBucketOwner,
timeoutInMilliseconds,
retriesRemaining: 2,
providerSpecifics,
@@ -286,7 +272,7 @@ export const innerHandler = async <Provider extends CloudProvider>({
transport === 's3'
? makeS3RendererOutput({
params,
- expectedBucketOwner: currentUserId,
+ expectedBucketOwner: context.expectedBucketOwner,
region,
providerSpecifics,
})
@@ -297,7 +283,7 @@ export const innerHandler = async <Provider extends CloudProvider>({
rendererHandler({
params,
options: {
- expectedBucketOwner: currentUserId,
+ expectedBucketOwner: context.expectedBucketOwner,
isWarm,
},
onStream: s3Output
@@ -372,7 +358,7 @@ export const innerHandler = async <Provider extends CloudProvider>({
const response = await compositionsHandler({
params,
options: {
- expectedBucketOwner: currentUserId,
+ expectedBucketOwner: context.expectedBucketOwner,
},
providerSpecifics,
insideFunctionSpecifics,
diff --git a/packages/serverless/src/merge-chunks.ts b/packages/serverless/src/merge-chunks.ts
index e4f2e1782f..5e8e402d63 100644
--- a/packages/serverless/src/merge-chunks.ts
+++ b/packages/serverless/src/merge-chunks.ts
@@ -25,7 +25,7 @@ export const mergeChunksAndFinishRender = async <
>(options: {
bucketName: string;
renderId: string;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
numberOfFrames: number;
codec: ServerlessCodec;
chunkCount: number;
diff --git a/packages/serverless/src/overall-render-progress.ts b/packages/serverless/src/overall-render-progress.ts
index 4e591c032e..b62c91618b 100644
--- a/packages/serverless/src/overall-render-progress.ts
+++ b/packages/serverless/src/overall-render-progress.ts
@@ -95,7 +95,7 @@ export const makeOverallRenderProgress = <Provider extends CloudProvider>({
}: {
renderId: string;
bucketName: string;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
region: Provider['region'];
timeoutTimestamp: number;
logLevel: LogLevel;
diff --git a/packages/serverless/src/provider-implementation.ts b/packages/serverless/src/provider-implementation.ts
index 9b0fac866f..08d9f9fe40 100644
--- a/packages/serverless/src/provider-implementation.ts
+++ b/packages/serverless/src/provider-implementation.ts
@@ -8,7 +8,7 @@ import type {
import type {
CloudProvider,
DeleteAfter,
- GetFolderFiles,
+ FunctionErrorInfo,
Privacy,
ProviderSpecifics,
ReceivedArtifact,
@@ -109,7 +109,7 @@ export type CreateFunction<Provider extends CloudProvider> = (
) => Promise<{FunctionName: string}>;
export type InvokeWebhookOptions = {
- payload: WebhookPayload;
+ payload: WebhookPayload<string | null>;
url: string;
secret: string | null;
};
@@ -136,7 +136,14 @@ export type InsideFunctionSpecifics<Provider extends CloudProvider> = {
invokeWebhook: InvokeWebhook;
getCurrentRegionInFunction: () => Provider['region'];
makeArtifactWithDetails: MakeArtifactWithDetails<Provider>;
- getFolderFiles: GetFolderFiles;
+ normalizeChromiumOptions:
+ | ((options: {
+ chromiumOptions: ChromiumOptions;
+ logLevel: LogLevel;
+ }) => ChromiumOptions)
+ | null;
+ getTmpDirState: ((error: string) => FunctionErrorInfo['tmpDir']) | null;
+ startRendererDiagnostics: ((requestId: string) => () => void) | null;
};
export type FullClientSpecifics<Provider extends CloudProvider> = {
diff --git a/packages/serverless/src/s3-renderer-output.ts b/packages/serverless/src/s3-renderer-output.ts
index 98030bf06e..f087750b02 100644
--- a/packages/serverless/src/s3-renderer-output.ts
+++ b/packages/serverless/src/s3-renderer-output.ts
@@ -24,7 +24,7 @@ export const makeS3RendererOutput = <Provider extends CloudProvider>({
providerSpecifics,
}: {
params: ServerlessPayload<Provider>;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
region: Provider['region'];
providerSpecifics: ProviderSpecifics<Provider>;
}) => {
diff --git a/packages/serverless/src/stream-renderer.ts b/packages/serverless/src/stream-renderer.ts
index dfc536e72f..5c93c6998d 100644
--- a/packages/serverless/src/stream-renderer.ts
+++ b/packages/serverless/src/stream-renderer.ts
@@ -54,7 +54,7 @@ const streamRenderer = <Provider extends CloudProvider>({
providerSpecifics: ProviderSpecifics<Provider>;
insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
requestHandler: Provider['requestHandler'] | null;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
}) => {
if (payload.type !== ServerlessRoutines.renderer) {
throw new Error('Expected renderer type');
@@ -307,7 +307,7 @@ const s3Renderer = async <Provider extends CloudProvider>({
providerSpecifics: ProviderSpecifics<Provider>;
insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
requestHandler: Provider['requestHandler'] | null;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
}): Promise<StreamRendererResponse> => {
if (payload.type !== ServerlessRoutines.renderer) {
throw new Error('Expected renderer type');
@@ -577,7 +577,7 @@ export const renderRendererFunctionWithRetry = async <
providerSpecifics: ProviderSpecifics<Provider>;
insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
requestHandler: Provider['requestHandler'] | null;
- expectedBucketOwner: string;
+ expectedBucketOwner: string | null;
}): Promise<unknown> => {
if (payload.type !== ServerlessRoutines.renderer) {
throw new Error('Expected renderer type');
diff --git a/packages/serverless/src/test/inner-routine.test.ts b/packages/serverless/src/test/inner-routine.test.ts
index b3d0b6a01f..9c68846dcb 100644
--- a/packages/serverless/src/test/inner-routine.test.ts
+++ b/packages/serverless/src/test/inner-routine.test.ts
@@ -1,10 +1,12 @@
import {expect, test} from 'bun:test';
+import {Readable} from 'node:stream';
import type {
CloudProvider,
ProviderSpecifics,
} from '@remotion/serverless-client';
-import {VERSION} from '@remotion/serverless-client';
+import {ServerlessRoutines, VERSION} from '@remotion/serverless-client';
import {innerHandler, innerRoutine} from '../inner-routine';
+import {makeInitialOverallRenderProgress} from '../overall-render-progress';
import type {InsideFunctionSpecifics} from '../provider-implementation';
type MockProvider = CloudProvider<
@@ -15,6 +17,83 @@ type MockProvider = CloudProvider<
Record<string, never>
>;
+test('progress works without AWS context or a bucket owner', async () => {
+ const previousFlag = process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA;
+ delete process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA;
+ const chunks: Uint8Array[] = [];
+ let ended = false;
+ const reads: Array<string | null> = [];
+
+ try {
+ await innerHandler<MockProvider>({
+ params: {
+ type: ServerlessRoutines.status,
+ version: VERSION,
+ logLevel: 'error',
+ bucketName: 'render-storage',
+ renderId: 'render-id',
+ forcePathStyle: false,
+ s3OutputProvider: null,
+ },
+ context: {
+ requestId: 'request-id',
+ expectedBucketOwner: null,
+ getRemainingTimeInMillis: () => 120_000,
+ },
+ responseWriter: {
+ write: (message) => {
+ chunks.push(message);
+ return Promise.resolve();
+ },
+ end: () => {
+ ended = true;
+ return Promise.resolve();
+ },
+ },
+ providerSpecifics: {
+ printLoggingHelper: false,
+ getBillingCurrency: () => 'USD',
+ readFile: ({expectedBucketOwner}) => {
+ reads.push(expectedBucketOwner);
+ return Promise.resolve(
+ Readable.from([
+ Buffer.from(
+ JSON.stringify(
+ makeInitialOverallRenderProgress(Date.now() + 120_000, false),
+ ),
+ ),
+ ]),
+ );
+ },
+ } as Partial<
+ ProviderSpecifics<MockProvider>
+ > as ProviderSpecifics<MockProvider>,
+ insideFunctionSpecifics: {
+ deleteTmpDir: () => Promise.resolve(),
+ getCurrentRegionInFunction: () => 'mock-region',
+ getCurrentMemorySizeInMb: () => 2048,
+ getCurrentFunctionName: () => 'render-worker',
+ } as InsideFunctionSpecifics<MockProvider>,
+ });
+
+ expect(ended).toBe(true);
+ expect(JSON.parse(Buffer.concat(chunks).toString())).toMatchObject({
+ type: 'success',
+ renderId: 'render-id',
+ bucket: 'render-storage',
+ done: false,
+ });
+ expect(reads).toEqual([null]);
+ expect(process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA).toBeUndefined();
+ } finally {
+ if (previousFlag === undefined) {
+ delete process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA;
+ } else {
+ process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = previousFlag;
+ }
+ }
+});
+
test('buffered still errors are written to the response', async () => {
const chunks: Uint8Array[] = [];
let ended = false;
@@ -42,9 +121,8 @@ test('buffered still errors are written to the response', async () => {
},
},
context: {
- awsRequestId: 'request-id',
- invokedFunctionArn:
- 'arn:aws:lambda:mock-region:123456789012:function:test',
+ requestId: 'request-id',
+ expectedBucketOwner: null,
getRemainingTimeInMillis: () => 120_000,
},
providerSpecifics: {
@@ -97,9 +175,8 @@ test('buffered render start exceptions are written to the response', async () =>
},
},
context: {
- awsRequestId: 'request-id',
- invokedFunctionArn:
- 'arn:aws:lambda:mock-region:123456789012:function:test',
+ requestId: 'request-id',
+ expectedBucketOwner: null,
getRemainingTimeInMillis: () => 120_000,
},
providerSpecifics: {
diff --git a/packages/serverless/src/test/renderer-lifecycle.test.ts b/packages/serverless/src/test/renderer-lifecycle.test.ts
index 15bd1dd8b1..57b5e9b767 100644
--- a/packages/serverless/src/test/renderer-lifecycle.test.ts
+++ b/packages/serverless/src/test/renderer-lifecycle.test.ts
@@ -36,6 +36,11 @@ test.each(['browser launch', 'Chromium path lookup'] as const)(
fs.mkdtempSync(path.join(testRoot, 'render-')),
);
const launchError = new Error(`Failed ${failure}`);
+ const diagnostics: string[] = [];
+ const tmpDirState = {
+ files: [{filename: 'provider-cache', size: 123}],
+ total: 123,
+ };
const browser = {
on: mock(() => undefined),
close: mock(() => Promise.resolve()),
@@ -78,7 +83,7 @@ test.each(['browser launch', 'Chromium path lookup'] as const)(
rendererHandler<MockProvider>({
params: {
type: 'renderer',
- chromiumOptions: {gl: null},
+ chromiumOptions: {gl: 'angle', enableMultiProcessOnLinux: true},
launchFunctionConfig: {version: VERSION},
inputProps: {type: 'payload', payload: '{}'},
resolvedProps: {type: 'payload', payload: '{}'},
@@ -114,11 +119,19 @@ test.each(['browser launch', 'Chromium path lookup'] as const)(
},
} as unknown as ProviderSpecifics<MockProvider>,
requestContext: {
- awsRequestId: currentInvocation,
- invokedFunctionArn: 'arn',
+ requestId: currentInvocation,
+ expectedBucketOwner: null,
getRemainingTimeInMillis: () => 120_000,
},
insideFunctionSpecifics: {
+ normalizeChromiumOptions: null,
+ getTmpDirState: () => tmpDirState,
+ startRendererDiagnostics: (requestId) => {
+ diagnostics.push(`start-${requestId}`);
+ return () => {
+ diagnostics.push(`end-${requestId}`);
+ };
+ },
getCurrentRegionInFunction: () => 'mock-region',
getBrowserInstance: async (options) => {
launchedBrowser = await getBrowserInstanceImplementation(options);
@@ -138,7 +151,10 @@ test.each(['browser launch', 'Chromium path lookup'] as const)(
expect(streamedMessages).toHaveLength(1);
expect(streamedMessages[0]).toMatchObject({
type: 'error-occurred',
- payload: {shouldRetry: true, errorInfo: {message: launchError.message}},
+ payload: {
+ shouldRetry: true,
+ errorInfo: {message: launchError.message, tmpDir: tmpDirState},
+ },
});
currentInvocation = 'B';
@@ -154,6 +170,18 @@ test.each(['browser launch', 'Chromium path lookup'] as const)(
failure === 'browser launch' ? 2 : 1,
);
expect(renderMediaSpy).toHaveBeenCalledTimes(1);
+ for (const spy of [openBrowserSpy, renderMediaSpy]) {
+ expect(spy).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ chromiumOptions: expect.objectContaining({
+ gl: 'angle',
+ enableMultiProcessOnLinux: true,
+ }),
+ }),
+ );
+ }
+
+ expect(diagnostics).toEqual(['start-A', 'end-A', 'start-B', 'end-B']);
expect(onMediaFiles).toHaveBeenCalledTimes(1);
expect(forgetBrowserEventLoop).toHaveBeenCalledTimes(1);
expect(exits).toEqual([]);
@@ -227,8 +255,8 @@ test('a flaky renderer invocation closes its browser before returning', async ()
isFlakyError: () => true,
} as unknown as ProviderSpecifics<MockProvider>,
requestContext: {
- awsRequestId: 'invocation-a',
- invokedFunctionArn: 'arn',
+ requestId: 'invocation-a',
+ expectedBucketOwner: null,
getRemainingTimeInMillis: () => 120_000,
},
insideFunctionSpecifics: {