Containers

import { DurableObject } from "cloudflare:workers";
import { rewriteRequestForContainer, startAndWaitForPort } from "./utils";

export class MyContainer extends DurableObject {
	async fetch(request) {
		const container = this.ctx.container;
		await startAndWaitForPort(container, {
			port: 4000,
			inactivityTimeout: 10 * 60 * 1000,
		});

		const forwarded = rewriteRequestForContainer(request);
		const response = await container.getTcpPort(4000).fetch(forwarded);
		return response;
	}
}

export default {
	async fetch(request, env) {
		const containerRequest = request.clone();
		const { "session-id": sessionId } = await request.json();
		return env.MY_CONTAINER.getByName(sessionId).fetch(containerRequest);
	},
};

import { DurableObject } from "cloudflare:workers";
import { rewriteRequestForContainer, startAndWaitForPort } from "./utils";

interface Env {
	MY_CONTAINER: DurableObjectNamespace<MyContainer>;
}

export class MyContainer extends DurableObject<Env> {
	async fetch(request: Request): Promise<Response> {
		const container = this.ctx.container!;
		await startAndWaitForPort(container, {
			port: 4000,
			inactivityTimeout: 10 * 60 * 1000,
		});

		const forwarded = rewriteRequestForContainer(request);
		const response = await container.getTcpPort(4000).fetch(forwarded);
		return response;
	}
}

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const containerRequest = request.clone();
		const { "session-id": sessionId } = await request.json<{
			"session-id": string;
		}>();
		return env.MY_CONTAINER.getByName(sessionId).fetch(containerRequest);
	},
};

export function rewriteRequestForContainer(request) {
	const url = new URL(request.url);
	url.protocol = "http:";
	url.host = "container";
	const forwarded = new Request(url, request);
	forwarded.headers.delete("host");
	return forwarded;
}

export async function startAndWaitForPort(container, options) {
	await container.setInactivityTimeout(options.inactivityTimeout);
	if (!container.running) {
		container.start();
	}

	// start() returns before the container is ready, so poll its health endpoint.
	const port = container.getTcpPort(options.port);
	let lastError;
	for (let attempt = 0; attempt < 100; attempt++) {
		try {
			const response = await port.fetch("http://container/health");
			if (!response.ok) {
				throw new Error(`Health check returned ${response.status}`);
			}
			return;
		} catch (error) {
			lastError = error;
			await scheduler.wait(200);
		}
	}
	throw new Error(`Container did not become ready on port ${options.port}`, {
		cause: lastError,
	});
}

interface ReadinessOptions {
	port: number;
	inactivityTimeout: number;
}

type ContainerInstance = NonNullable<DurableObjectState["container"]>;

export function rewriteRequestForContainer(request: Request): Request {
	const url = new URL(request.url);
	url.protocol = "http:";
	url.host = "container";
	const forwarded = new Request(url, request);
	forwarded.headers.delete("host");
	return forwarded;
}

export async function startAndWaitForPort(
	container: ContainerInstance,
	options: ReadinessOptions,
): Promise<void> {
	await container.setInactivityTimeout(options.inactivityTimeout);
	if (!container.running) {
		container.start();
	}

	// start() returns before the container is ready, so poll its health endpoint.
	const port = container.getTcpPort(options.port);
	let lastError: unknown;
	for (let attempt = 0; attempt < 100; attempt++) {
		try {
			const response = await port.fetch("http://container/health");
			if (!response.ok) {
				throw new Error(`Health check returned ${response.status}`);
			}
			return;
		} catch (error) {
			lastError = error;
			await scheduler.wait(200);
		}
	}
	throw new Error(`Container did not become ready on port ${options.port}`, {
		cause: lastError,
	});
}