@gmickel/gno 1.16.0 → 1.18.0

package/src/serve/public/pages/Dashboard.tsx

@@ -513,6 +513,7 @@ export default function Dashboard({ navigate }: PageProps) {
               busyAction={busyAction}
               health={status.health}
               onAction={handleHealthAction}
+              resident={status.resident}
             />
           </div>
         )}

package/src/serve/resident-admission.ts

@@ -0,0 +1,159 @@
+/** Resident request admission and bounded reader concurrency primitives. */
+
+import type { ResidentRequestHandle } from "./resident-runtime";
+
+const DEFAULT_READER_LIMIT = 8;
+const DEFAULT_READER_QUEUE_LIMIT = 64;
+
+export class ReaderGate {
+  readonly #limit: number;
+  readonly #maxQueued: number;
+  #active = 0;
+  readonly #queue: Array<{
+    resolve: () => void;
+    reject: (error: Error) => void;
+    signal?: AbortSignal;
+    onAbort?: () => void;
+  }> = [];
+
+  constructor(
+    limit = DEFAULT_READER_LIMIT,
+    maxQueued = DEFAULT_READER_QUEUE_LIMIT
+  ) {
+    this.#limit = Math.max(1, Math.floor(limit));
+    this.#maxQueued = Math.max(0, Math.floor(maxQueued));
+  }
+
+  get active(): number {
+    return this.#active;
+  }
+
+  get queued(): number {
+    return this.#queue.length;
+  }
+
+  get limit(): number {
+    return this.#limit;
+  }
+
+  get maxQueued(): number {
+    return this.#maxQueued;
+  }
+
+  async acquire(signal?: AbortSignal): Promise<() => void> {
+    if (signal?.aborted) {
+      throw new Error("Resident request aborted");
+    }
+    if (this.#active >= this.#limit) {
+      if (this.#queue.length >= this.#maxQueued) {
+        throw new Error("Resident reader queue is full");
+      }
+      await new Promise<void>((resolve, reject) => {
+        const entry = {
+          resolve,
+          reject,
+          signal,
+          onAbort: undefined as (() => void) | undefined,
+        };
+        entry.onAbort = () => {
+          const index = this.#queue.indexOf(entry);
+          if (index >= 0) this.#queue.splice(index, 1);
+          reject(new Error("Resident request aborted"));
+        };
+        signal?.addEventListener("abort", entry.onAbort, { once: true });
+        this.#queue.push(entry);
+      });
+    }
+    if (signal?.aborted) throw new Error("Resident request aborted");
+    this.#active += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.#active -= 1;
+      const next = this.#queue.shift();
+      if (next) {
+        next.signal?.removeEventListener("abort", next.onAbort!);
+        next.resolve();
+      }
+    };
+  }
+}
+
+export class AdmissionController {
+  #accepting = true;
+  readonly #requests = new Map<string, AbortController>();
+  readonly #drainWaiters = new Set<() => void>();
+
+  get active(): number {
+    return this.#requests.size;
+  }
+
+  get accepting(): boolean {
+    return this.#accepting;
+  }
+
+  admit(parentSignal?: AbortSignal): ResidentRequestHandle | null {
+    if (!this.#accepting) return null;
+    const id = crypto.randomUUID();
+    const controller = new AbortController();
+    const abortFromParent = (): void => controller.abort(parentSignal?.reason);
+    parentSignal?.addEventListener("abort", abortFromParent, { once: true });
+    if (parentSignal?.aborted) abortFromParent();
+    this.#requests.set(id, controller);
+    let finished = false;
+    return {
+      id,
+      signal: controller.signal,
+      finish: () => {
+        if (finished) return;
+        finished = true;
+        parentSignal?.removeEventListener("abort", abortFromParent);
+        this.#requests.delete(id);
+        if (this.#requests.size === 0) {
+          for (const waiter of this.#drainWaiters) waiter();
+          this.#drainWaiters.clear();
+        }
+      },
+    };
+  }
+
+  async closeAndDrain(
+    deadlineMs: number,
+    abortSettleMs = deadlineMs
+  ): Promise<boolean> {
+    this.#accepting = false;
+    if (this.#requests.size === 0) return false;
+
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    let deadlineReached = false;
+    await Promise.race([
+      new Promise<void>((resolve) => this.#drainWaiters.add(resolve)),
+      new Promise<void>((resolve) => {
+        timeout = setTimeout(
+          () => {
+            deadlineReached = true;
+            resolve();
+          },
+          Math.max(0, deadlineMs)
+        );
+      }),
+    ]);
+    if (timeout) clearTimeout(timeout);
+
+    if (!deadlineReached) return false;
+
+    for (const controller of this.#requests.values())
+      controller.abort(new Error("Resident runtime is shutting down"));
+
+    if (this.#requests.size > 0) {
+      await Promise.race([
+        new Promise<void>((resolve) => this.#drainWaiters.add(resolve)),
+        new Promise<void>((resolve) =>
+          setTimeout(resolve, Math.max(0, abortSettleMs))
+        ),
+      ]);
+    }
+    return deadlineReached;
+  }
+}

package/src/serve/resident-background-work.ts

@@ -0,0 +1,39 @@
+/** Tracks cancellable work that intentionally outlives its initiating request. */
+
+interface BackgroundWorkEntry {
+  controller: AbortController;
+  promise: Promise<void>;
+}
+
+export class ResidentBackgroundWork {
+  readonly #entries = new Set<BackgroundWorkEntry>();
+  readonly #isAccepting: () => boolean;
+
+  constructor(isAccepting: () => boolean) {
+    this.#isAccepting = isAccepting;
+  }
+
+  start(operation: (signal: AbortSignal) => Promise<void>): boolean {
+    if (!this.#isAccepting()) return false;
+    const controller = new AbortController();
+    const entry: BackgroundWorkEntry = {
+      controller,
+      promise: Promise.resolve(),
+    };
+    entry.promise = Promise.resolve()
+      .then(() => operation(controller.signal))
+      .catch(() => undefined)
+      .finally(() => this.#entries.delete(entry));
+    this.#entries.add(entry);
+    return true;
+  }
+
+  async cancelAndDrain(): Promise<void> {
+    for (const entry of this.#entries) {
+      entry.controller.abort(new Error("Resident runtime is shutting down"));
+    }
+    await Promise.allSettled(
+      Array.from(this.#entries, (entry) => entry.promise)
+    );
+  }
+}

package/src/serve/resident-request.ts

@@ -0,0 +1,55 @@
+/** Admission, bounded-reader, and model-lease boundary for resident REST reads. */
+
+import type { ResidentRuntime } from "./resident-runtime";
+
+function unavailableResponse(): Response {
+  return Response.json(
+    { error: { code: "UNAVAILABLE", message: "Resident runtime unavailable" } },
+    { status: 503 }
+  );
+}
+
+function saturatedResponse(): Response {
+  return Response.json(
+    {
+      error: { code: "RATE_LIMITED", message: "Resident reader queue is full" },
+    },
+    { status: 429 }
+  );
+}
+
+export async function handleResidentRead(
+  runtime: ResidentRuntime,
+  request: Request | undefined,
+  operation: (signal: AbortSignal) => Promise<Response> | Response
+): Promise<Response> {
+  const admitted = runtime.admitRequest(request?.signal);
+  if (!admitted) return unavailableResponse();
+
+  let releaseReader: (() => void) | undefined;
+  try {
+    releaseReader = await runtime.readerGate.acquire(admitted.signal);
+    if (admitted.signal.aborted) return unavailableResponse();
+    const response = await runtime.withModelLease(() =>
+      Promise.resolve(operation(admitted.signal))
+    );
+    return admitted.signal.aborted ? unavailableResponse() : response;
+  } catch (error) {
+    if (
+      admitted.signal.aborted ||
+      (error instanceof Error && error.message === "Resident request aborted")
+    ) {
+      return unavailableResponse();
+    }
+    if (
+      error instanceof Error &&
+      error.message === "Resident reader queue is full"
+    ) {
+      return saturatedResponse();
+    }
+    throw error;
+  } finally {
+    releaseReader?.();
+    admitted.finish();
+  }
+}