@rivetkit/engine-runner 25.7.1-rc.1

package/benches/actor-lifecycle.bench.ts

@@ -0,0 +1,190 @@
+// import { Bench } from "tinybench";
+// import { Runner } from "@/mod";
+// import type { ActorConfig } from "@/mod";
+// import {
+// 	createActor,
+// 	destroyActor,
+// 	setupBenchmarkRunner,
+// 	createPromiseResolver,
+// 	RIVET_ENDPOINT,
+// } from "./utils.js";
+// import { afterEach } from "node:test";
+//
+// async function runActorLifecycleBenchmark() {
+// 	// Shared state for benchmarks
+// 	let runner: Runner | null = null;
+// 	let namespaceName: string;
+// 	let runnerName: string;
+// 	let createdActors: string[] = [];
+// 	let wakeActorId: string | null = null;
+// 	let stopped: { promise: Promise<void>; resolve: () => void };
+// 	let started: { promise: Promise<void>; resolve: () => void };
+//
+// 	const bench = new Bench({
+// 		time: 1000,
+// 		iterations: 10,
+// 		warmupTime: 0,
+// 		warmupIterations: 0,
+// 		throws: true,
+// 		setup: async (task) => {
+// 			// Setup benchmark runner
+// 			console.log("Setting up benchmark runner...");
+// 			stopped = createPromiseResolver<void>();
+// 			started = createPromiseResolver<void>();
+//
+// 			const setup = await setupBenchmarkRunner(
+// 				"lifecycle",
+// 				5054,
+// 				async (
+// 					_actorId: string,
+// 					_generation: number,
+// 					_config: ActorConfig,
+// 				) => {
+// 					started.resolve();
+// 				},
+// 				async (_actorId: string, _generation: number) => {
+// 					stopped.resolve();
+// 				},
+// 			);
+// 			runner = setup.runner;
+// 			namespaceName = setup.namespaceName;
+// 			runnerName = setup.runnerName;
+//
+// 			console.log(
+// 				`Benchmark setup complete. Namespace: ${namespaceName}, Runner: ${runnerName}`,
+// 			);
+// 		},
+// 		teardown: async () => {
+// 			if (runner) {
+// 				await runner.shutdown(true);
+// 			}
+//
+// 			// Clean up created actors from creation benchmark
+// 			console.log(
+// 				`Cleaning up ${createdActors.length} actors in ${namespaceName}...`,
+// 			);
+// 			const cleanupActor = createdActors;
+// 			createdActors = [];
+// 			wakeActorId = null;
+// 			for (const actorId of cleanupActor) {
+// 				try {
+// 					await destroyActor(namespaceName, actorId);
+// 				} catch (err) {
+// 					console.warn(`Failed to clean up actor ${actorId}:`, err);
+// 				}
+// 			}
+//
+// 			console.log("Benchmark teardown complete!");
+// 		},
+// 	});
+//
+// 	bench.add("create actor", async () => {
+// 		const actorResponse = await createActor(
+// 			namespaceName,
+// 			runnerName,
+// 			false,
+// 		);
+// 		const actorId = actorResponse.actor.actor_id;
+// 		createdActors.push(actorId);
+//
+// 		// Ping the actor
+// 		const pingResponse = await fetch(`${RIVET_ENDPOINT}/ping`, {
+// 			method: "GET",
+// 			headers: {
+// 				"x-rivet-target": "actor",
+// 				"x-rivet-actor": actorId,
+// 			},
+// 		});
+// 		if (!pingResponse.ok) throw "Request failed";
+// 	});
+//
+// 	//bench.add(
+// 	//	"wake actor from sleep",
+// 	//	async () => {
+// 	//		if (!wakeActorId) throw "No wake actor ID";
+// 	//
+// 	//		// Ping the actor
+// 	//		const pingResponse = await fetch(`${RIVET_ENDPOINT}/ping`, {
+// 	//			method: "GET",
+// 	//			headers: {
+// 	//				"x-rivet-target": "actor",
+// 	//				"x-rivet-actor": wakeActorId,
+// 	//			},
+// 	//		});
+// 	//
+// 	//		if (!pingResponse.ok) {
+// 	//			console.error(
+// 	//				`Ping failed: ${pingResponse.status} ${pingResponse.statusText}`,
+// 	//			);
+// 	//			const errorText = await pingResponse.text();
+// 	//			console.error(`Error response: ${errorText}`);
+// 	//			throw `Request failed: ${pingResponse.status} ${pingResponse.statusText}`;
+// 	//		}
+// 	//	},
+// 	//	{
+// 	//		beforeEach: async () => {
+// 	//			// Reset promise resolvers for this iteration
+// 	//			started = createPromiseResolver<void>();
+// 	//			stopped = createPromiseResolver<void>();
+// 	//
+// 	//			// Create the actor that will be used for wake benchmarking
+// 	//			console.log('Creating actor');
+// 	//			const wakeActorResponse = await createActor(
+// 	//				namespaceName,
+// 	//				runnerName,
+// 	//				false,
+// 	//				"wake-bench-actor",
+// 	//			);
+// 	//			wakeActorId = wakeActorResponse.actor.actor_id;
+// 	//			createdActors.push(wakeActorId!);
+// 	//
+// 	//			// Wait for actor to start
+// 	//			await started.promise;
+// 	//
+// 	//			// Put actor to sleep initially
+// 	//			runner!.sleepActor(wakeActorId!);
+// 	//			await stopped.promise;
+// 	//		},
+// 	//	},
+// 	//	// TODO(RVT-4979): Add back after sleep cycles fixed
+// 	//	//{
+// 	//	//	beforeAll: async () => {
+// 	//	//		// Create the actor that will be used for wake benchmarking
+// 	//	//		console.log("Creating wake actor...");
+// 	//	//		const wakeActorResponse = await createActor(
+// 	//	//			namespaceName,
+// 	//	//			runnerName,
+// 	//	//			false,
+// 	//	//			"wake-bench-actor",
+// 	//	//		);
+// 	//	//		wakeActorId = wakeActorResponse.actor.actor_id;
+// 	//	//		createdActors.push(wakeActorId!);
+// 	//	//
+// 	//	//		// Wait for actor to start
+// 	//	//		await started.promise;
+// 	//	//	},
+// 	//	//	beforeEach: async () => {
+// 	//	//		console.log("Putting actor to sleep...");
+// 	//	//
+// 	//	//		// Put actor to sleep initially
+// 	//	//		stopped = createPromiseResolver<void>();
+// 	//	//		runner!.sleepActor(wakeActorId!);
+// 	//	//		await stopped.promise;
+// 	//	//	},
+// 	//	//},
+// 	//);
+//
+// 	// Run the benchmark
+// 	console.log("Running benchmarks...");
+// 	await bench.run();
+//
+// 	// Display results
+// 	console.table(bench.table());
+//
+// 	console.log("Benchmark complete!");
+// }
+//
+// // Run the benchmark if this file is executed directly
+// if (import.meta.url === `file://${process.argv[1]}`) {
+// 	runActorLifecycleBenchmark();
+// }

package/benches/utils.ts

@@ -0,0 +1,143 @@
+// import { Runner } from "@/mod";
+// import type { RunnerConfig, ActorConfig } from "@/mod";
+//
+// export const RIVET_ENDPOINT =
+// 	process.env.RIVET_ENDPOINT ?? "http://localhost:6420";
+//
+// export async function createActor(
+// 	namespaceName: string,
+// 	runnerNameSelector: string,
+// 	durable: boolean,
+// 	actorName: string = "bench-actor",
+// ): Promise<any> {
+// 	const response = await fetch(
+// 		`${RIVET_ENDPOINT}/actors?namespace=${namespaceName}`,
+// 		{
+// 			method: "POST",
+// 			headers: {
+// 				"Content-Type": "application/json",
+// 			},
+// 			body: JSON.stringify({
+// 				name: actorName,
+// 				input: btoa("bench-input"),
+// 				runner_name_selector: runnerNameSelector,
+// 				durable,
+// 			}),
+// 		},
+// 	);
+//
+// 	if (!response.ok) {
+// 		throw new Error(
+// 			`Failed to create actor: ${response.status} ${response.statusText}\n${await response.text()}`,
+// 		);
+// 	}
+//
+// 	return response.json();
+// }
+//
+// export async function destroyActor(
+// 	namespaceName: string,
+// 	actorId: string,
+// ): Promise<void> {
+// 	const response = await fetch(
+// 		`${RIVET_ENDPOINT}/actors/${actorId}?namespace=${namespaceName}`,
+// 		{
+// 			method: "DELETE",
+// 		},
+// 	);
+//
+// 	if (!response.ok) {
+// 		throw new Error(
+// 			`Failed to delete actor: ${response.status} ${response.statusText}\n${await response.text()}`,
+// 		);
+// 	}
+// }
+//
+// export async function createNamespace(
+// 	name: string,
+// 	displayName: string,
+// ): Promise<any> {
+// 	const response = await fetch(`${RIVET_ENDPOINT}/namespaces`, {
+// 		method: "POST",
+// 		headers: {
+// 			"Content-Type": "application/json",
+// 		},
+// 		body: JSON.stringify({
+// 			name,
+// 			display_name: displayName,
+// 		}),
+// 	});
+//
+// 	if (!response.ok) {
+// 		console.warn(
+// 			`Failed to create namespace: ${response.status} ${response.statusText}\n${await response.text()}`,
+// 		);
+// 	}
+// }
+//
+// export interface BenchmarkRunnerSetup {
+// 	runner: Runner;
+// 	namespaceName: string;
+// 	runnerName: string;
+// }
+//
+// export async function setupBenchmarkRunner(
+// 	namespaceSuffix: string,
+// 	port: number,
+// 	onActorStart?: (
+// 		actorId: string,
+// 		generation: number,
+// 		config: ActorConfig,
+// 	) => Promise<void>,
+// 	onActorStop?: (actorId: string, generation: number) => Promise<void>,
+// ): Promise<BenchmarkRunnerSetup> {
+// 	const namespaceName = `bench-${crypto.randomUUID().slice(0, 8)}`;
+// 	const runnerName = `bench-runner`;
+//
+// 	let runnerStartedResolver: () => void;
+// 	const runnerStarted = new Promise<void>((resolve) => {
+// 		runnerStartedResolver = resolve;
+// 	});
+//
+// 	const config: RunnerConfig = {
+// 		version: 1,
+// 		endpoint: RIVET_ENDPOINT,
+// 		namespace: namespaceName,
+// 		addresses: { main: { host: "127.0.0.1", port } },
+// 		totalSlots: 100,
+// 		prepopulateActorNames: [],
+// 		runnerName: runnerName,
+// 		runnerKey: "default",
+// 		onConnected: () => {
+// 			runnerStartedResolver();
+// 		},
+// 		onDisconnected: () => {},
+// 		fetch: async (_actorId: string, request: Request) => {
+// 			return new Response("ok", { status: 200 });
+// 		},
+// 		onActorStart: onActorStart || (async () => {}),
+// 		onActorStop: onActorStop || (async () => {}),
+// 	};
+//
+// 	await createNamespace(namespaceName, `Bench ${namespaceSuffix} Namespace`);
+// 	const runner = new Runner(config);
+// 	runner.start();
+// 	await runnerStarted;
+//
+// 	return { runner, namespaceName, runnerName };
+// }
+//
+// export function createPromiseResolver<T = void>(): {
+// 	promise: Promise<T>;
+// 	resolve: (value: T) => void;
+// 	reject: (error: any) => void;
+// } {
+// 	let resolve: (value: T) => void;
+// 	let reject: (error: any) => void;
+// 	const promise = new Promise<T>((res, rej) => {
+// 		resolve = res;
+// 		reject = rej;
+// 	});
+// 	return { promise, resolve: resolve!, reject: reject! };
+// }
+//