Skip to content

🎥 Make videos programmatically with React

10.2 KB
Raw Blame
import type {IncomingMessage} from 'node:http';
import http from 'node:http';
import type {
	BundlerOverrideFn,
	RspackOverrideFn,
	WebpackOverrideFn,
} from '@remotion/bundler';
import {
	BundlerInternals,
	WatchIgnoreNextChangePlugin,
	webpack,
} from '@remotion/bundler';
import type {
	DefaultCodingAgent,
	DefaultEditor,
	LogLevel,
} from '@remotion/renderer';
import {RenderInternals} from '@remotion/renderer';
import type {
	GitSource,
	RenderDefaults,
	RenderJob,
	StudioRuntimeConfig,
} from '@remotion/studio-shared';
import {detectRemotionServer} from '../detect-remotion-server';
import {handleRoutes} from '../routes';
import type {QueueMethods} from './api-types';
import {wdm} from './dev-middleware';
import {setupWebpackHmr} from './hot-middleware';
import type {LiveEventsServer} from './live-events';
import {makeLiveEventsRouter} from './live-events';
import {clearNodePathCache} from './node-path-cache';
import {getRedoStack, getUndoStack} from './undo-stack';
import {setWatchIgnoreNextChangePlugin} from './watch-ignore-next-change';

export type StartServerResult =
	| {
			type: 'started';
			port: number;
			liveEventsServer: LiveEventsServer;
			close: () => Promise<void>;
	  }
	| {
			type: 'already-running';
			port: number;
	  };

export const startServer = async (options: {
	entry: string;
	userDefinedComponent: string;
	bundlerOverride: BundlerOverrideFn;
	rspackOverride: RspackOverrideFn;
	webpackOverride: WebpackOverrideFn;
	getCurrentInputProps: () => object;
	getEnvVariables: () => Record<string, string>;
	port: number | null;
	remotionRoot: string;
	publicDir: string;
	poll: number | null;
	staticHash: string;
	staticHashPrefix: string;
	outputHash: string;
	outputHashPrefix: string;
	logLevel: LogLevel;
	getRenderQueue: () => RenderJob[];
	getRenderDefaults: () => RenderDefaults;
	getNumberOfAudioTags: () => number;
	queueMethods: QueueMethods;
	gitSource: GitSource | null;
	binariesDirectory: string | null;
	forceIPv4: boolean;
	getAudioLatencyHint: () => AudioContextLatencyCategory | null;
	getExperimentalKeepAudioContextAlive: () => boolean;
	getPreviewSampleRate: () => number | null;
	enableCrossSiteIsolation: boolean;
	forceNew: boolean;
	rspack: boolean;
	getStudioRuntimeConfig: () => StudioRuntimeConfig;
	getDefaultCodingAgent: () => DefaultCodingAgent | null;
	getDefaultEditor: () => DefaultEditor | null;
	configFile: string | null;
}): Promise<StartServerResult> => {
	const desiredPort =
		options?.port ??
		(process.env.PORT ? Number(process.env.PORT) : undefined) ??
		undefined;

	const portConfig = RenderInternals.getPortConfig(options.forceIPv4);

	const onPortUnavailable = async (
		port: number,
	): Promise<'continue' | 'stop'> => {
		if (!options.forceNew) {
			const detection = await detectRemotionServer({
				port,
				cwd: options.remotionRoot,
				hostname: portConfig.hostsToTry[0],
			});
			if (detection.type === 'match') {
				return 'stop';
			}
		}

		RenderInternals.Log.info(
			{indent: false, logLevel: options.logLevel},
			RenderInternals.chalk.gray(`Port ${port} is busy, trying another.`),
		);
		return 'continue';
	};

	let portSelection = await RenderInternals.getDesiredPort({
		desiredPort,
		from: 3000,
		to: 3100,
		hostsToTry: portConfig.hostsToTry,
		onPortUnavailable,
	});

	if (portSelection.didUsePort) {
		portSelection.unlockPort();
		return {
			type: 'already-running' as const,
			port: portSelection.port,
		};
	}

	const handleRequestBeforeReady: http.RequestListener = (
		_request,
		response,
	) => {
		response.writeHead(503);
		response.end('Studio is starting...');
	};

	const server = http.createServer(handleRequestBeforeReady);
	const maxTries = 5;
	let selectedPort: number | null = null;

	for (let i = 0; i < maxTries; i++) {
		try {
			const {port, unlockPort} = portSelection;

			selectedPort = await new Promise<number>((resolve, reject) => {
				RenderInternals.Log.verbose(
					{indent: false, logLevel: options.logLevel},
					`Binding server to host ${portConfig.host}, port ${port}`,
				);
				const onListening = () => {
					server.off('error', onError);
					unlockPort();
					resolve(port);
				};

				const onError = (error: Error) => {
					server.off('listening', onListening);
					reject(error);
				};

				server.once('listening', onListening);
				server.once('error', onError);
				server.listen({
					port,
					host: portConfig.host,
				});
			});
			break;
		} catch (err) {
			if (!(err instanceof Error)) {
				portSelection.unlockPort();
				throw err;
			}

			const codedError = err as Error & {code: string; port: number};

			if (codedError.code === 'EADDRINUSE') {
				portSelection.unlockPort();
				RenderInternals.Log.error(
					{indent: false, logLevel: options.logLevel},
					`Port ${codedError.port} is already in use. Trying another port...`,
				);
				if (i === maxTries - 1) {
					break;
				}

				portSelection = await RenderInternals.getDesiredPort({
					desiredPort,
					from: 3000,
					to: 3100,
					hostsToTry: portConfig.hostsToTry,
					onPortUnavailable,
				});

				if (portSelection.didUsePort) {
					portSelection.unlockPort();
					return {
						type: 'already-running' as const,
						port: portSelection.port,
					};
				}
			} else {
				portSelection.unlockPort();
				throw err;
			}
		}
	}

	if (selectedPort === null) {
		throw new Error(`Tried ${maxTries} times to find a free port. Giving up.`);
	}

	let compiler: webpack.Compiler | null = null;
	try {
		const watchIgnorePlugin = new WatchIgnoreNextChangePlugin((...args) => {
			RenderInternals.Log.trace(
				{indent: false, logLevel: options.logLevel},
				...args,
			);
		});

		const configArgs = {
			entry: options.entry,
			userDefinedComponent: options.userDefinedComponent,
			outDir: null,
			environment: 'development' as const,
			bundlerOverride: options.bundlerOverride,
			rspackOverride: options.rspackOverride,
			webpackOverride: options?.webpackOverride,
			remotionRoot: options.remotionRoot,
			poll: options.poll,
			extraPlugins: [watchIgnorePlugin],
		};

		if (options.rspack) {
			const [, rspackConf] = await BundlerInternals.rspackConfig(configArgs);
			compiler = BundlerInternals.createRspackCompiler(
				rspackConf,
			) as unknown as webpack.Compiler;
		} else {
			const [, webpackConf] = await BundlerInternals.webpackConfig(configArgs);
			compiler = webpack(webpackConf);
		}

		setWatchIgnoreNextChangePlugin(watchIgnorePlugin);

		const wdmMiddleware = wdm(compiler, options.logLevel);
		const invalidateBundle = () => {
			return new Promise<void>((resolve, reject) => {
				const watching = compiler?.watching;
				if (!watching) {
					reject(new Error('The Studio bundle is not being watched.'));
					return;
				}

				watching.invalidate((error) => {
					if (error) {
						reject(error);
						return;
					}

					resolve();
				});
			});
		};

		const liveEventsServer = makeLiveEventsRouter(options.logLevel, () => {
			const undoStack = getUndoStack();
			const redoStack = getRedoStack();
			return {
				undoFile:
					undoStack.length > 0
						? undoStack[undoStack.length - 1].filePath
						: null,
				redoFile:
					redoStack.length > 0
						? redoStack[redoStack.length - 1].filePath
						: null,
			};
		});
		setupWebpackHmr(compiler, options.logLevel, liveEventsServer);
		compiler.hooks.done.tap('remotion-node-path-cache', () => {
			clearNodePathCache();
		});

		server.off('request', handleRequestBeforeReady);
		server.on('request', (request, response) => {
			if (options.enableCrossSiteIsolation) {
				response.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
				response.setHeader('Cross-Origin-Embedder-Policy', 'credentialless');
			}

			new Promise<void>((resolve) => {
				wdmMiddleware(request as IncomingMessage, response, () => {
					resolve();
				});
			})
				.then(() => {
					return handleRoutes({
						staticHash: options.staticHash,
						staticHashPrefix: options.staticHashPrefix,
						outputHash: options.outputHash,
						outputHashPrefix: options.outputHashPrefix,
						request: request as IncomingMessage,
						response,
						liveEventsServer,
						getCurrentInputProps: options.getCurrentInputProps,
						getEnvVariables: options.getEnvVariables,
						remotionRoot: options.remotionRoot,
						entryPoint: options.userDefinedComponent,
						publicDir: options.publicDir,
						logLevel: options.logLevel,
						getRenderQueue: options.getRenderQueue,
						getRenderDefaults: options.getRenderDefaults,
						getNumberOfAudioTags: options.getNumberOfAudioTags,
						queueMethods: options.queueMethods,
						gitSource: options.gitSource,
						binariesDirectory: options.binariesDirectory,
						getAudioLatencyHint: options.getAudioLatencyHint,
						getExperimentalKeepAudioContextAlive:
							options.getExperimentalKeepAudioContextAlive,
						getPreviewSampleRate: options.getPreviewSampleRate,
						enableCrossSiteIsolation: options.enableCrossSiteIsolation,
						getStudioRuntimeConfig: options.getStudioRuntimeConfig,
						getDefaultCodingAgent: options.getDefaultCodingAgent,
						getDefaultEditor: options.getDefaultEditor,
						configFile: options.configFile,
						invalidateBundle,
					});
				})
				.catch((err) => {
					RenderInternals.Log.error(
						{indent: false, logLevel: options.logLevel},
						`Error while calling ${request.url}`,
						err,
					);
					if (!response.headersSent) {
						response.setHeader('content-type', 'application/json');
						response.writeHead(500);
					}

					if (!response.writableEnded) {
						response.end(
							JSON.stringify({
								err: (err as Error).message,
							}),
						);
					}
				});
		});

		const initializedCompiler = compiler;
		return {
			type: 'started' as const,
			port: selectedPort,
			liveEventsServer,
			close: async () => {
				server.closeAllConnections();
				await Promise.all([
					new Promise<void>((resolve) => {
						server.close(() => {
							resolve();
						});
					}),
					new Promise<void>((resolve) => {
						initializedCompiler.close(() => {
							resolve();
						});
					}),
				]);
			},
		};
	} catch (error) {
		server.closeAllConnections();
		await Promise.all([
			new Promise<void>((resolve) => {
				server.close(() => resolve());
			}),
			compiler
				? new Promise<void>((resolve) => {
						compiler?.close(() => resolve());
					})
				: Promise.resolve(),
		]);
		throw error;
	}
};