chore: add examples for reusing workers

Author: nyannyacha

examples/main-session/index.ts

@@ -0,0 +1,145 @@
+// @ts-ignore
+import { STATUS_CODE } from 'https://deno.land/std/http/status.ts';
+
+interface Worker {
+new(key: string, rid: string): Worker;
+
+fetch(request: Request, options?: any): Promise<Response>;
+dispose(): void;
+
+get active(): boolean;
+}
+
+const SESSION_HEADER_NAME = 'X-Edge-Runtime-Session-Id';
+const WORKERS = new Map<string, Worker>();
+
+setInterval(() => {
+const shouldBeRemoved: string[] = [];
+
+for (const [uuid, worker] of WORKERS) {
+if (!worker.active) {
+shouldBeRemoved.push(uuid);
+}
+}
+
+for (const uuid of shouldBeRemoved) {
+console.log("deleted: ", uuid);
+WORKERS.delete(uuid);
+}
+}, 2500);
+
+console.log('main function started (session mode)');
+
+Deno.serve(async (req: Request) => {
+const headers = new Headers({
+'Content-Type': 'application/json',
+});
+
+const url = new URL(req.url);
+const { pathname } = url;
+
+// handle health checks
+if (pathname === '/_internal/health') {
+return new Response(
+JSON.stringify({ 'message': 'ok' }),
+{
+status: STATUS_CODE.OK,
+headers,
+},
+);
+}
+
+if (pathname === '/_internal/metric') {
+const metric = await EdgeRuntime.getRuntimeMetrics();
+return Response.json(metric);
+}
+
+const path_parts = pathname.split('/');
+const service_name = path_parts[1];
+
+if (!service_name || service_name === '') {
+const error = { msg: 'missing function name in request' };
+return new Response(
+JSON.stringify(error),
+{ status: STATUS_CODE.BadRequest, headers: { 'Content-Type': 'application/json' } },
+);
+}
+
+const servicePath = `./examples/${service_name}`;
+const createWorker = async (): Promise<Worker> => {
+const memoryLimitMb = 150;
+const workerTimeoutMs = 30 * 1000;
+const noModuleCache = false;
+
+const importMapPath = null;
+const envVarsObj = Deno.env.toObject();
+const envVars = Object.keys(envVarsObj).map((k) => [k, envVarsObj[k]]);
+const forceCreate = false;
+const netAccessDisabled = false;
+const cpuTimeSoftLimitMs = 10000;
+const cpuTimeHardLimitMs = 20000;
+
+return await EdgeRuntime.userWorkers.create({
+servicePath,
+memoryLimitMb,
+workerTimeoutMs,
+noModuleCache,
+importMapPath,
+envVars,
+forceCreate,
+netAccessDisabled,
+cpuTimeSoftLimitMs,
+cpuTimeHardLimitMs,
+});
+};
+
+const callWorker = async () => {
+
+try {
+let worker: Worker | null = null;
+
+if (req.headers.get(SESSION_HEADER_NAME)) {
+const sessionId = req.headers.get(SESSION_HEADER_NAME)!;
+const complexSessionId = `${servicePath}/${sessionId}`;
+
+let maybeWorker = WORKERS.get(complexSessionId);
+
+if (maybeWorker && maybeWorker.active) {
+worker = maybeWorker;
+}
+}
+
+if (!worker) {
+worker = await createWorker();
+}
+
+let resp = await worker.fetch(req);
+
+if (resp.headers.has(SESSION_HEADER_NAME)) {
+const sessionIdFromWorker = resp.headers.get(SESSION_HEADER_NAME)!;
+const complexSessionId = `${servicePath}/${sessionIdFromWorker}`;
+
+WORKERS.set(complexSessionId, worker);
+}
+
+return resp;
+} catch (e) {
+console.error(e);
+
+if (e instanceof Deno.errors.WorkerRequestCancelled) {
+headers.append('Connection', 'close');
+}
+
+const error = { msg: e.toString() };
+return new Response(
+JSON.stringify(error),
+{
+status: STATUS_CODE.InternalServerError,
+headers,
+},
+);
+}
+};
+
+return callWorker();
+});

examples/serve-session/index.ts

@@ -0,0 +1,59 @@
+// @ts-ignore
+import { STATUS_CODE } from "https://deno.land/std/http/status.ts";
+
+const SESSION_HEADER_NAME = "X-Edge-Runtime-Session-Id";
+const SESSIONS = new Map<string, object>();
+
+function makeNewSession(): [string, object] {
+ const uuid = crypto.randomUUID();
+ const storage = {};
+
+ SESSIONS.set(uuid, storage);
+ return [uuid, storage];
+}
+
+function getSessionStorageFromRequest(req: Request): object | void {
+ let maybeSessionId = req.headers.get(SESSION_HEADER_NAME);
+
+ if (typeof maybeSessionId === "string" && SESSIONS.has(maybeSessionId)) {
+ return SESSIONS.get(maybeSessionId);
+ }
+}
+
+Deno.serve((req: Request) => {
+ const headers = new Headers();
+ let storage: object;
+
+ if (req.headers.get(SESSION_HEADER_NAME)) {
+ const maybeStorage = getSessionStorageFromRequest(req);
+
+ if (!maybeStorage) {
+ return new Response(null, {
+ status: STATUS_CODE.BadRequest
+ });
+ }
+
+ storage = maybeStorage;
+ } else {
+ const [sessionId, newStorage] = makeNewSession();
+
+ headers.set(SESSION_HEADER_NAME, sessionId);
+
+ storage = newStorage;
+ }
+
+ if (!("count" in storage)) {
+ storage["count"] = 0;
+ } else {
+ (storage["count"] as number)++;
+ }
+
+ const count = storage["count"] as number;
+
+ return new Response(
+ JSON.stringify({ count }),
+ {
+ headers
+ }
+ );
+});