Skip to content

🎥 Make videos programmatically with React

`@remotion/lambda`: Allow cancelling renders (#10653)

Jonny Burgerec4d03587018
diff --git a/packages/cli/src/cleanup-before-quit.ts b/packages/cli/src/cleanup-before-quit.ts
index 33d363769d..eb2c00fb49 100644
--- a/packages/cli/src/cleanup-before-quit.ts
+++ b/packages/cli/src/cleanup-before-quit.ts
@@ -3,6 +3,10 @@ import {Log} from './log';
const cleanupJobs: {label: string; job: () => void}[] = [];
+type CtrlCHandler = () => number | Promise<number>;
+
+let ctrlCHandler: CtrlCHandler | null = null;
+
export const cleanupBeforeQuit = ({
indent,
logLevel,
@@ -24,16 +28,62 @@ export const registerCleanupJob = (label: string, job: () => void) => {
cleanupJobs.push({job, label});
};
+export const registerCtrlCHandler = (handler: CtrlCHandler) => {
+ ctrlCHandler = handler;
+
+ return () => {
+ if (ctrlCHandler === handler) {
+ ctrlCHandler = null;
+ }
+ };
+};
+
export const handleCtrlC = ({
indent,
logLevel,
+ exit = process.exit,
}: {
indent: boolean;
logLevel: LogLevel;
+ exit?: (exitCode: number) => void;
}) => {
- process.on('SIGINT', () => {
+ let handlingCtrlC = false;
+ let forceExited = false;
+
+ const listener = async () => {
+ if (handlingCtrlC) {
+ forceExited = true;
+ exit(130);
+ return;
+ }
+
+ handlingCtrlC = true;
Log.info({indent: false, logLevel});
+ let exitCode = 0;
+ const handler = ctrlCHandler;
+ ctrlCHandler = null;
+
+ try {
+ if (handler) {
+ exitCode = await handler();
+ }
+ } catch (err) {
+ Log.error(
+ {indent: false, logLevel},
+ err instanceof Error ? err.message : String(err),
+ );
+ exitCode = 1;
+ }
+
+ if (forceExited) {
+ return;
+ }
+
cleanupBeforeQuit({indent, logLevel});
- process.exit(0);
- });
+ exit(exitCode);
+ };
+
+ process.on('SIGINT', listener);
+
+ return () => process.removeListener('SIGINT', listener);
};
diff --git a/packages/cli/src/config/index.ts b/packages/cli/src/config/index.ts
index 3b081da754..71b6ae29bb 100644
--- a/packages/cli/src/config/index.ts
+++ b/packages/cli/src/config/index.ts
@@ -98,6 +98,7 @@ const {
disallowParallelEncodingOption,
deleteAfterOption,
folderExpiryOption,
+ enableCancellationOption,
enableMultiprocessOnLinuxOption,
glOption,
gopSizeOption,
@@ -639,6 +640,10 @@ type FlatConfig = RemotionConfigObject &
* Set whether S3 buckets should be allowed to expire.
*/
setEnableFolderExpiry: (value: boolean | null) => void;
+ /**
+ * Allow `npx remotion lambda render` to cancel a render when Ctrl+C is pressed.
+ */
+ setEnableCancellation: (value: boolean) => void;
/**
* Set whether Lambda Insights should be enabled when deploying a function.
*/
@@ -835,6 +840,7 @@ export const Config: FlatConfig = {
setDisallowParallelEncoding: disallowParallelEncodingOption.setConfig,
setBeepOnFinish: beepOnFinishOption.setConfig,
setEnableFolderExpiry: folderExpiryOption.setConfig,
+ setEnableCancellation: enableCancellationOption.setConfig,
setRepro: reproOption.setConfig,
setLambdaInsights: enableLambdaInsights.setConfig,
setBinariesDirectory: binariesDirectoryOption.setConfig,
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
index 096a74103b..e66991c5a1 100644
--- a/packages/cli/src/index.ts
+++ b/packages/cli/src/index.ts
@@ -9,7 +9,11 @@ import {defaultBrowserDownloadProgress} from './browser-download-bar';
import {bundleCommand} from './bundle';
import {chalk} from './chalk';
import {checkForNpmRunFlagPass} from './check-for-npm-run-flag-pass';
-import {cleanupBeforeQuit, handleCtrlC} from './cleanup-before-quit';
+import {
+ cleanupBeforeQuit,
+ handleCtrlC,
+ registerCtrlCHandler,
+} from './cleanup-before-quit';
import {cloudrunCommand} from './cloudrun-command';
import {listCompositionsCommand} from './compositions';
import {determineFinalStillImageFormat} from './determine-image-format';
@@ -207,4 +211,6 @@ export const CliInternals = {
makeHyperlink,
supportsHyperlink,
getGitSource,
+ handleCtrlC,
+ registerCtrlCHandler,
};
diff --git a/packages/cli/src/parsed-cli.ts b/packages/cli/src/parsed-cli.ts
index 5dd4bf7553..e767246b9c 100644
--- a/packages/cli/src/parsed-cli.ts
+++ b/packages/cli/src/parsed-cli.ts
@@ -19,6 +19,7 @@ const {
encodingMaxRateOption,
deleteAfterOption,
folderExpiryOption,
+ enableCancellationOption,
enableMultiprocessOnLinuxOption,
numberOfGifLoopsOption,
x264Option,
@@ -190,6 +191,9 @@ export type CommandLineOptions = {
[ipv4Option.cliFlag]: TypeOfOption<typeof ipv4Option> | null;
[deleteAfterOption.cliFlag]: TypeOfOption<typeof deleteAfterOption>;
[folderExpiryOption.cliFlag]: TypeOfOption<typeof folderExpiryOption>;
+ [enableCancellationOption.cliFlag]: TypeOfOption<
+ typeof enableCancellationOption
+ > | null;
[enableMultiprocessOnLinuxOption.cliFlag]: TypeOfOption<
typeof enableMultiprocessOnLinuxOption
>;
@@ -232,6 +236,7 @@ export const BooleanFlags = [
disableGitSourceOption.cliFlag,
disallowParallelEncodingOption.cliFlag,
forSeamlessAacConcatenationOption.cliFlag,
+ enableCancellationOption.cliFlag,
reproOption.cliFlag,
isProductionOption.cliFlag,
forceNewStudioOption.cliFlag,
@@ -262,6 +267,7 @@ export const parsedCli = minimist<CommandLineOptions>(process.argv.slice(2), {
[forceNewStudioOption.cliFlag]: null,
[experimentalKeepAudioContextAliveOption.cliFlag]: null,
[mutedOption.cliFlag]: null,
+ [enableCancellationOption.cliFlag]: null,
[rspackOption.cliFlag]: null,
},
}) as CommandLineOptions & {
diff --git a/packages/cli/src/test/boolean-flag-defaults.test.ts b/packages/cli/src/test/boolean-flag-defaults.test.ts
index 433e545e12..0f075fda32 100644
--- a/packages/cli/src/test/boolean-flag-defaults.test.ts
+++ b/packages/cli/src/test/boolean-flag-defaults.test.ts
@@ -6,6 +6,7 @@ const {
beepOnFinishOption,
disableWebSecurityOption,
disallowParallelEncodingOption,
+ enableCancellationOption,
forceNewStudioOption,
headlessOption,
ignoreCertificateErrorsOption,
@@ -28,6 +29,7 @@ test('config-backed boolean flags default to null when absent', () => {
expect(parsedCli[ipv4Option.cliFlag]).toEqual(null);
expect(parsedCli[beepOnFinishOption.cliFlag]).toEqual(null);
expect(parsedCli[disallowParallelEncodingOption.cliFlag]).toEqual(null);
+ expect(parsedCli[enableCancellationOption.cliFlag]).toEqual(null);
expect(parsedCli[reproOption.cliFlag]).toEqual(null);
expect(parsedCli[isProductionOption.cliFlag]).toEqual(null);
expect(parsedCli[forceNewStudioOption.cliFlag]).toEqual(null);
diff --git a/packages/cli/src/test/ctrl-c.test.ts b/packages/cli/src/test/ctrl-c.test.ts
new file mode 100644
index 0000000000..cd85b70aef
--- /dev/null
+++ b/packages/cli/src/test/ctrl-c.test.ts
@@ -0,0 +1,70 @@
+import {expect, test} from 'bun:test';
+import {handleCtrlC, registerCtrlCHandler} from '../cleanup-before-quit';
+
+const waitForTask = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+test('Ctrl+C waits for a command-specific async handler', async () => {
+ let releaseHandler: () => void = () => undefined;
+ const waitUntilReleased = new Promise<void>((resolve) => {
+ releaseHandler = resolve;
+ });
+ const exits: number[] = [];
+ let handlerCalls = 0;
+ const unregisterHandler = registerCtrlCHandler(async () => {
+ handlerCalls++;
+ await waitUntilReleased;
+ return 130;
+ });
+ const unregisterListener = handleCtrlC({
+ indent: false,
+ logLevel: 'error',
+ exit: (exitCode) => exits.push(exitCode),
+ });
+
+ try {
+ process.emit('SIGINT', 'SIGINT');
+ await waitForTask();
+ expect(handlerCalls).toBe(1);
+ expect(exits).toEqual([]);
+
+ releaseHandler();
+ await waitForTask();
+ expect(exits).toEqual([130]);
+ } finally {
+ unregisterHandler();
+ unregisterListener();
+ }
+});
+
+test('a second Ctrl+C exits immediately', async () => {
+ let releaseHandler: () => void = () => undefined;
+ const waitUntilReleased = new Promise<void>((resolve) => {
+ releaseHandler = resolve;
+ });
+ const exits: number[] = [];
+ const unregisterHandler = registerCtrlCHandler(async () => {
+ await waitUntilReleased;
+ return 130;
+ });
+ const unregisterListener = handleCtrlC({
+ indent: false,
+ logLevel: 'error',
+ exit: (exitCode) => exits.push(exitCode),
+ });
+
+ try {
+ process.emit('SIGINT', 'SIGINT');
+ await waitForTask();
+ expect(exits).toEqual([]);
+
+ process.emit('SIGINT', 'SIGINT');
+ expect(exits).toEqual([130]);
+
+ releaseHandler();
+ await waitForTask();
+ expect(exits).toEqual([130]);
+ } finally {
+ unregisterHandler();
+ unregisterListener();
+ }
+});
diff --git a/packages/docs/docs/config.mdx b/packages/docs/docs/config.mdx
index b9972721aa..8e80d6ed18 100644
--- a/packages/docs/docs/config.mdx
+++ b/packages/docs/docs/config.mdx
@@ -966,6 +966,20 @@ import {Config} from '@remotion/cli/config';
Config.setEnableFolderExpiry(true);
```
+## `setEnableCancellation()`<AvailableFrom v="4.0.515" />
+
+<Options id="enable-cancellation" />
+<br />
+<br />
+
+```ts twoslash title="remotion.config.ts"
+import {Config} from '@remotion/cli/config';
+// ---cut---
+Config.setEnableCancellation(true);
+```
+
+The `--enable-cancellation` command line flag will take precedence over this option.
+
## `setLambdaInsights()`<AvailableFrom v="4.0.115" />
<Options id="enable-lambda-insights" />
diff --git a/packages/docs/docs/lambda/cancellation.mdx b/packages/docs/docs/lambda/cancellation.mdx
new file mode 100644
index 0000000000..cc343cc0cc
--- /dev/null
+++ b/packages/docs/docs/lambda/cancellation.mdx
@@ -0,0 +1,103 @@
+---
+image: /generated/articles-docs-lambda-cancellation.png
+id: cancellation
+title: Cancelling Lambda renders
+sidebar_label: Cancelling renders
+crumb: 'Lambda'
+---
+
+# Cancelling Lambda renders<AvailableFrom v="4.0.515" />
+
+By default, a Lambda render continues until it finishes or fails.
+
+To allow a render to be cancelled, polling to S3 needs to be enabled. Each active renderer then makes one S3 `HEAD` request per second.
+
+Set [`enableCancellation`](/docs/lambda/rendermediaonlambda#enablecancellation) to `true` when calling [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda).
+
+Still renders cannot be cancelled because [`renderStillOnLambda()`](/docs/lambda/renderstillonlambda) only returns after the still has been rendered.
+
+```ts twoslash title="cancel-render.ts"
+import {
+ cancelRenderOnLambda,
+ renderMediaOnLambda,
+} from '@remotion/lambda/client';
+
+const {bucketName, renderId} = await renderMediaOnLambda({
+ region: 'us-east-1',
+ functionName: 'remotion-render-bds9aab',
+ composition: 'MyVideo',
+ serveUrl: 'https://remotionlambda-qg35eyp1s1.s3.eu-central-1.amazonaws.com/sites/bf2jrbfkw',
+ codec: 'h264',
+ enableCancellation: true,
+});
+
+// Call this when the render should stop
+await cancelRenderOnLambda({
+ region: 'us-east-1',
+ bucketName,
+ renderId,
+});
+```
+
+Calling [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda) for a render that was not started with `enableCancellation: true` throws an error.
+
+## Cancelling from the CLI
+
+Pass `--enable-cancellation` to [`npx remotion lambda render`](/docs/lambda/cli/render):
+
+```bash title="Terminal"
+npx remotion lambda render <serve-url> <composition-id> --enable-cancellation
+```
+
+Press Ctrl+C to send the cancellation signal. The CLI exits after the signal has been written. Press Ctrl+C again to exit immediately without waiting for the signal to be written.
+
+Without `--enable-cancellation`, pressing Ctrl+C stops the CLI from waiting, but the Lambda render continues.
+
+## Cost
+
+Cancellation is opt-in because each [renderer function](/docs/lambda/how-lambda-works) checks S3 once per second for a cancellation signal.
+
+Each renderer makes approximately one additional S3 `HEAD` request for every second that it is active. Renderer functions stop polling when they finish or receive the cancellation signal.
+
+In the absolute worst case of 200 concurrent functions running for the full 15-minute Lambda limit, polling costs approximately $0.072.
+
+These estimates use the current US East (N. Virginia) ARM list prices and exclude the AWS Free Tier and volume discounts. Prices vary by region. See [AWS Lambda pricing](https://aws.amazon.com/lambda/pricing/) and [Amazon S3 pricing](https://aws.amazon.com/s3/pricing/).
+
+Leave `enableCancellation` at its default value of `false` if the render does not need to be cancellable.
+
+## How cancellation works
+
+[`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda) writes a cancellation signal to S3. Renderer functions stop after seeing the signal during their next poll.
+
+:::note
+Cancellation is asynchronous. The promise returned by `cancelRenderOnLambda()` resolves once the signal has been written, not once every renderer function has stopped.
+:::
+
+If the main function fails or times out, it also sends the cancellation signal to the remaining renderer functions.
+
+Cancelling a render does not delete its files from S3. After cancellation has propagated, use [`deleteRender()`](/docs/lambda/deleterender) to remove them. If the render has already finished, cancelling it does not remove or invalidate the output file.
+
+## Detecting a cancelled render
+
+There is currently no dedicated `cancelled` field. A renderer that receives the cancellation signal adds a fatal error named `CancelledError` to the render progress.
+
+```ts twoslash title="detect-cancellation.ts"
+import type {RenderProgress} from '@remotion/lambda/client';
+
+export const wasRenderCancelled = (progress: RenderProgress) => {
+ return progress.errors.some((error) => error.name === 'CancelledError');
+};
+```
+
+In the value returned by [`getRenderProgress()`](/docs/lambda/getrenderprogress), `fatalErrorEncountered` will also be `true`, while `done` remains `false`.
+
+The same `errors` array is stored in `progress.json`, so checking for `CancelledError` also works when reading the file directly. `fatalErrorEncountered` is derived by `getRenderProgress()` and is not stored in `progress.json`.
+
+If the main function fails or times out, the remaining renderer functions may also report `CancelledError`. The error indicates that a renderer received the cancellation signal, but not why the signal was sent.
+
+## See also
+
+- [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda)
+- [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda)
+- [`getRenderProgress()`](/docs/lambda/getrenderprogress)
+- [How Remotion Lambda works](/docs/lambda/how-lambda-works)
diff --git a/packages/docs/docs/lambda/cancelrenderonlambda.mdx b/packages/docs/docs/lambda/cancelrenderonlambda.mdx
new file mode 100644
index 0000000000..907e521f4d
--- /dev/null
+++ b/packages/docs/docs/lambda/cancelrenderonlambda.mdx
@@ -0,0 +1,77 @@
+---
+image: /generated/articles-docs-lambda-cancelrenderonlambda.png
+id: cancelrenderonlambda
+title: cancelRenderOnLambda()
+crumb: '@remotion/lambda-client'
+---
+
+# cancelRenderOnLambda()<AvailableFrom v="4.0.515" />
+
+Signals the renderer functions of an in-progress Lambda render to stop.
+
+The render must have been started with [`enableCancellation: true`](/docs/lambda/rendermediaonlambda#enablecancellation). Otherwise, this function throws an error.
+
+## Example
+
+```ts twoslash title="cancel-render.ts"
+import {
+ cancelRenderOnLambda,
+ renderMediaOnLambda,
+} from '@remotion/lambda/client';
+
+const {bucketName, renderId} = await renderMediaOnLambda({
+ region: 'us-east-1',
+ functionName: 'remotion-render-bds9aab',
+ composition: 'MyVideo',
+ serveUrl: 'https://remotionlambda-qg35eyp1s1.s3.eu-central-1.amazonaws.com/sites/bf2jrbfkw',
+ codec: 'h264',
+ enableCancellation: true,
+});
+
+await cancelRenderOnLambda({
+ region: 'us-east-1',
+ bucketName,
+ renderId,
+});
+```
+
+Cancellation is asynchronous. Renderer functions stop after their next S3 poll, which occurs once per second.
+
+## Arguments
+
+An object with the following properties:
+
+### `region`
+
+The [AWS region](/docs/lambda/region-selection) in which the render is running.
+
+### `bucketName`
+
+The bucket name returned by [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda).
+
+### `renderId`
+
+The render ID returned by [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda).
+
+### `forcePathStyle?`
+
+Passes `forcePathStyle` to the AWS S3 client. If you don't know what this is, you probably don't need it.
+
+### `requestHandler?`
+
+An AWS SDK request handler. Use it to configure a [proxy](/docs/lambda/proxy).
+
+## Return value
+
+A promise that resolves when the cancellation signal has been written to S3.
+
+## Compatibility
+
+<CompatibilityTable chrome={false} firefox={false} safari={false} nodejs={true} bun={true} serverlessFunctions={true} clientSideRendering={false} serverSideRendering={false} player={false} studio={false} />
+
+## See also
+
+- [Cancelling Lambda renders](/docs/lambda/cancellation)
+- [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda)
+- [`getRenderProgress()`](/docs/lambda/getrenderprogress)
+- [Source code for this function](https://github.com/remotion-dev/remotion/blob/main/packages/lambda-client/src/cancel-render-on-lambda.ts)
diff --git a/packages/docs/docs/lambda/cli/render.mdx b/packages/docs/docs/lambda/cli/render.mdx
index 3803115570..d899b97f2d 100644
--- a/packages/docs/docs/lambda/cli/render.mdx
+++ b/packages/docs/docs/lambda/cli/render.mdx
@@ -77,6 +77,12 @@ npx remotion lambda render --codec=mp3 testbed my-comp
The [AWS region](/docs/lambda/region-selection) to select. Both project and function should be in this region.
+### `--enable-cancellation`<AvailableFrom v="4.0.515" />
+
+<Options id="enable-cancellation" />
+
+Press Ctrl+C to cancel the render. Without this flag, Ctrl+C stops the CLI from waiting while the Lambda render continues.
+
### `--props`
<Options id="props" />
diff --git a/packages/docs/docs/lambda/go.mdx b/packages/docs/docs/lambda/go.mdx
index 230d7d9d1e..d46c9e49b4 100644
--- a/packages/docs/docs/lambda/go.mdx
+++ b/packages/docs/docs/lambda/go.mdx
@@ -116,6 +116,32 @@ func main() {
}
```
+## Cancelling a render<AvailableFrom v="4.0.515" />
+
+Set `EnableCancellation` when starting the render, then pass its response to `CancelRenderOnLambda()`:
+
+```go title="cancel-render.go"
+renderResponse, err := lambda_go_sdk.RenderMediaOnLambda(lambda_go_sdk.RemotionOptions{
+ ServeUrl: serveUrl,
+ FunctionName: functionName,
+ Region: region,
+ Composition: "main",
+ EnableCancellation: true,
+})
+if err != nil {
+ log.Fatal(err)
+}
+
+err = lambda_go_sdk.CancelRenderOnLambda(lambda_go_sdk.CancelRenderOnLambdaInput{
+ Region: region,
+ BucketName: renderResponse.BucketName,
+ RenderId: renderResponse.RenderId,
+})
+if err != nil {
+ log.Fatal(err)
+}
+```
+
## Changelog
`v4.0.6`: The response payload structure has changed. See the history of this page to see the previous structure.
diff --git a/packages/docs/docs/lambda/php.mdx b/packages/docs/docs/lambda/php.mdx
index d4733b9c80..c8dbc28bcc 100644
--- a/packages/docs/docs/lambda/php.mdx
+++ b/packages/docs/docs/lambda/php.mdx
@@ -87,6 +87,22 @@ while (!$renderProgressResponse->done) {
print_r("Render is done!\n");
```
+## Cancelling a render<AvailableFrom v="4.0.515" />
+
+Enable cancellation before starting the render, then call `cancelRenderOnLambda()`:
+
+```php title="cancel-render.php"
+$params = new RenderParams(enableCancellation: true);
+$params->setComposition('react-svg');
+
+$renderResponse = $client->renderMediaOnLambda($params);
+
+$client->cancelRenderOnLambda(
+ $renderResponse->renderId,
+ $renderResponse->bucketName
+);
+```
+
## Changelog
- `v4.0.15`: The fields are now typed. `->setInputProps()` now works as intended, serializing the input props to JSON for you.
diff --git a/packages/docs/docs/lambda/python.mdx b/packages/docs/docs/lambda/python.mdx
index 2b83af8d48..dfd3a38533 100644
--- a/packages/docs/docs/lambda/python.mdx
+++ b/packages/docs/docs/lambda/python.mdx
@@ -82,6 +82,24 @@ if render_response:
print("Render done!", progress_response.outputFile)
```
+## Cancelling a render<AvailableFrom v="4.0.515" />
+
+Enable cancellation before starting the render, then call `cancel_render_on_lambda()`:
+
+```python title="cancel_render.py"
+render_params = RenderMediaParams(
+ composition="react-svg",
+ enable_cancellation=True,
+)
+render_response = client.render_media_on_lambda(render_params)
+
+if render_response:
+ client.cancel_render_on_lambda(
+ render_id=render_response.render_id,
+ bucket_name=render_response.bucket_name,
+ )
+```
+
## Large input props _available from v4.0.315_
The Python SDK automatically handles large input props by uploading them to S3 when they exceed AWS Lambda payload limits:
diff --git a/packages/docs/docs/lambda/rendermediaonlambda.mdx b/packages/docs/docs/lambda/rendermediaonlambda.mdx
index 85692610f0..208657fa46 100644
--- a/packages/docs/docs/lambda/rendermediaonlambda.mdx
+++ b/packages/docs/docs/lambda/rendermediaonlambda.mdx
@@ -69,6 +69,14 @@ The `framesPerLambda` parameter cannot result in more than 200 functions being s
When rendering transparent WebM videos, chunk boundaries can be visible in the alpha channel. See [Known problem: Rendering transparent WebM on Lambda](/docs/transparent-videos#known-problem-rendering-transparent-webm-on-lambda). Increase `framesPerLambda` to reduce boundaries, or render WebM in one pass if the artifact appears.
:::
+### `enableCancellation?`<AvailableFrom v="4.0.515" />
+
+Enable the render to be cancelled using [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda). Default: `false`.
+
+When enabled, every renderer checks S3 once per second for a cancellation signal. This incurs additional S3 `HEAD` request charges for the duration of the render.
+
+See [Cancelling Lambda renders](/docs/lambda/cancellation) for the full workflow.
+
### `concurrency?`<AvailableFrom v="4.0.322" />
Specify the number of Lambda functions to use for rendering. This is an alternative to `framesPerLambda` that allows you to set the concurrency directly without needing to know the video duration.
diff --git a/packages/docs/docs/lambda/ruby.mdx b/packages/docs/docs/lambda/ruby.mdx
index 4c31aa3011..f937b45eb5 100644
--- a/packages/docs/docs/lambda/ruby.mdx
+++ b/packages/docs/docs/lambda/ruby.mdx
@@ -14,7 +14,7 @@ The version should be the same version of the `@remotion/lambda` NPM package ver
## Notes
- This module is experimental and might have breaking changes in minor versions. Check on this page for up-to-date examples.
-- The implemented methods are [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda), [`renderStillOnLambda()`](/docs/lambda/renderstillonlambda) and [`getRenderProgressOnLambda()`](/docs/lambda/getrenderprogress).
+- The implemented methods are [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda), [`renderStillOnLambda()`](/docs/lambda/renderstillonlambda), [`getRenderProgressOnLambda()`](/docs/lambda/getrenderprogress), and [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda).
- We will maintain the Ruby SDK to ensure the fields stay in sync with the Node.js functions.
- The fields in the input payload are `snake_case` versions of the Node.js field names.
- Nested field names, e.g. `s3_output_provder.accessKeyId` have the original `camelCase` capitalization.
@@ -58,6 +58,21 @@ while true
end
```
+## Cancelling a render<AvailableFrom v="4.0.515" />
+
+Enable cancellation in the render payload, then call `cancel_render_on_lambda()`:
+
+```ruby title="Cancelling a render from Ruby"
+payload = get_render_media_on_lambda_payload(
+ composition: "still-helloworld",
+ codec: "h264",
+ enable_cancellation: true,
+)
+
+res = client.render_media_on_lambda(function_name, payload)
+client.cancel_render_on_lambda(res["bucketName"], res["renderId"])
+```
+
## Rendering a still
```ruby title="Rendering a still from Ruby"
diff --git a/packages/docs/docs/lambda/table-of-contents.tsx b/packages/docs/docs/lambda/table-of-contents.tsx
index 54cf5c02d9..719fac0919 100644
--- a/packages/docs/docs/lambda/table-of-contents.tsx
+++ b/packages/docs/docs/lambda/table-of-contents.tsx
@@ -58,6 +58,10 @@ export const TableOfContents: React.FC = () => {
<strong>downloadMedia()</strong>
<div>Download a render artifact from S3</div>
</TOCItem>
+ <TOCItem link="/docs/lambda/cancelrenderonlambda">
+ <strong>cancelRenderOnLambda()</strong>
+ <div>Cancel an in-progress render</div>
+ </TOCItem>
<TOCItem link="/docs/lambda/getuserpolicy">
<strong>getUserPolicy()</strong>
<div>Get the policy JSON for your AWS user</div>
diff --git a/packages/docs/sidebars.ts b/packages/docs/sidebars.ts
index f42ad1b54b..8f0aa55c91 100644
--- a/packages/docs/sidebars.ts
+++ b/packages/docs/sidebars.ts
@@ -445,6 +445,7 @@ const sidebars: SidebarsConfig = {
'lambda/getrenderprogress',
'lambda/presignurl',
'lambda/rendermediaonlambda',
+ 'lambda/cancelrenderonlambda',
'lambda/renderstillonlambda',
'lambda/simulatepermissions',
'lambda/speculatefunctionname',
@@ -1289,6 +1290,7 @@ const sidebars: SidebarsConfig = {
'lambda/custom-destination',
'lambda/checklist',
'lambda/webhooks',
+ 'lambda/cancellation',
'lambda/cost-example',
'lambda/autodelete',
{
diff --git a/packages/docs/src/data/articles.ts b/packages/docs/src/data/articles.ts
index 8a78d07622..c0ce3e96ca 100644
--- a/packages/docs/src/data/articles.ts
+++ b/packages/docs/src/data/articles.ts
@@ -3077,6 +3077,24 @@ export const articles = [
noAi: false,
slug: 'lambda/bucket-security',
},
+ {
+ id: 'cancellation',
+ title: 'Cancelling Lambda renders',
+ relativePath: 'docs/lambda/cancellation.mdx',
+ compId: 'articles-docs-lambda-cancellation',
+ crumb: 'Lambda',
+ noAi: false,
+ slug: 'lambda/cancellation',
+ },
+ {
+ id: 'cancelrenderonlambda',
+ title: 'cancelRenderOnLambda()',
+ relativePath: 'docs/lambda/cancelrenderonlambda.mdx',
+ compId: 'articles-docs-lambda-cancelrenderonlambda',
+ crumb: '@remotion/lambda-client',
+ noAi: false,
+ slug: 'lambda/cancelrenderonlambda',
+ },
{
id: 'changelog',
title: 'Prerelease Changelog',
diff --git a/packages/docs/static/generated/articles-docs-lambda-cancellation.png b/packages/docs/static/generated/articles-docs-lambda-cancellation.png
new file mode 100644
index 0000000000..21ff8370a6
Binary files /dev/null and b/packages/docs/static/generated/articles-docs-lambda-cancellation.png differ
diff --git a/packages/docs/static/generated/articles-docs-lambda-cancelrenderonlambda.png b/packages/docs/static/generated/articles-docs-lambda-cancelrenderonlambda.png
new file mode 100644
index 0000000000..2378a32a42
Binary files /dev/null and b/packages/docs/static/generated/articles-docs-lambda-cancelrenderonlambda.png differ
diff --git a/packages/it-tests/src/monorepo/esm.test.ts b/packages/it-tests/src/monorepo/esm.test.ts
index 3ad328e283..a6913bbad9 100644
--- a/packages/it-tests/src/monorepo/esm.test.ts
+++ b/packages/it-tests/src/monorepo/esm.test.ts
@@ -33,6 +33,9 @@ test('Should be able to "import" frontend in node', async () => {
execSync(
`node --input-type=module -e "import {getRenderProgress} from '@remotion/lambda/client'; console.log(getRenderProgress)"`,
);
+ execSync(
+ `node --input-type=module -e "import {cancelRenderOnLambda} from '@remotion/lambda/client'; console.log(cancelRenderOnLambda)"`,
+ );
execSync(
`node --input-type=module -e "import {getRenderProgress} from '@remotion/lambda'; console.log(getRenderProgress)"`,
);
diff --git a/packages/it-tests/src/monorepo/go-package.test.ts b/packages/it-tests/src/monorepo/go-package.test.ts
index 5a6532e2e0..371556a8dd 100644
--- a/packages/it-tests/src/monorepo/go-package.test.ts
+++ b/packages/it-tests/src/monorepo/go-package.test.ts
@@ -32,6 +32,7 @@ test(
const nativeVersion =
await LambdaClientInternals.makeLambdaRenderMediaPayload({
+ enableCancellation: false,
region: 'us-east-1',
composition: 'react-svg',
functionName: 'remotion-render',
diff --git a/packages/it-tests/src/monorepo/php-package.test.ts b/packages/it-tests/src/monorepo/php-package.test.ts
index 1465d2d968..e3045c62a6 100644
--- a/packages/it-tests/src/monorepo/php-package.test.ts
+++ b/packages/it-tests/src/monorepo/php-package.test.ts
@@ -97,6 +97,7 @@ class Semantic
const toParse = output[5];
const nativeVersion =
await LambdaClientInternals.makeLambdaRenderMediaPayload({
+ enableCancellation: false,
region: 'us-east-1',
composition: 'react-svg',
functionName: 'remotion-render',
diff --git a/packages/it-tests/src/monorepo/python-package.test.ts b/packages/it-tests/src/monorepo/python-package.test.ts
index 73f81f3210..a917985a99 100644
--- a/packages/it-tests/src/monorepo/python-package.test.ts
+++ b/packages/it-tests/src/monorepo/python-package.test.ts
@@ -49,6 +49,7 @@ test('Python package should create the same renderMedia payload as normal Lambda
const toParse = output[PYTHON_OUTPUT_MARKER];
const nativeVersion =
await LambdaClientInternals.makeLambdaRenderMediaPayload({
+ enableCancellation: false,
requestHandler: null,
region: 'us-east-1',
composition: 'react-svg',
diff --git a/packages/it-tests/src/monorepo/ruby-package.test.ts b/packages/it-tests/src/monorepo/ruby-package.test.ts
index 1778547ed4..c878aca311 100644
--- a/packages/it-tests/src/monorepo/ruby-package.test.ts
+++ b/packages/it-tests/src/monorepo/ruby-package.test.ts
@@ -75,6 +75,7 @@ test('Render Media payload', async () => {
const nativeVersion =
await LambdaClientInternals.makeLambdaRenderMediaPayload({
+ enableCancellation: false,
region: 'us-east-1',
composition: 'react-svg',
functionName: 'remotion-render',
diff --git a/packages/lambda-client/src/cancel-render-on-lambda.ts b/packages/lambda-client/src/cancel-render-on-lambda.ts
new file mode 100644
index 0000000000..ce66a43274
--- /dev/null
+++ b/packages/lambda-client/src/cancel-render-on-lambda.ts
@@ -0,0 +1,73 @@
+import type {ProviderSpecifics} from '@remotion/serverless-client';
+import {
+ getOverallProgressFromStorage,
+ writeCancellationSignal,
+} from '@remotion/serverless-client';
+import {awsImplementation, type AwsProvider} from './aws-provider';
+import type {AwsRegion} from './regions';
+import type {RequestHandler} from './types';
+
+export type CancelRenderOnLambdaInput = {
+ region: AwsRegion;
+ bucketName: string;
+ renderId: string;
+ forcePathStyle?: boolean;
+ requestHandler?: RequestHandler;
+};
+
+type InternalCancelRenderOnLambdaInput = Omit<
+ CancelRenderOnLambdaInput,
+ 'forcePathStyle' | 'requestHandler'
+> & {
+ forcePathStyle: boolean;
+ requestHandler: RequestHandler | null;
+ providerSpecifics: ProviderSpecifics<AwsProvider>;
+};
+
+export const internalCancelRenderOnLambda = async (
+ input: InternalCancelRenderOnLambdaInput,
+): Promise<void> => {
+ const expectedBucketOwner = await input.providerSpecifics.getAccountId({
+ region: input.region,
+ });
+ const progress = await getOverallProgressFromStorage({
+ bucketName: input.bucketName,
+ expectedBucketOwner,
+ region: input.region,
+ renderId: input.renderId,
+ providerSpecifics: input.providerSpecifics,
+ forcePathStyle: input.forcePathStyle,
+ requestHandler: input.requestHandler,
+ });
+
+ if (progress.cancellationEnabled !== true) {
+ throw new Error(
+ `Cannot cancel render ${input.renderId}: The render was not started with enableCancellation: true.`,
+ );
+ }
+
+ await writeCancellationSignal({
+ bucketName: input.bucketName,
+ renderId: input.renderId,
+ region: input.region,
+ expectedBucketOwner,
+ providerSpecifics: input.providerSpecifics,
+ forcePathStyle: input.forcePathStyle,
+ requestHandler: input.requestHandler,
+ });
+};
+
+/*
+ * @description Cancels an in-progress render that was started with enableCancellation: true.
+ * @see [Documentation](https://remotion.dev/docs/lambda/cancelrenderonlambda)
+ */
+export const cancelRenderOnLambda = (
+ input: CancelRenderOnLambdaInput,
+): Promise<void> => {
+ return internalCancelRenderOnLambda({
+ ...input,
+ forcePathStyle: input.forcePathStyle ?? false,
+ requestHandler: input.requestHandler ?? null,
+ providerSpecifics: awsImplementation,
+ });
+};
diff --git a/packages/lambda-client/src/index.ts b/packages/lambda-client/src/index.ts
index 9e92eab1d1..c1df53ab9b 100644
--- a/packages/lambda-client/src/index.ts
+++ b/packages/lambda-client/src/index.ts
@@ -17,6 +17,7 @@ import {
getAwsRegionMetadata,
} from './aws-region-metadata';
import {parseJsonOrThrowSource} from './call-lambda-streaming';
+import {internalCancelRenderOnLambda} from './cancel-render-on-lambda';
import {cleanItems} from './clean-items';
import {
DEFAULT_CLOUDWATCH_RETENTION_PERIOD,
@@ -73,6 +74,10 @@ export type {
} from '@remotion/serverless-client';
export {appRouterWebhook, NextWebhookArgs} from './app-router-webhook';
export {AwsProvider} from './aws-provider';
+export {
+ cancelRenderOnLambda,
+ type CancelRenderOnLambdaInput,
+} from './cancel-render-on-lambda';
export type {
AwsBillingCurrency,
AwsPartition,
@@ -142,6 +147,7 @@ export const LambdaClientInternals: {
makeLambdaRenderMediaPayload: typeof makeLambdaRenderMediaPayload;
renderMediaOnLambdaOptionalToRequired: typeof renderMediaOnLambdaOptionalToRequired;
internalDeleteRender: typeof internalDeleteRender;
+ internalCancelRenderOnLambda: typeof internalCancelRenderOnLambda;
internalGetSites: typeof internalGetSites;
getLifeCycleRules: typeof getLifeCycleRules;
awsImplementation: typeof awsImplementation;
@@ -187,6 +193,7 @@ export const LambdaClientInternals: {
makeLambdaRenderMediaPayload,
renderMediaOnLambdaOptionalToRequired,
internalDeleteRender,
+ internalCancelRenderOnLambda,
internalGetSites,
getLifeCycleRules,
awsImplementation,
diff --git a/packages/lambda-client/src/make-lambda-payload.ts b/packages/lambda-client/src/make-lambda-payload.ts
index 214261e8bf..0a645203d2 100644
--- a/packages/lambda-client/src/make-lambda-payload.ts
+++ b/packages/lambda-client/src/make-lambda-payload.ts
@@ -41,6 +41,7 @@ import {validateLambdaCodec} from './validate-lambda-codec';
import {validateServeUrl} from './validate-serveurl';
export type InnerRenderMediaOnLambdaInput = {
+ enableCancellation: boolean;
region: AwsRegion;
functionName: string;
serveUrl: string;
@@ -96,6 +97,7 @@ export type InnerRenderMediaOnLambdaInput = {
>;
export const makeLambdaRenderMediaPayload = async ({
+ enableCancellation,
rendererFunctionName,
frameRange,
framesPerLambda,
@@ -183,6 +185,7 @@ export const makeLambdaRenderMediaPayload = async ({
logLevel,
});
return {
+ enableCancellation,
rendererFunctionName,
framesPerLambda,
concurrency,
diff --git a/packages/lambda-client/src/render-media-on-lambda.ts b/packages/lambda-client/src/render-media-on-lambda.ts
index f7e5ea2ccf..a937137268 100644
--- a/packages/lambda-client/src/render-media-on-lambda.ts
+++ b/packages/lambda-client/src/render-media-on-lambda.ts
@@ -32,6 +32,7 @@ import type {AwsRegion} from './regions';
import type {RequestHandler} from './types';
export type RenderMediaOnLambdaInput = {
+ enableCancellation?: boolean;
region: AwsRegion;
functionName: string;
serveUrl: string;
@@ -160,6 +161,7 @@ export const renderMediaOnLambdaOptionalToRequired = (
options: RenderMediaOnLambdaInput,
): InnerRenderMediaOnLambdaInput => {
return {
+ enableCancellation: options.enableCancellation ?? false,
offthreadVideoThreads: options.offthreadVideoThreads ?? null,
audioBitrate: options.audioBitrate ?? null,
audioCodec: options.audioCodec ?? null,
diff --git a/packages/lambda-client/src/test/cancel-render-on-lambda.test.ts b/packages/lambda-client/src/test/cancel-render-on-lambda.test.ts
new file mode 100644
index 0000000000..60462de112
--- /dev/null
+++ b/packages/lambda-client/src/test/cancel-render-on-lambda.test.ts
@@ -0,0 +1,84 @@
+import {expect, test} from 'bun:test';
+import {Readable} from 'node:stream';
+import {
+ cancellationKey,
+ overallProgressKey,
+ type ProviderSpecifics,
+} from '@remotion/serverless-client';
+import {awsImplementation, type AwsProvider} from '../aws-provider';
+import {internalCancelRenderOnLambda} from '../cancel-render-on-lambda';
+
+const makeProviderSpecifics = ({
+ cancellationEnabled,
+ onWrite,
+}: {
+ cancellationEnabled: boolean | undefined;
+ onWrite: ProviderSpecifics<AwsProvider>['writeFile'];
+}): ProviderSpecifics<AwsProvider> => {
+ return {
+ ...awsImplementation,
+ getAccountId: () => Promise.resolve('123456789012'),
+ readFile: ({key}) => {
+ expect(key).toBe(overallProgressKey('render-id'));
+ return Promise.resolve(
+ Readable.from([
+ Buffer.from(
+ JSON.stringify({
+ cancellationEnabled,
+ }),
+ ),
+ ]),
+ );
+ },
+ writeFile: onWrite,
+ };
+};
+
+test('writes a cancellation signal for an opted-in render', async () => {
+ let writes = 0;
+ const providerSpecifics = makeProviderSpecifics({
+ cancellationEnabled: true,
+ onWrite: (input) => {
+ writes++;
+ expect(input.bucketName).toBe('bucket');
+ expect(input.key).toBe(cancellationKey('render-id'));
+ expect(input.privacy).toBe('private');
+ expect(JSON.parse(String(input.body)).cancelledAt).toBeNumber();
+ return Promise.resolve();
+ },
+ });
+
+ await internalCancelRenderOnLambda({
+ bucketName: 'bucket',
+ renderId: 'render-id',
+ region: 'us-east-1',
+ forcePathStyle: false,
+ requestHandler: null,
+ providerSpecifics,
+ });
+
+ expect(writes).toBe(1);
+});
+
+test('rejects cancellation if the render did not opt in', async () => {
+ let writes = 0;
+ const providerSpecifics = makeProviderSpecifics({
+ cancellationEnabled: undefined,
+ onWrite: () => {
+ writes++;
+ return Promise.resolve();
+ },
+ });
+
+ await expect(
+ internalCancelRenderOnLambda({
+ bucketName: 'bucket',
+ renderId: 'render-id',
+ region: 'us-east-1',
+ forcePathStyle: false,
+ requestHandler: null,
+ providerSpecifics,
+ }),
+ ).rejects.toThrow('enableCancellation: true');
+ expect(writes).toBe(0);
+});
diff --git a/packages/lambda-client/src/test/concurrency-payload.test.ts b/packages/lambda-client/src/test/concurrency-payload.test.ts
index c33c74cae7..6048db471f 100644
--- a/packages/lambda-client/src/test/concurrency-payload.test.ts
+++ b/packages/lambda-client/src/test/concurrency-payload.test.ts
@@ -4,6 +4,7 @@ import {makeLambdaRenderMediaPayload} from '../make-lambda-payload';
test('Should include concurrency field in payload', async () => {
const payload = await makeLambdaRenderMediaPayload({
+ enableCancellation: false,
region: 'us-east-1',
functionName: 'test-function',
serveUrl: 'https://example.com',
@@ -68,6 +69,7 @@ test('Should include concurrency field in payload', async () => {
test('Should handle null concurrency', async () => {
const payload = await makeLambdaRenderMediaPayload({
+ enableCancellation: false,
region: 'us-east-1',
functionName: 'test-function',
serveUrl: 'https://example.com',
diff --git a/packages/lambda-client/src/test/overwrite-default.test.ts b/packages/lambda-client/src/test/overwrite-default.test.ts
index 5c5cdcbe73..ab2c2c24ef 100644
--- a/packages/lambda-client/src/test/overwrite-default.test.ts
+++ b/packages/lambda-client/src/test/overwrite-default.test.ts
@@ -15,6 +15,18 @@ test('keeps an omitted overwrite value unresolved', () => {
const options = renderMediaOnLambdaOptionalToRequired(getOptions());
expect(options.overwrite).toBeUndefined();
+ expect(options.enableCancellation).toBe(false);
+});
+
+test('preserves enableCancellation in the Lambda payload', async () => {
+ const options = renderMediaOnLambdaOptionalToRequired({
+ ...getOptions(),
+ enableCancellation: true,
+ });
+
+ expect(options.enableCancellation).toBe(true);
+ const payload = await makeLambdaRenderMediaPayload(options);
+ expect(payload.enableCancellation).toBe(true);
});
test('preserves an explicit overwrite value', () => {
diff --git a/packages/lambda-go/internalops.go b/packages/lambda-go/internalops.go
index c8aca4e037..cea3296cf9 100644
--- a/packages/lambda-go/internalops.go
+++ b/packages/lambda-go/internalops.go
@@ -26,6 +26,7 @@ func constructRenderInternals(options *RemotionOptions) (*renderInternalOptions,
}
internalParams := renderInternalOptions{
+ EnableCancellation: options.EnableCancellation,
ServeUrl: options.ServeUrl,
InputProps: inputProps,
Composition: options.Composition,
diff --git a/packages/lambda-go/lambda_go_sdk.go b/packages/lambda-go/lambda_go_sdk.go
index 4e0b22fb28..c53ce968d1 100644
--- a/packages/lambda-go/lambda_go_sdk.go
+++ b/packages/lambda-go/lambda_go_sdk.go
@@ -1,5 +1,7 @@
package lambda_go_sdk
+import "github.com/go-playground/validator/v10"
+
func RenderMediaOnLambda(input RemotionOptions) (*RemotionRenderResponse, error) {
return invokeRenderLambda(input)
}
@@ -7,3 +9,17 @@ func RenderMediaOnLambda(input RemotionOptions) (*RemotionRenderResponse, error)
func GetRenderProgress(input RenderConfig) (*RenderProgress, error) {
return invokeRenderProgressLambda(input)
}
+
+func CancelRenderOnLambda(input CancelRenderOnLambdaInput) error {
+ validate := validator.New()
+ if err := validate.Struct(input); err != nil {
+ return err
+ }
+
+ s3Client, err := newS3Client(input.Region, input.ForcePathStyle)
+ if err != nil {
+ return err
+ }
+
+ return cancelRenderOnLambda(s3Client, input)
+}
diff --git a/packages/lambda-go/lambda_go_sdk_test.go b/packages/lambda-go/lambda_go_sdk_test.go
index 3166187479..97576302c3 100644
--- a/packages/lambda-go/lambda_go_sdk_test.go
+++ b/packages/lambda-go/lambda_go_sdk_test.go
@@ -34,6 +34,30 @@ type objectUploaderMock struct {
err error
}
+type cancellationObjectClientMock struct {
+ progress string
+ getInput *s3.GetObjectInput
+ putInput *s3.PutObjectInput
+}
+
+func (mock *cancellationObjectClientMock) GetObject(
+ _ context.Context,
+ input *s3.GetObjectInput,
+ _ ...func(*s3.Options),
+) (*s3.GetObjectOutput, error) {
+ mock.getInput = input
+ return &s3.GetObjectOutput{Body: io.NopCloser(strings.NewReader(mock.progress))}, nil
+}
+
+func (mock *cancellationObjectClientMock) PutObject(
+ _ context.Context,
+ input *s3.PutObjectInput,
+ _ ...func(*s3.Options),
+) (*s3.PutObjectOutput, error) {
+ mock.putInput = input
+ return &s3.PutObjectOutput{}, nil
+}
+
func (mock *objectUploaderMock) PutObject(
_ context.Context,
input *s3.PutObjectInput,
@@ -66,6 +90,45 @@ func TestPrintVersion(t *testing.T) {
println(string(jsonData))
}
+func TestCancelRenderOnLambda(t *testing.T) {
+ client := &cancellationObjectClientMock{progress: `{"cancellationEnabled":true}`}
+ input := CancelRenderOnLambdaInput{
+ Region: "us-east-1",
+ BucketName: "remotionlambda-test",
+ RenderId: "render-id",
+ }
+
+ if err := cancelRenderOnLambda(client, input); err != nil {
+ t.Fatalf("could not cancel render: %v", err)
+ }
+ if aws.ToString(client.getInput.Key) != "renders/render-id/progress.json" {
+ t.Fatalf("unexpected progress key: %s", aws.ToString(client.getInput.Key))
+ }
+ if aws.ToString(client.putInput.Key) != "renders/render-id/cancel.json" {
+ t.Fatalf("unexpected cancellation key: %s", aws.ToString(client.putInput.Key))
+ }
+ body, err := io.ReadAll(client.putInput.Body)
+ if err != nil {
+ t.Fatalf("could not read cancellation body: %v", err)
+ }
+ var cancellationBody map[string]int64
+ if err := json.Unmarshal(body, &cancellationBody); err != nil {
+ t.Fatalf("could not parse cancellation body: %v", err)
+ }
+ if cancellationBody["cancelledAt"] <= 0 {
+ t.Fatalf("expected cancelledAt timestamp, got %s", string(body))
+ }
+
+ disabledClient := &cancellationObjectClientMock{progress: `{}`}
+ err = cancelRenderOnLambda(disabledClient, input)
+ if err == nil || !strings.Contains(err.Error(), "enableCancellation: true") {
+ t.Fatalf("expected cancellation opt-in error, got %v", err)
+ }
+ if disabledClient.putInput != nil {
+ t.Fatal("should not write a cancellation signal for a disabled render")
+ }
+}
+
func TestRenderPayloadNumberOfGifLoops(t *testing.T) {
tests := []struct {
name string
diff --git a/packages/lambda-go/models.go b/packages/lambda-go/models.go
index 62674b6212..0e5c55a916 100644
--- a/packages/lambda-go/models.go
+++ b/packages/lambda-go/models.go
@@ -1,6 +1,7 @@
package lambda_go_sdk
type RemotionOptions struct {
+ EnableCancellation bool `json:"enableCancellation"`
ServeUrl string `json:"serveUrl" validate:"required"`
FunctionName string `json:"functionName" validate:"required"`
RendererFunctionName string `json:"rendererFunctionName"`
@@ -58,6 +59,7 @@ type RemotionOptions struct {
}
type renderInternalOptions struct {
+ EnableCancellation bool `json:"enableCancellation"`
RendererFunctionName *string `json:"rendererFunctionName"`
FramesPerLambda *string `json:"framesPerLambda"`
Composition string `json:"composition" validate:"required"`
@@ -138,6 +140,13 @@ type RenderConfig struct {
ForcePathStyle bool `json:"forcePathStyle"`
}
+type CancelRenderOnLambdaInput struct {
+ RenderId string `json:"renderId" validate:"required"`
+ BucketName string `json:"bucketName" validate:"required"`
+ Region string `json:"region" validate:"required"`
+ ForcePathStyle bool `json:"forcePathStyle"`
+}
+
type renderProgressInternalConfig struct {
RenderId string `json:"renderId" validate:"required"`
BucketName string `json:"bucketName" validate:"required"`
diff --git a/packages/lambda-go/s3.go b/packages/lambda-go/s3.go
index 6da37ae49f..a093a5bf5f 100644
--- a/packages/lambda-go/s3.go
+++ b/packages/lambda-go/s3.go
@@ -5,10 +5,13 @@ import (
"crypto/rand"
"crypto/sha256"
"encoding/hex"
+ "encoding/json"
"errors"
"fmt"
+ "io"
"math/big"
"strings"
+ "time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
@@ -28,6 +31,11 @@ type objectUploader interface {
PutObject(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)
}
+type cancellationObjectClient interface {
+ GetObject(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)
+ PutObject(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)
+}
+
// hashPayload returns the SHA256 hex digest used as the input-props object name.
func hashPayload(payload string) string {
sum := sha256.Sum256([]byte(payload))
@@ -61,6 +69,56 @@ func inputPropsKey(hash string) string {
return fmt.Sprintf("input-props/%s.json", hash)
}
+func overallProgressKey(renderId string) string {
+ return fmt.Sprintf("renders/%s/progress.json", renderId)
+}
+
+func cancellationKey(renderId string) string {
+ return fmt.Sprintf("renders/%s/cancel.json", renderId)
+}
+
+func cancelRenderOnLambda(client cancellationObjectClient, input CancelRenderOnLambdaInput) error {
+ progressObject, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
+ Bucket: new(input.BucketName),
+ Key: new(overallProgressKey(input.RenderId)),
+ })
+ if err != nil {
+ return fmt.Errorf("could not read progress for render %q: %w", input.RenderId, err)
+ }
+ defer progressObject.Body.Close()
+
+ progressBody, err := io.ReadAll(progressObject.Body)
+ if err != nil {
+ return fmt.Errorf("could not read progress for render %q: %w", input.RenderId, err)
+ }
+
+ var progress struct {
+ CancellationEnabled bool `json:"cancellationEnabled"`
+ }
+ if err := json.Unmarshal(progressBody, &progress); err != nil {
+ return fmt.Errorf("could not parse progress for render %q: %w", input.RenderId, err)
+ }
+ if !progress.CancellationEnabled {
+ return fmt.Errorf("cannot cancel render %s: the render was not started with enableCancellation: true", input.RenderId)
+ }
+
+ cancellationBody, err := json.Marshal(map[string]int64{"cancelledAt": time.Now().UnixMilli()})
+ if err != nil {
+ return fmt.Errorf("could not serialize cancellation signal: %w", err)
+ }
+ _, err = client.PutObject(context.TODO(), &s3.PutObjectInput{
+ Bucket: new(input.BucketName),
+ Key: new(cancellationKey(input.RenderId)),
+ Body: strings.NewReader(string(cancellationBody)),
+ ContentType: new("application/json"),
+ })
+ if err != nil {
+ return fmt.Errorf("could not cancel render %q: %w", input.RenderId, err)
+ }
+
+ return nil
+}
+
// newS3Client creates an S3 client using the same shared config resolution as
// the Lambda client in invocations.go.
func newS3Client(region string, forcePathStyle bool) (*s3.Client, error) {
diff --git a/packages/lambda-php/src/PHPClient.php b/packages/lambda-php/src/PHPClient.php
index 83d4438582..ffe792696c 100644
--- a/packages/lambda-php/src/PHPClient.php
+++ b/packages/lambda-php/src/PHPClient.php
@@ -294,6 +294,59 @@ class PHPClient
return $this->handleLambdaResponseProgress($result);
}
+ public function cancelRenderOnLambda(string $renderId, string $bucketName): void
+ {
+ try {
+ $progress = json_decode(
+ $this->readProgressFromS3($bucketName, "renders/{$renderId}/progress.json"),
+ true,
+ 512,
+ JSON_THROW_ON_ERROR
+ );
+ } catch (\Throwable $exception) {
+ throw new Exception("Could not read progress for render {$renderId}: {$exception->getMessage()}", 0, $exception);
+ }
+
+ if (($progress['cancellationEnabled'] ?? false) !== true) {
+ throw new InvalidArgumentException(
+ "Cannot cancel render {$renderId}: The render was not started with enableCancellation: true."
+ );
+ }
+
+ try {
+ $this->writeCancellationToS3(
+ $bucketName,
+ "renders/{$renderId}/cancel.json",
+ json_encode(
+ ['cancelledAt' => (int) floor(microtime(true) * 1000)],
+ JSON_THROW_ON_ERROR
+ )
+ );
+ } catch (\Throwable $exception) {
+ throw new Exception("Could not cancel render {$renderId}: {$exception->getMessage()}", 0, $exception);
+ }
+ }
+
+ protected function readProgressFromS3(string $bucketName, string $key): string
+ {
+ $result = $this->createS3Client()->getObject([
+ 'Bucket' => $bucketName,
+ 'Key' => $key,
+ ]);
+
+ return (string) $result['Body'];
+ }
+
+ protected function writeCancellationToS3(string $bucketName, string $key, string $body): void
+ {
+ $this->createS3Client()->putObject([
+ 'Bucket' => $bucketName,
+ 'Key' => $key,
+ 'Body' => $body,
+ 'ContentType' => 'application/json',
+ ]);
+ }
+
private function invokeLambdaFunction(string $payload)
{
$result = $this->client->invoke([
diff --git a/packages/lambda-php/src/RenderParams.php b/packages/lambda-php/src/RenderParams.php
index 7ca8fcdce4..b5327f02f9 100644
--- a/packages/lambda-php/src/RenderParams.php
+++ b/packages/lambda-php/src/RenderParams.php
@@ -6,6 +6,7 @@ use stdClass;
class RenderParams
{
+ protected $enableCancellation = false;
protected $data = null;
protected $bucketName = null;
protected $region = null;
@@ -114,7 +115,8 @@ class RenderParams
?bool $forcePathStyle = false,
?array $metadata = null,
?bool $isProduction = null,
- ?int $gopSize = null
+ ?int $gopSize = null,
+ ?bool $enableCancellation = false
)
{
if ($chromiumOptions === null) {
@@ -171,6 +173,7 @@ class RenderParams
$this->forcePathStyle = $forcePathStyle;
$this->isProduction = $isProduction;
$this->gopSize = $gopSize;
+ $this->enableCancellation = $enableCancellation;
}
private array $inputProps = array();
@@ -178,6 +181,7 @@ class RenderParams
public function serializeParams()
{
$parameters = [
+ 'enableCancellation' => $this->getEnableCancellation(),
'rendererFunctionName' => $this->getRendererFunctionName(),
'framesPerLambda' => $this->getFramesPerLambda(),
'composition' => $this->getComposition(),
@@ -274,6 +278,18 @@ class RenderParams
return $parameters;
}
+ public function getEnableCancellation()
+ {
+ return $this->enableCancellation;
+ }
+
+ public function setEnableCancellation($enableCancellation)
+ {
+ $this->enableCancellation = $enableCancellation;
+
+ return $this;
+ }
+
public function getForcePathStyle()
{
return $this->forcePathStyle;
diff --git a/packages/lambda-php/tests/PHPClientTest.php b/packages/lambda-php/tests/PHPClientTest.php
index 00294c71c8..6a0dc784d7 100644
--- a/packages/lambda-php/tests/PHPClientTest.php
+++ b/packages/lambda-php/tests/PHPClientTest.php
@@ -6,6 +6,26 @@ use PHPUnit\Framework\TestCase;
use Remotion\LambdaPhp\PHPClient;
use Remotion\LambdaPhp\RenderParams;
+class CancellationPHPClient extends PHPClient
+{
+ public array $writes = [];
+ public bool $cancellationEnabled = true;
+
+ public function __construct()
+ {
+ }
+
+ protected function readProgressFromS3(string $bucketName, string $key): string
+ {
+ return json_encode(['cancellationEnabled' => $this->cancellationEnabled]);
+ }
+
+ protected function writeCancellationToS3(string $bucketName, string $key, string $body): void
+ {
+ $this->writes[] = compact('bucketName', 'key', 'body');
+ }
+}
+
class PHPClientTest extends TestCase
{
public function testOverwriteDefaultsToFalseInV4()
@@ -14,6 +34,31 @@ class PHPClientTest extends TestCase
$this->assertFalse($params->getOverwrite());
$this->assertFalse($params->serializeParams()['overwrite']);
+ $this->assertFalse($params->serializeParams()['enableCancellation']);
+ }
+
+ public function testEnableCancellationAndCancelRender()
+ {
+ $params = new RenderParams(enableCancellation: true);
+ $this->assertTrue($params->serializeParams()['enableCancellation']);
+
+ $client = new CancellationPHPClient();
+ $client->cancelRenderOnLambda('render-id', 'remotionlambda-test');
+
+ $this->assertCount(1, $client->writes);
+ $this->assertEquals('remotionlambda-test', $client->writes[0]['bucketName']);
+ $this->assertEquals('renders/render-id/cancel.json', $client->writes[0]['key']);
+ $this->assertGreaterThan(0, json_decode($client->writes[0]['body'], true)['cancelledAt']);
+ }
+
+ public function testCancelRenderRequiresOptIn()
+ {
+ $client = new CancellationPHPClient();
+ $client->cancellationEnabled = false;
+
+ $this->expectException(\InvalidArgumentException::class);
+ $this->expectExceptionMessage('enableCancellation: true');
+ $client->cancelRenderOnLambda('render-id', 'remotionlambda-test');
}
public function testExplicitOverwriteValueIsPreserved()
diff --git a/packages/lambda-python/remotion_lambda/models.py b/packages/lambda-python/remotion_lambda/models.py
index be038b12fb..bdae181518 100644
--- a/packages/lambda-python/remotion_lambda/models.py
+++ b/packages/lambda-python/remotion_lambda/models.py
@@ -282,6 +282,7 @@ class RenderMediaParams:
region: Optional[str] = None
out_name: Optional[Union[str, OutNameInputObject]] = None
prefer_lossless: Optional[bool] = False
+ enable_cancellation: bool = False
composition: str = ""
serve_url: str = ""
frames_per_lambda: Optional[int] = None
@@ -342,6 +343,7 @@ class RenderMediaParams:
Convert instance attributes to a dictionary for serialization.
"""
parameters = {
+ 'enableCancellation': self.enable_cancellation,
'rendererFunctionName': self.renderer_function_name,
'framesPerLambda': self.frames_per_lambda,
'concurrency': self.concurrency,
diff --git a/packages/lambda-python/remotion_lambda/remotionclient.py b/packages/lambda-python/remotion_lambda/remotionclient.py
index 266efb83a9..9ba127cb1d 100644
--- a/packages/lambda-python/remotion_lambda/remotionclient.py
+++ b/packages/lambda-python/remotion_lambda/remotionclient.py
@@ -4,6 +4,7 @@ from dataclasses import asdict
import random
import json
import hashlib
+import time
from math import ceil
from typing import Optional, Union, List, Dict, Any
from enum import Enum
@@ -626,6 +627,38 @@ class RemotionClient:
return None
+ def cancel_render_on_lambda(self, render_id: str, bucket_name: str) -> None:
+ """Cancel a render started with ``enable_cancellation=True``."""
+ s3_client = self._create_s3_client()
+ try:
+ progress_object = s3_client.get_object(
+ Bucket=bucket_name,
+ Key=f"renders/{render_id}/progress.json",
+ )
+ progress = json.loads(progress_object['Body'].read())
+ except (ClientError, KeyError, TypeError, json.JSONDecodeError) as error:
+ raise RemotionException(
+ f"Could not read progress for render {render_id}: {error}"
+ ) from error
+
+ if progress.get('cancellationEnabled') is not True:
+ raise RemotionInvalidArgumentException(
+ f"Cannot cancel render {render_id}: The render was not started "
+ "with enableCancellation: true."
+ )
+
+ try:
+ s3_client.put_object(
+ Bucket=bucket_name,
+ Key=f"renders/{render_id}/cancel.json",
+ Body=json.dumps({'cancelledAt': int(time.time() * 1000)}),
+ ContentType='application/json',
+ )
+ except ClientError as error:
+ raise RemotionException(
+ f"Could not cancel render {render_id}: {error}"
+ ) from error
+
def render_still_on_lambda(
self, render_params: RenderStillParams
) -> Optional[RenderStillResponse]:
diff --git a/packages/lambda-python/tests/test_render_client_render_media.py b/packages/lambda-python/tests/test_render_client_render_media.py
index 673f505a24..911eee2886 100644
--- a/packages/lambda-python/tests/test_render_client_render_media.py
+++ b/packages/lambda-python/tests/test_render_client_render_media.py
@@ -1,5 +1,6 @@
+import json
from unittest import TestCase
-from unittest.mock import patch
+from unittest.mock import Mock, patch
from remotion_lambda.models import RenderMediaParams, ShouldDownload, Webhook
from remotion_lambda.remotionclient import RemotionClient
@@ -11,6 +12,46 @@ class TestRemotionClient(TestCase):
render_params = RenderMediaParams()
self.assertFalse(render_params.serialize_params()['overwrite'])
+ self.assertFalse(render_params.serialize_params()['enableCancellation'])
+
+ def test_enable_cancellation_is_serialized(self):
+ render_params = RenderMediaParams(enable_cancellation=True)
+
+ self.assertTrue(render_params.serialize_params()['enableCancellation'])
+
+ def test_cancel_render_on_lambda(self):
+ client = RemotionClient(
+ region="us-east-1", serve_url="testbed", function_name="remotion-render"
+ )
+ s3_client = Mock()
+ s3_client.get_object.return_value = {
+ 'Body': Mock(read=Mock(return_value=b'{"cancellationEnabled": true}'))
+ }
+ client._create_s3_client = Mock(return_value=s3_client)
+
+ client.cancel_render_on_lambda('render-id', 'remotionlambda-test')
+
+ s3_client.get_object.assert_called_once_with(
+ Bucket='remotionlambda-test', Key='renders/render-id/progress.json'
+ )
+ put_input = s3_client.put_object.call_args.kwargs
+ self.assertEqual(put_input['Key'], 'renders/render-id/cancel.json')
+ self.assertGreater(json.loads(put_input['Body'])['cancelledAt'], 0)
+
+ def test_cancel_render_requires_opt_in(self):
+ client = RemotionClient(
+ region="us-east-1", serve_url="testbed", function_name="remotion-render"
+ )
+ s3_client = Mock()
+ s3_client.get_object.return_value = {'Body': Mock(read=Mock(return_value=b'{}'))}
+ client._create_s3_client = Mock(return_value=s3_client)
+
+ with self.assertRaisesRegex(
+ RemotionInvalidArgumentException, 'enableCancellation: true'
+ ):
+ client.cancel_render_on_lambda('render-id', 'remotionlambda-test')
+
+ s3_client.put_object.assert_not_called()
@patch('remotion_lambda.models.VERSION', '5.0.0')
def test_overwrite_defaults_to_true_in_v5(self):
diff --git a/packages/lambda-ruby/Gemfile b/packages/lambda-ruby/Gemfile
index 1be56368af..a84f40d77b 100644
--- a/packages/lambda-ruby/Gemfile
+++ b/packages/lambda-ruby/Gemfile
@@ -1,5 +1,7 @@
source 'https://rubygems.org'
gem 'aws-sdk-lambda', '1.143.0'
+gem 'aws-sdk-s3', '1.183.0'
gem 'json', '2.8.2'
gem 'logger', '1.6.1'
+gem 'rexml', '3.4.4'
diff --git a/packages/lambda-ruby/Gemfile.lock b/packages/lambda-ruby/Gemfile.lock
index 40a99c38e3..5fce4c7059 100644
--- a/packages/lambda-ruby/Gemfile.lock
+++ b/packages/lambda-ruby/Gemfile.lock
@@ -3,27 +3,42 @@ GEM
specs:
aws-eventstream (1.3.0)
aws-partitions (1.1012.0)
- aws-sdk-core (3.213.0)
+ aws-sdk-core (3.254.1)
aws-eventstream (~> 1, >= 1.3.0)
aws-partitions (~> 1, >= 1.992.0)
aws-sigv4 (~> 1.9)
+ base64
+ bigdecimal
jmespath (~> 1, >= 1.6.1)
+ logger
+ aws-sdk-kms (1.130.0)
+ aws-sdk-core (~> 3, >= 3.254.0)
+ aws-sigv4 (~> 1.5)
aws-sdk-lambda (1.143.0)
aws-sdk-core (~> 3, >= 3.210.0)
aws-sigv4 (~> 1.5)
+ aws-sdk-s3 (1.183.0)
+ aws-sdk-core (~> 3, >= 3.216.0)
+ aws-sdk-kms (~> 1)
+ aws-sigv4 (~> 1.5)
aws-sigv4 (1.10.1)
aws-eventstream (~> 1, >= 1.0.2)
+ base64 (0.3.0)
+ bigdecimal (4.1.2)
jmespath (1.6.2)
json (2.8.2)
logger (1.6.1)
+ rexml (3.4.4)
PLATFORMS
ruby
DEPENDENCIES
aws-sdk-lambda (= 1.143.0)
+ aws-sdk-s3 (= 1.183.0)
json (= 2.8.2)
logger (= 1.6.1)
+ rexml (= 3.4.4)
BUNDLED WITH
2.6.9
diff --git a/packages/lambda-ruby/lib/remotion_lambda/cancel_render_on_lambda_spec.rb b/packages/lambda-ruby/lib/remotion_lambda/cancel_render_on_lambda_spec.rb
new file mode 100644
index 0000000000..332edb64ec
--- /dev/null
+++ b/packages/lambda-ruby/lib/remotion_lambda/cancel_render_on_lambda_spec.rb
@@ -0,0 +1,26 @@
+require_relative 'sdk'
+require 'aws-sdk-s3'
+require 'json'
+
+s3_client = Aws::S3::Client.new(stub_responses: true)
+s3_client.stub_responses(:get_object, body: JSON.generate(cancellationEnabled: true))
+client = RemotionLambda::Client.new(s3_client: s3_client)
+
+client.cancel_render_on_lambda('remotionlambda-test', 'render-id')
+
+requests = s3_client.api_requests
+raise 'Expected progress to be read' unless requests[0][:params][:key] == 'renders/render-id/progress.json'
+raise 'Expected cancellation signal to be written' unless requests[1][:params][:key] == 'renders/render-id/cancel.json'
+cancellation_body = JSON.parse(requests[1][:params][:body])
+raise 'Expected cancelledAt timestamp' unless cancellation_body['cancelledAt'] > 0
+
+disabled_s3_client = Aws::S3::Client.new(stub_responses: true)
+disabled_s3_client.stub_responses(:get_object, body: '{}')
+disabled_client = RemotionLambda::Client.new(s3_client: disabled_s3_client)
+
+begin
+ disabled_client.cancel_render_on_lambda('remotionlambda-test', 'render-id')
+ raise 'Expected cancellation to fail without opt-in'
+rescue => error
+ raise error unless error.message.include?('enableCancellation: true')
+end
diff --git a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rb b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rb
index 70b243681e..24ef0cf8b6 100644
--- a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rb
+++ b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rb
@@ -19,6 +19,7 @@ def get_render_media_on_lambda_payload(
crf: nil,
delete_after: nil,
download_behavior: nil,
+ enable_cancellation: false,
encoding_buffer_size: nil,
encoding_max_rate: nil,
env_variables: {},
@@ -79,6 +80,7 @@ payload = {
crf: crf,
deleteAfter: delete_after,
downloadBehavior: download_behavior,
+ enableCancellation: enable_cancellation,
encodingBufferSize: encoding_buffer_size,
encodingMaxRate: encoding_max_rate,
envVariables: env_variables,
diff --git a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rb b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rb
index 27e2a4044f..258a7e5910 100644
--- a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rb
+++ b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rb
@@ -30,6 +30,10 @@ payload = get_render_media_on_lambda_payload(
)
raise "Expected the current SDK to default overwrite to false" unless payload[:overwrite] == false
+raise "Expected cancellation to default to false" unless payload[:enableCancellation] == false
+
+cancellable_payload = get_render_media_on_lambda_payload(codec: "h264", enable_cancellation: true)
+raise "Expected cancellation to be enabled" unless cancellable_payload[:enableCancellation] == true
# Print as JSON
puts JSON.generate(payload)
diff --git a/packages/lambda-ruby/lib/remotion_lambda/sdk.rb b/packages/lambda-ruby/lib/remotion_lambda/sdk.rb
index d7f2ad6486..ee35317035 100644
--- a/packages/lambda-ruby/lib/remotion_lambda/sdk.rb
+++ b/packages/lambda-ruby/lib/remotion_lambda/sdk.rb
@@ -1,4 +1,5 @@
require 'aws-sdk-lambda'
+require 'aws-sdk-s3'
require 'json'
require 'logger'
require_relative 'version'
@@ -9,11 +10,13 @@ module RemotionLambda
def initialize(
region: ENV.fetch('AWS_REGION', 'us-east-1'),
- aws_profile: nil
+ aws_profile: nil,
+ s3_client: nil
)
@region = region
@aws_profile = aws_profile
@lambda_client = create_lambda_client
+ @s3_client = s3_client
end
def get_render_progress(function_name, payload)
@@ -34,6 +37,26 @@ module RemotionLambda
body
end
+ def cancel_render_on_lambda(bucket_name, render_id)
+ progress_response = s3_client.get_object(
+ bucket: bucket_name,
+ key: "renders/#{render_id}/progress.json"
+ )
+ progress = JSON.parse(progress_response.body.read)
+
+ unless progress['cancellationEnabled'] == true
+ raise "Cannot cancel render #{render_id}: The render was not started with enableCancellation: true."
+ end
+
+ s3_client.put_object(
+ bucket: bucket_name,
+ key: "renders/#{render_id}/cancel.json",
+ body: JSON.generate(cancelledAt: (Time.now.to_f * 1000).floor),
+ content_type: 'application/json'
+ )
+ nil
+ end
+
private
# Lambda methods
@@ -50,6 +73,10 @@ module RemotionLambda
Aws::Lambda::Client.new(region: @region, credentials: aws_credentials)
end
+ def s3_client
+ @s3_client ||= Aws::S3::Client.new(region: @region, credentials: aws_credentials)
+ end
+
def aws_credentials
if @aws_profile
Aws::SharedCredentials.new(profile_name: @aws_profile)
diff --git a/packages/lambda-ruby/remotion_lambda.gemspec b/packages/lambda-ruby/remotion_lambda.gemspec
index 46b65e5d0e..181121132d 100644
--- a/packages/lambda-ruby/remotion_lambda.gemspec
+++ b/packages/lambda-ruby/remotion_lambda.gemspec
@@ -11,8 +11,12 @@ Gem::Specification.new do |s|
s.license = "MIT"
s.add_runtime_dependency "aws-sdk-lambda",
["> 1.0.0"]
+ s.add_runtime_dependency "aws-sdk-s3",
+ ["> 1.0.0"]
s.add_runtime_dependency "json",
["> 2.0.0"]
s.add_runtime_dependency "logger",
["> 1.0.0"]
+ s.add_runtime_dependency "rexml",
+ ["> 3.0.0"]
end
diff --git a/packages/lambda/src/cli/commands/render/render.ts b/packages/lambda/src/cli/commands/render/render.ts
index 160f25eea6..15dfb52775 100644
--- a/packages/lambda/src/cli/commands/render/render.ts
+++ b/packages/lambda/src/cli/commands/render/render.ts
@@ -78,6 +78,7 @@ const {
overrideFpsOption,
overrideDurationOption,
sampleRateOption,
+ enableCancellationOption,
} = BrowserSafeApis.options;
export const renderCommand = async ({
@@ -124,6 +125,9 @@ export const renderCommand = async ({
}
const singleFrameRange = frameRange as SingleFrameRange | null;
+ const enableCancellation = enableCancellationOption.getValue({
+ commandLine: CliInternals.parsedCli,
+ }).value;
const height = overrideHeightOption.getValue({
commandLine: CliInternals.parsedCli,
@@ -382,6 +386,7 @@ export const renderCommand = async ({
const webhookCustomData = getWebhookCustomData(logLevel);
const res = await LambdaClientInternals.internalRenderMediaOnLambdaRaw({
+ enableCancellation,
functionName,
serveUrl,
inputProps,
@@ -449,6 +454,45 @@ export const renderCommand = async ({
sampleRate,
});
+ const unregisterCtrlCHandler = CliInternals.registerCtrlCHandler(async () => {
+ if (!enableCancellation) {
+ Log.info(
+ {indent: false, logLevel},
+ 'Stopped waiting. The Lambda render is still running.',
+ );
+ Log.info(
+ {indent: false, logLevel},
+ 'Use --enable-cancellation to allow Ctrl+C to cancel it.',
+ );
+ return 130;
+ }
+
+ Log.info({indent: false, logLevel}, 'Cancelling Lambda render...');
+ try {
+ await LambdaClientInternals.internalCancelRenderOnLambda({
+ bucketName: res.bucketName,
+ region,
+ renderId: res.renderId,
+ forcePathStyle: parsedLambdaCli['force-path-style'] ?? false,
+ requestHandler: null,
+ providerSpecifics,
+ });
+ } catch (err) {
+ Log.error(
+ {indent: false, logLevel},
+ `Could not cancel the Lambda render: ${err instanceof Error ? err.message : String(err)}`,
+ );
+ Log.info(
+ {indent: false, logLevel},
+ 'The Lambda render may still be running.',
+ );
+ return 1;
+ }
+
+ Log.info({indent: false, logLevel}, 'Cancellation signal sent.');
+ return 130;
+ });
+
const progressBar = CliInternals.createOverwriteableCliOutput({
quiet: CliInternals.quietFlagProvided(),
cancelSignal: null,
@@ -464,6 +508,12 @@ export const renderCommand = async ({
`Bucket: ${CliInternals.makeHyperlink({text: res.bucketName, fallback: res.bucketName, url: LambdaClientInternals.getS3BucketUrl({region: getAwsRegion(), bucketName: res.bucketName})})}`,
),
);
+ if (enableCancellation) {
+ Log.info(
+ {indent: false, logLevel},
+ CliInternals.chalk.gray('Press Ctrl+C to cancel the render.'),
+ );
+ }
Log.info(
{indent: false, logLevel},
CliInternals.chalk.gray(
@@ -577,6 +627,7 @@ export const renderCommand = async ({
);
if (newStatus.done) {
+ unregisterCtrlCHandler();
let downloadOrNothing;
if (downloadName) {
@@ -688,6 +739,7 @@ export const renderCommand = async ({
}
if (newStatus.fatalErrorEncountered) {
+ unregisterCtrlCHandler();
Log.error({indent: false, logLevel}, '\n');
const uniqueErrors: EnhancedErrorInfo[] = [];
for (const err of newStatus.errors) {
diff --git a/packages/lambda/src/test/integration/cli-render-cancellation.test.ts b/packages/lambda/src/test/integration/cli-render-cancellation.test.ts
new file mode 100644
index 0000000000..22dfa765b6
--- /dev/null
+++ b/packages/lambda/src/test/integration/cli-render-cancellation.test.ts
@@ -0,0 +1,177 @@
+import {afterEach, beforeEach, expect, test} from 'bun:test';
+import {Readable} from 'node:stream';
+// eslint-disable-next-line no-restricted-imports
+import {CliInternals} from '@remotion/cli';
+import {LambdaClientInternals} from '@remotion/lambda-client';
+import {parsedLambdaCli} from '../../cli/args';
+import {renderCommand} from '../../cli/commands/render/render';
+import {mockImplementation} from '../mocks/mock-implementation';
+import {doAfter, doBefore, getProcessWriteOutput} from './console-hooks';
+
+const enableCancellationOption = CliInternals.parsedCli['enable-cancellation'];
+const originalCallFunctionSync =
+ LambdaClientInternals.awsImplementation.callFunctionSync;
+const originalFunctionName = parsedLambdaCli['function-name'];
+const originalRegion = parsedLambdaCli.region;
+
+beforeEach(() => {
+ doBefore();
+ CliInternals.parsedCli['enable-cancellation'] = true;
+ parsedLambdaCli['function-name'] = 'custom-function';
+ parsedLambdaCli.region = 'us-east-1';
+});
+
+afterEach(() => {
+ LambdaClientInternals.awsImplementation.callFunctionSync =
+ originalCallFunctionSync;
+ CliInternals.parsedCli['enable-cancellation'] = enableCancellationOption;
+ parsedLambdaCli['function-name'] = originalFunctionName;
+ parsedLambdaCli.region = originalRegion;
+ doAfter();
+});
+
+test('Ctrl+C cancels an opted-in Lambda CLI render', async () => {
+ let resolveStatusRequested: () => void = () => undefined;
+ const statusRequested = new Promise<void>((resolve) => {
+ resolveStatusRequested = resolve;
+ });
+ const pendingStatus = new Promise<never>(() => undefined);
+ const enableCancellationInPayloads: boolean[] = [];
+
+ LambdaClientInternals.awsImplementation.callFunctionSync = ((input) => {
+ if (input.type === 'start') {
+ enableCancellationInPayloads.push(
+ (input.payload as {enableCancellation: boolean}).enableCancellation,
+ );
+ return Promise.resolve({bucketName: 'bucket', renderId: 'render-id'});
+ }
+
+ if (input.type === 'status') {
+ resolveStatusRequested();
+ return pendingStatus;
+ }
+
+ return Promise.reject(
+ new Error(`Unexpected Lambda routine: ${input.type}`),
+ );
+ }) as typeof originalCallFunctionSync;
+
+ let cancellationWrites = 0;
+ const providerSpecifics = {
+ ...mockImplementation,
+ readFile: ({key}: {key: string}) => {
+ expect(key).toBe('renders/render-id/progress.json');
+ return Promise.resolve(
+ Readable.from([
+ Buffer.from(JSON.stringify({cancellationEnabled: true})),
+ ]),
+ );
+ },
+ writeFile: (input: {key: string}) => {
+ expect(input.key).toBe('renders/render-id/cancel.json');
+ cancellationWrites++;
+ return Promise.resolve();
+ },
+ } as typeof mockImplementation;
+
+ let resolveExit: (exitCode: number) => void = () => undefined;
+ const exitCode = new Promise<number>((resolve) => {
+ resolveExit = resolve;
+ });
+ const unregisterCtrlC = CliInternals.handleCtrlC({
+ indent: false,
+ logLevel: 'info',
+ exit: resolveExit,
+ });
+
+ renderCommand({
+ args: ['https://example.com', 'composition-id'],
+ remotionRoot: process.cwd(),
+ logLevel: 'info',
+ providerSpecifics,
+ }).catch(() => undefined);
+
+ try {
+ await statusRequested;
+ process.emit('SIGINT', 'SIGINT');
+
+ expect(await exitCode).toBe(130);
+ expect(enableCancellationInPayloads).toEqual([true]);
+ expect(cancellationWrites).toBe(1);
+ expect(getProcessWriteOutput()).toContain('Cancelling Lambda render...');
+ expect(getProcessWriteOutput()).toContain('Cancellation signal sent.');
+ } finally {
+ unregisterCtrlC();
+ }
+});
+
+test('Ctrl+C leaves a Lambda CLI render running without the flag', async () => {
+ CliInternals.parsedCli['enable-cancellation'] = false;
+ let resolveStatusRequested: () => void = () => undefined;
+ const statusRequested = new Promise<void>((resolve) => {
+ resolveStatusRequested = resolve;
+ });
+ const pendingStatus = new Promise<never>(() => undefined);
+ const enableCancellationInPayloads: boolean[] = [];
+
+ LambdaClientInternals.awsImplementation.callFunctionSync = ((input) => {
+ if (input.type === 'start') {
+ enableCancellationInPayloads.push(
+ (input.payload as {enableCancellation: boolean}).enableCancellation,
+ );
+ return Promise.resolve({bucketName: 'bucket', renderId: 'render-id'});
+ }
+
+ if (input.type === 'status') {
+ resolveStatusRequested();
+ return pendingStatus;
+ }
+
+ return Promise.reject(
+ new Error(`Unexpected Lambda routine: ${input.type}`),
+ );
+ }) as typeof originalCallFunctionSync;
+
+ let cancellationWrites = 0;
+ const providerSpecifics = {
+ ...mockImplementation,
+ writeFile: () => {
+ cancellationWrites++;
+ return Promise.resolve();
+ },
+ } as typeof mockImplementation;
+
+ let resolveExit: (exitCode: number) => void = () => undefined;
+ const exitCode = new Promise<number>((resolve) => {
+ resolveExit = resolve;
+ });
+ const unregisterCtrlC = CliInternals.handleCtrlC({
+ indent: false,
+ logLevel: 'info',
+ exit: resolveExit,
+ });
+
+ renderCommand({
+ args: ['https://example.com', 'composition-id'],
+ remotionRoot: process.cwd(),
+ logLevel: 'info',
+ providerSpecifics,
+ }).catch(() => undefined);
+
+ try {
+ await statusRequested;
+ process.emit('SIGINT', 'SIGINT');
+
+ expect(await exitCode).toBe(130);
+ expect(enableCancellationInPayloads).toEqual([false]);
+ expect(cancellationWrites).toBe(0);
+ expect(getProcessWriteOutput()).toContain(
+ 'Stopped waiting. The Lambda render is still running.',
+ );
+ expect(getProcessWriteOutput()).toContain(
+ 'Use --enable-cancellation to allow Ctrl+C to cancel it.',
+ );
+ } finally {
+ unregisterCtrlC();
+ }
+});
diff --git a/packages/lambda/src/test/integration/renders/old-version.test.ts b/packages/lambda/src/test/integration/renders/old-version.test.ts
index e675f72799..6d57a51ce5 100644
--- a/packages/lambda/src/test/integration/renders/old-version.test.ts
+++ b/packages/lambda/src/test/integration/renders/old-version.test.ts
@@ -10,6 +10,7 @@ test(
const aha = await mockImplementation.callFunctionSync({
type: ServerlessRoutines.launch,
payload: {
+ enableCancellation: false,
type: ServerlessRoutines.launch,
serveUrl: path.join(__dirname, 'old-version-bundle'),
chromiumOptions: {},
diff --git a/packages/lambda/src/test/integration/webhooks.test.ts b/packages/lambda/src/test/integration/webhooks.test.ts
index 3522ea6b27..5341fe9420 100644
--- a/packages/lambda/src/test/integration/webhooks.test.ts
+++ b/packages/lambda/src/test/integration/webhooks.test.ts
@@ -37,6 +37,7 @@ test(
const res = await mockImplementation.callFunctionSync({
type: ServerlessRoutines.start,
payload: {
+ enableCancellation: false,
type: ServerlessRoutines.start,
serveUrl: `http://localhost:${port}`,
chromiumOptions: {},
@@ -165,6 +166,7 @@ test(
region: 'us-east-1',
type: ServerlessRoutines.launch,
payload: {
+ enableCancellation: false,
type: ServerlessRoutines.launch,
mediaCacheSizeInBytes: null,
offthreadVideoCacheSizeInBytes: null,
diff --git a/packages/lambda/src/test/unit/x264-preset-default.test.ts b/packages/lambda/src/test/unit/x264-preset-default.test.ts
index dfeb2251be..776c8368e1 100644
--- a/packages/lambda/src/test/unit/x264-preset-default.test.ts
+++ b/packages/lambda/src/test/unit/x264-preset-default.test.ts
@@ -65,6 +65,7 @@ const makeStartPayload = ({
colorSpace: null,
preferLossless: false,
forcePathStyle: false,
+ enableCancellation: null,
metadata: null,
licenseKey: null,
storageClass: null,
diff --git a/packages/renderer/src/options/enable-cancellation.tsx b/packages/renderer/src/options/enable-cancellation.tsx
new file mode 100644
index 0000000000..b06ec2bd72
--- /dev/null
+++ b/packages/renderer/src/options/enable-cancellation.tsx
@@ -0,0 +1,38 @@
+import type {AnyRemotionOption} from './option';
+
+const cliFlag = 'enable-cancellation' as const;
+
+let enableCancellation = false;
+
+export const enableCancellationOption = {
+ name: 'Enable cancellation',
+ cliFlag,
+ description: () => (
+ <>
+ Allows a Lambda render to be cancelled by pressing Ctrl+C while running{' '}
+ <code>npx remotion lambda render</code>. Enabling cancellation causes each
+ renderer function to poll S3 once per second while it is running.
+ </>
+ ),
+ ssrName: null,
+ docLink:
+ 'https://www.remotion.dev/docs/lambda/cli/render#--enable-cancellation',
+ type: false as boolean,
+ setConfig: (value: boolean) => {
+ enableCancellation = value;
+ },
+ getValue: ({commandLine}) => {
+ if (typeof commandLine[cliFlag] === 'boolean') {
+ return {
+ value: commandLine[cliFlag],
+ source: 'cli',
+ };
+ }
+
+ return {
+ value: enableCancellation,
+ source: enableCancellation ? 'config' : 'default',
+ };
+ },
+ id: cliFlag,
+} satisfies AnyRemotionOption<boolean>;
diff --git a/packages/renderer/src/options/index.tsx b/packages/renderer/src/options/index.tsx
index cff91ca488..e4c9a38328 100644
--- a/packages/renderer/src/options/index.tsx
+++ b/packages/renderer/src/options/index.tsx
@@ -22,6 +22,7 @@ import {deleteAfterOption} from './delete-after';
import {disableGitSourceOption} from './disable-git-source';
import {disableWebSecurityOption} from './disable-web-security';
import {disallowParallelEncodingOption} from './disallow-parallel-encoding';
+import {enableCancellationOption} from './enable-cancellation';
import {enableLambdaInsights} from './enable-lambda-insights';
import {enableMultiprocessOnLinuxOption} from './enable-multiprocess-on-linux';
import {encodingBufferSizeOption} from './encoding-buffer-size';
@@ -118,6 +119,7 @@ export const allOptions = {
disableWebSecurityOption,
disallowParallelEncodingOption,
folderExpiryOption,
+ enableCancellationOption,
enableMultiprocessOnLinuxOption,
glOption,
gopSizeOption,
diff --git a/packages/renderer/src/test/boolean-option-precedence.test.ts b/packages/renderer/src/test/boolean-option-precedence.test.ts
index 82784fa1e6..63f60fddcf 100644
--- a/packages/renderer/src/test/boolean-option-precedence.test.ts
+++ b/packages/renderer/src/test/boolean-option-precedence.test.ts
@@ -2,6 +2,7 @@ import {expect, test} from 'bun:test';
import {beepOnFinishOption} from '../options/beep-on-finish';
import {disableWebSecurityOption} from '../options/disable-web-security';
import {disallowParallelEncodingOption} from '../options/disallow-parallel-encoding';
+import {enableCancellationOption} from '../options/enable-cancellation';
import {forceNewStudioOption} from '../options/force-new-studio';
import {headlessOption} from '../options/headless';
import {ignoreCertificateErrorsOption} from '../options/ignore-certificate-errors';
@@ -109,6 +110,19 @@ test('boolean options respect config if CLI flag is absent', () => {
).toEqual(false);
disallowParallelEncodingOption.setConfig(false);
+ enableCancellationOption.setConfig(true);
+ expect(
+ enableCancellationOption.getValue({
+ commandLine: {'enable-cancellation': null},
+ }).value,
+ ).toEqual(true);
+ expect(
+ enableCancellationOption.getValue({
+ commandLine: {'enable-cancellation': false},
+ }).value,
+ ).toEqual(false);
+ enableCancellationOption.setConfig(false);
+
reproOption.setConfig(true);
expect(reproOption.getValue({commandLine: {repro: null}}).value).toEqual(
true,
diff --git a/packages/serverless-client/src/constants.ts b/packages/serverless-client/src/constants.ts
index 9a050f98d5..97fee29cff 100644
--- a/packages/serverless-client/src/constants.ts
+++ b/packages/serverless-client/src/constants.ts
@@ -111,6 +111,7 @@ export type ServerlessStatusPayload<Provider extends CloudProvider> = {
};
export type ServerlessStartPayload<Provider extends CloudProvider> = {
+ enableCancellation: boolean | null;
rendererFunctionName: string | null;
type: ServerlessRoutines.start;
serveUrl: string;
@@ -174,6 +175,7 @@ export type ServerlessPayloads<Provider extends CloudProvider> = {
};
start: ServerlessStartPayload<Provider>;
launch: {
+ enableCancellation: boolean | null;
rendererFunctionName: string | null;
type: ServerlessRoutines.launch;
serveUrl: string;
@@ -232,6 +234,7 @@ export type ServerlessPayloads<Provider extends CloudProvider> = {
};
status: ServerlessStatusPayload<Provider>;
renderer: {
+ enableCancellation: boolean | null;
concurrencyPerLambda: number;
type: ServerlessRoutines.renderer;
serveUrl: string;
@@ -382,6 +385,9 @@ export const customOutName = <Provider extends CloudProvider>(
export const overallProgressKey = (renderId: string) =>
`${rendersPrefix(renderId)}/progress.json`;
+export const cancellationKey = (renderId: string) =>
+ `${rendersPrefix(renderId)}/cancel.json`;
+
export const artifactName = (renderId: string, name: string) =>
`${rendersPrefix(renderId)}/artifacts/${name}`;
diff --git a/packages/serverless-client/src/index.ts b/packages/serverless-client/src/index.ts
index 9d0c590003..f66046a2cf 100644
--- a/packages/serverless-client/src/index.ts
+++ b/packages/serverless-client/src/index.ts
@@ -2,6 +2,7 @@ import {interpolate, NoReactInternals, random} from 'remotion/no-react';
export * from './constants';
export {
artifactName,
+ cancellationKey,
customOutName,
expiryDays,
MINIMUM_FRAMES_PER_FUNCTION,
@@ -133,6 +134,7 @@ export {validateBucketName} from './validate-bucket-name';
export {validateOutname} from './validate-outname';
export {validatePrivacy} from './validate-privacy';
export {validateWebhook} from './validate-webhook';
+export {writeCancellationSignal} from './write-cancellation-signal';
export * from './webhook-types';
export {EnhancedErrorInfo, FunctionErrorInfo} from './write-error-to-storage';
export {interpolate, random};
diff --git a/packages/serverless-client/src/overall-render-progress.ts b/packages/serverless-client/src/overall-render-progress.ts
index c09ff41b29..642f08dcb5 100644
--- a/packages/serverless-client/src/overall-render-progress.ts
+++ b/packages/serverless-client/src/overall-render-progress.ts
@@ -9,6 +9,10 @@ import type {
import type {FunctionErrorInfo} from './write-error-to-storage';
export type OverallRenderProgress<Provider extends CloudProvider> = {
+ /**
+ * Whether renderers poll for a cancellation signal.
+ */
+ cancellationEnabled: boolean | null;
chunks: number[];
framesRendered: number;
framesEncoded: number;
diff --git a/packages/serverless-client/src/test/progress.test.ts b/packages/serverless-client/src/test/progress.test.ts
index 643df5380d..e8c06da885 100644
--- a/packages/serverless-client/src/test/progress.test.ts
+++ b/packages/serverless-client/src/test/progress.test.ts
@@ -66,6 +66,7 @@ const renderMetadata: RenderMetadata<MockProvider> = {
};
const progress: OverallRenderProgress<MockProvider> = {
+ cancellationEnabled: false,
chunks: [0, 1],
combinedFrames: 20,
compositionValidated: startedDate + 2,
diff --git a/packages/serverless-client/src/write-cancellation-signal.ts b/packages/serverless-client/src/write-cancellation-signal.ts
new file mode 100644
index 0000000000..2c121106b4
--- /dev/null
+++ b/packages/serverless-client/src/write-cancellation-signal.ts
@@ -0,0 +1,35 @@
+import {cancellationKey} from './constants';
+import type {ProviderSpecifics} from './provider-implementation';
+import type {CloudProvider} from './types';
+
+export const writeCancellationSignal = async <Provider extends CloudProvider>({
+ bucketName,
+ renderId,
+ region,
+ expectedBucketOwner,
+ providerSpecifics,
+ forcePathStyle,
+ requestHandler,
+}: {
+ bucketName: string;
+ renderId: string;
+ region: Provider['region'];
+ expectedBucketOwner: string;
+ providerSpecifics: ProviderSpecifics<Provider>;
+ forcePathStyle: boolean;
+ requestHandler: Provider['requestHandler'] | null;
+}) => {
+ await providerSpecifics.writeFile({
+ bucketName,
+ key: cancellationKey(renderId),
+ body: JSON.stringify({cancelledAt: Date.now()}),
+ region,
+ privacy: 'private',
+ expectedBucketOwner,
+ downloadBehavior: null,
+ customCredentials: null,
+ forcePathStyle,
+ storageClass: null,
+ requestHandler,
+ });
+};
diff --git a/packages/serverless/src/cancellation-polling.ts b/packages/serverless/src/cancellation-polling.ts
new file mode 100644
index 0000000000..1fcf81a4ee
--- /dev/null
+++ b/packages/serverless/src/cancellation-polling.ts
@@ -0,0 +1,88 @@
+import {RenderInternals, type LogLevel} from '@remotion/renderer';
+import type {
+ CloudProvider,
+ ProviderSpecifics,
+} from '@remotion/serverless-client';
+import {cancellationKey} from '@remotion/serverless-client';
+
+const isMissingCancellationSignalError = (err: unknown) => {
+ const error = err as {name?: string; Code?: string; code?: string};
+ return (
+ error.name === 'NoSuchKey' ||
+ error.name === 'NotFound' ||
+ error.Code === 'NoSuchKey' ||
+ error.code === 'NoSuchKey'
+ );
+};
+
+export const startCancellationPolling = <Provider extends CloudProvider>({
+ bucketName,
+ renderId,
+ region,
+ providerSpecifics,
+ forcePathStyle,
+ intervalInMilliseconds,
+ logLevel,
+ onCancelled,
+}: {
+ bucketName: string;
+ renderId: string;
+ region: Provider['region'];
+ providerSpecifics: ProviderSpecifics<Provider>;
+ forcePathStyle: boolean;
+ intervalInMilliseconds: number;
+ logLevel: LogLevel;
+ onCancelled: () => void;
+}) => {
+ let stopped = false;
+ let timeout: ReturnType<typeof setTimeout> | null = null;
+
+ const poll = async () => {
+ try {
+ await providerSpecifics.headFile({
+ bucketName,
+ key: cancellationKey(renderId),
+ region,
+ customCredentials: null,
+ forcePathStyle,
+ requestHandler: null,
+ });
+
+ if (!stopped) {
+ stopped = true;
+ RenderInternals.Log.info(
+ {indent: false, logLevel},
+ 'Render cancellation signal received.',
+ );
+ onCancelled();
+ }
+ } catch (err) {
+ if (!isMissingCancellationSignalError(err)) {
+ RenderInternals.Log.warn(
+ {indent: false, logLevel},
+ 'Could not check for a render cancellation signal. Retrying.',
+ err,
+ );
+ }
+ }
+
+ if (!stopped) {
+ timeout = setTimeout(poll, intervalInMilliseconds);
+ }
+ };
+
+ poll().catch((err) => {
+ RenderInternals.Log.warn(
+ {indent: false, logLevel},
+ 'Cancellation polling stopped unexpectedly.',
+ err,
+ );
+ });
+
+ return () => {
+ stopped = true;
+ if (timeout !== null) {
+ clearTimeout(timeout);
+ }
+ };
+};
diff --git a/packages/serverless/src/handlers/launch.ts b/packages/serverless/src/handlers/launch.ts
index 0aa5ffc86e..16df9fec90 100644
--- a/packages/serverless/src/handlers/launch.ts
+++ b/packages/serverless/src/handlers/launch.ts
@@ -27,6 +27,7 @@ import {
validateFramesPerFunction,
validateOutname,
validatePrivacy,
+ writeCancellationSignal,
} from '@remotion/serverless-client';
import {cleanupProps} from '../cleanup-props';
import {findOutputFileInBucket} from '../find-output-file-in-bucket';
@@ -264,6 +265,7 @@ const innerLaunchHandler = async <Provider extends CloudProvider>({
const lambdaPayloads = chunks.map((chunkPayload) => {
const payload: ServerlessPayload<Provider> = {
+ enableCancellation: params.enableCancellation ?? false,
type: ServerlessRoutines.renderer,
frameRange: chunkPayload,
serveUrl: params.serveUrl,
@@ -633,6 +635,30 @@ export const launchHandler = async <Provider extends CloudProvider>({
return prom;
};
+ const cancelOtherRenderers = async () => {
+ if (!params.enableCancellation) {
+ return;
+ }
+
+ try {
+ await writeCancellationSignal({
+ bucketName: params.bucketName,
+ renderId: params.renderId,
+ region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+ expectedBucketOwner: options.expectedBucketOwner,
+ providerSpecifics,
+ forcePathStyle: params.forcePathStyle,
+ requestHandler: null,
+ });
+ } catch (err) {
+ RenderInternals.Log.warn(
+ {indent: false, logLevel: params.logLevel},
+ 'Could not signal other renderers to stop.',
+ err,
+ );
+ }
+ };
+
const onTimeout = async () => {
RenderInternals.Log.error(
{indent: false, logLevel: params.logLevel},
@@ -648,6 +674,7 @@ export const launchHandler = async <Provider extends CloudProvider>({
}
runCleanupTasks();
+ await cancelOtherRenderers();
if (!params.webhook) {
RenderInternals.Log.verbose(
@@ -741,6 +768,7 @@ export const launchHandler = async <Provider extends CloudProvider>({
);
const overallProgress = makeOverallRenderProgress({
+ cancellationEnabled: params.enableCancellation ?? false,
renderId: params.renderId,
bucketName: params.bucketName,
expectedBucketOwner: options.expectedBucketOwner,
@@ -833,6 +861,8 @@ export const launchHandler = async <Provider extends CloudProvider>({
throw err;
}
+ await cancelOtherRenderers();
+
RenderInternals.Log.error(
{indent: false, logLevel: params.logLevel},
'Error occurred',
diff --git a/packages/serverless/src/handlers/renderer.ts b/packages/serverless/src/handlers/renderer.ts
index 49acca32d0..00e801e83c 100644
--- a/packages/serverless/src/handlers/renderer.ts
+++ b/packages/serverless/src/handlers/renderer.ts
@@ -3,10 +3,11 @@ import path from 'node:path';
import type {
AudioCodec,
BrowserLog,
+ CancelSignal,
Codec,
OnArtifact,
} from '@remotion/renderer';
-import {RenderInternals} from '@remotion/renderer';
+import {makeCancelSignal, RenderInternals} from '@remotion/renderer';
import {NoReactAPIs} from '@remotion/renderer/pure';
import type {
CloudProvider,
@@ -23,6 +24,7 @@ import {
truthy,
VERSION,
} 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';
@@ -50,6 +52,7 @@ const renderHandler = async <Provider extends CloudProvider>({
insideFunctionSpecifics,
onBrowserInstance,
onMediaFiles,
+ cancelSignal,
}: {
params: ServerlessPayload<Provider>;
options: Options;
@@ -66,6 +69,7 @@ const renderHandler = async <Provider extends CloudProvider>({
completedAt: number;
}) => Promise<void>)
| null;
+ cancelSignal: CancelSignal | null;
}): Promise<{}> => {
if (params.type !== ServerlessRoutines.renderer) {
throw new Error('Params must be renderer');
@@ -341,7 +345,7 @@ const renderHandler = async <Provider extends CloudProvider>({
audioCodec,
preferLossless: params.preferLossless,
browserExecutable: providerSpecifics.getChromiumPath(),
- cancelSignal: undefined,
+ cancelSignal: cancelSignal ?? undefined,
disallowParallelEncoding: false,
ffmpegOverride: ({args}) => args,
indent: false,
@@ -491,6 +495,23 @@ export const rendererHandler = async <Provider extends CloudProvider>({
const leakDetection = enableNodeIntrospection(ENABLE_SLOW_LEAK_DETECTION);
let shouldKeepBrowserOpen = true;
let instance: LaunchedBrowser | undefined;
+ let cancellationRequested = false;
+ const {cancel, cancelSignal} = makeCancelSignal();
+ const stopCancellationPolling = params.enableCancellation
+ ? startCancellationPolling({
+ bucketName: params.bucketName,
+ renderId: params.renderId,
+ region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+ providerSpecifics,
+ forcePathStyle: params.forcePathStyle,
+ intervalInMilliseconds: 1000,
+ logLevel: params.logLevel,
+ onCancelled: () => {
+ cancellationRequested = true;
+ cancel();
+ },
+ })
+ : () => undefined;
try {
await renderHandler({
@@ -504,6 +525,7 @@ export const rendererHandler = async <Provider extends CloudProvider>({
instance = browserInstance;
},
onMediaFiles,
+ cancelSignal: params.enableCancellation ? cancelSignal : null,
});
} catch (err) {
if (process.env.NODE_ENV === 'test') {
@@ -519,7 +541,8 @@ export const rendererHandler = async <Provider extends CloudProvider>({
shouldKeepBrowserOpen = false;
}
- const shouldNotRetry = (err as Error).name === 'CancelledError';
+ const shouldNotRetry =
+ cancellationRequested || (err as Error).name === 'CancelledError';
const shouldRetry =
isRetryableError && params.retriesLeft > 0 && !shouldNotRetry;
@@ -557,6 +580,7 @@ export const rendererHandler = async <Provider extends CloudProvider>({
},
});
} finally {
+ stopCancellationPolling();
if (shouldKeepBrowserOpen && instance) {
insideFunctionSpecifics.forgetBrowserEventLoop({
logLevel: params.logLevel,
diff --git a/packages/serverless/src/handlers/start.ts b/packages/serverless/src/handlers/start.ts
index d638d6790c..3ac7e3b3e0 100644
--- a/packages/serverless/src/handlers/start.ts
+++ b/packages/serverless/src/handlers/start.ts
@@ -69,6 +69,7 @@ export const startHandler = async <Provider extends CloudProvider>({
body: JSON.stringify(
makeInitialOverallRenderProgress(
options.timeoutInMilliseconds + Date.now(),
+ params.enableCancellation ?? false,
),
),
expectedBucketOwner: options.expectedBucketOwner,
@@ -81,6 +82,7 @@ export const startHandler = async <Provider extends CloudProvider>({
});
const payload: ServerlessPayload<Provider> = {
+ enableCancellation: params.enableCancellation ?? false,
type: ServerlessRoutines.launch,
framesPerFunction: params.framesPerLambda,
concurrency: params.concurrency,
diff --git a/packages/serverless/src/handlers/still.ts b/packages/serverless/src/handlers/still.ts
index a25381d11f..1467dac26b 100644
--- a/packages/serverless/src/handlers/still.ts
+++ b/packages/serverless/src/handlers/still.ts
@@ -218,7 +218,7 @@ const innerStillHandler = async <Provider extends CloudProvider>(
scale: params.scale,
};
- const still = makeInitialOverallRenderProgress(timeoutInMilliseconds);
+ const still = makeInitialOverallRenderProgress(timeoutInMilliseconds, false);
still.renderMetadata = renderMetadata;
await providerSpecifics.writeFile({
diff --git a/packages/serverless/src/overall-render-progress.ts b/packages/serverless/src/overall-render-progress.ts
index 3d331c4293..4e591c032e 100644
--- a/packages/serverless/src/overall-render-progress.ts
+++ b/packages/serverless/src/overall-render-progress.ts
@@ -56,8 +56,10 @@ export const makeInitialOverallRenderProgress = <
Provider extends CloudProvider,
>(
timeoutTimestamp: number,
+ cancellationEnabled: boolean,
): OverallRenderProgress<Provider> => {
return {
+ cancellationEnabled,
chunks: [],
framesRendered: 0,
framesEncoded: 0,
@@ -89,6 +91,7 @@ export const makeOverallRenderProgress = <Provider extends CloudProvider>({
logLevel,
providerSpecifics,
forcePathStyle,
+ cancellationEnabled,
}: {
renderId: string;
bucketName: string;
@@ -98,13 +101,14 @@ export const makeOverallRenderProgress = <Provider extends CloudProvider>({
logLevel: LogLevel;
providerSpecifics: ProviderSpecifics<Provider>;
forcePathStyle: boolean;
+ cancellationEnabled: boolean;
}): OverallProgressHelper<Provider> => {
let framesRendered: number[] = [];
let framesEncoded: number[] = [];
let lambdasInvoked: boolean[] = [];
const renderProgress: OverallRenderProgress<Provider> =
- makeInitialOverallRenderProgress(timeoutTimestamp);
+ makeInitialOverallRenderProgress(timeoutTimestamp, cancellationEnabled);
let dirty = false;
let dirtyReasons: string[] = [];
diff --git a/packages/serverless/src/test/cancellation-polling.test.ts b/packages/serverless/src/test/cancellation-polling.test.ts
new file mode 100644
index 0000000000..59d80f695e
--- /dev/null
+++ b/packages/serverless/src/test/cancellation-polling.test.ts
@@ -0,0 +1,48 @@
+import {expect, test} from 'bun:test';
+import type {
+ CloudProvider,
+ ProviderSpecifics,
+} from '@remotion/serverless-client';
+import {cancellationKey} from '@remotion/serverless-client';
+import {startCancellationPolling} from '../cancellation-polling';
+
+type MockProvider = CloudProvider<
+ 'eu-central-1',
+ {s3Key: string; s3Url: string},
+ {},
+ 'standard',
+ {}
+>;
+
+test('polls until the cancellation signal exists', async () => {
+ let checks = 0;
+ let stop: () => void = () => undefined;
+ const cancelled = new Promise<void>((resolve) => {
+ stop = startCancellationPolling({
+ bucketName: 'bucket',
+ renderId: 'render-id',
+ region: 'eu-central-1',
+ providerSpecifics: {
+ headFile: (({key}) => {
+ expect(key).toBe(cancellationKey('render-id'));
+ checks++;
+ if (checks === 1) {
+ const error = new Error('Missing');
+ error.name = 'NotFound';
+ return Promise.reject(error);
+ }
+
+ return Promise.resolve({});
+ }) as ProviderSpecifics<MockProvider>['headFile'],
+ } as unknown as ProviderSpecifics<MockProvider>,
+ forcePathStyle: false,
+ intervalInMilliseconds: 1,
+ logLevel: 'error',
+ onCancelled: resolve,
+ });
+ });
+
+ await cancelled;
+ stop();
+ expect(checks).toBe(2);
+});
diff --git a/packages/serverless/src/test/overall-render-progress.test.ts b/packages/serverless/src/test/overall-render-progress.test.ts
index bf07e403c6..5db6424958 100644
--- a/packages/serverless/src/test/overall-render-progress.test.ts
+++ b/packages/serverless/src/test/overall-render-progress.test.ts
@@ -4,7 +4,10 @@ import type {
PostRenderData,
ProviderSpecifics,
} from '@remotion/serverless-client';
-import {makeOverallRenderProgress} from '../overall-render-progress';
+import {
+ makeInitialOverallRenderProgress,
+ makeOverallRenderProgress,
+} from '../overall-render-progress';
type MockProvider = CloudProvider<
'eu-central-1',
@@ -85,6 +88,11 @@ const postRenderData: PostRenderData<MockProvider> = {
timeToRenderFrames: 1,
};
+test('stores whether cancellation is enabled', () => {
+ const progress = makeInitialOverallRenderProgress<MockProvider>(1, true);
+ expect(progress.cancellationEnabled).toBe(true);
+});
+
test('setPostRenderData retries transient progress upload failures', async () => {
let attempts = 0;
let persistedBody: string | null = null;
@@ -100,6 +108,7 @@ test('setPostRenderData retries transient progress upload failures', async () =>
},
});
const overallProgress = makeOverallRenderProgress({
+ cancellationEnabled: false,
bucketName: 'bucket',
expectedBucketOwner: '123456789012',
forcePathStyle: false,
diff --git a/packages/studio-shared/src/config-method-lifecycles.ts b/packages/studio-shared/src/config-method-lifecycles.ts
index d26c77eef6..40f74173c6 100644
--- a/packages/studio-shared/src/config-method-lifecycles.ts
+++ b/packages/studio-shared/src/config-method-lifecycles.ts
@@ -40,6 +40,7 @@ export const configMethodLifecycles = {
setDeleteAfter: 'runtime',
setDisallowParallelEncoding: 'runtime',
setDotEnvLocation: 'restart',
+ setEnableCancellation: 'runtime',
setEnableCrossSiteIsolation: 'restart',
setEnableFolderExpiry: 'runtime',
setEncodingBufferSize: 'runtime',