@sanoma-ai/connector-cloudflare 0.3.2 → 0.5.0

package/worker/instance.js

@@ -8,7 +8,9 @@
 // another destroyed and started again (a deploy); it waits for `/healthz`, and proxies every
 // request to it. It answers `/__sanoma/health` without starting it (with `?start=1`, once it
 // runs), and holds the company's one wake (`/__sanoma/wake`) as an alarm, which starts the
-// container at `at` and calls its `/wake`.
+// container at `at` and calls its `/wake`. `startNow`, which the sites router calls over RPC
+// when a page on the Worker queued a run, starts the container from an alarm too, without the
+// caller waiting for it, and calls its `/wake`: a worker that stopped itself runs the queued run.
 
 /** The object's own route: the wake it holds. */
 export const WAKE_PATH = "/__sanoma/wake";
@@ -26,6 +28,13 @@ const POLL_MS = 250;
 const MAX_POLL_MS = 1_000;
 /** Where the wake is kept, in the object's storage. */
 const WAKE_KEY = "wake";
+/** Where a start `startNow` asked for is kept until the alarm that makes it rings. */
+const START_KEY = "start";
+/**
+ * The retries of an alarm whose start keeps failing before that start is given up, so the wake
+ * held for later is set again: Cloudflare retries an alarm that throws up to six times, then drops it.
+ */
+const START_RETRIES = 5;
 /** The binding that names the object, in the Worker's env. */
 export const NAMESPACE = "SANOMA_INSTANCE";
 /** The name the upload gives the runtime image (`containers[].images`), which the object starts. */
@@ -44,7 +53,7 @@ function containerEnv(env) {
   return Object.fromEntries(Object.entries(env).filter(([, value]) => typeof value === "string"));
 }
 
-/** The label naming an image: a digest of it, as a label holds 64 bytes and a pinned image is longer. */
+/** The label naming an image (or the sites' domains): a digest of it, as a label holds 64 bytes and a pinned image is longer. */
 export async function imageLabel(image) {
   const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(image));
   return [...new Uint8Array(digest).slice(0, 8)].map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -152,6 +161,8 @@ export class Instance {
       revision: this.env.SANOMA_REVISION ?? "",
       image: await imageLabel(image),
       ...(this.env.SANOMA_CONFIG_REVISION && { configuration: this.env.SANOMA_CONFIG_REVISION }),
+      // The sites' domains, which its environment and the sites bundle it built name.
+      ...(this.env.SANOMA_DOMAINS && { domains: await imageLabel(this.env.SANOMA_DOMAINS) }),
     };
     const until = Date.now() + START_TIMEOUT_MS;
     let last;
@@ -178,8 +189,9 @@ export class Instance {
             info &&
             info.labels?.revision === labels.revision &&
             (info.labels?.image ?? "") === labels.image &&
-            (info.labels?.configuration ?? "") === (labels.configuration ?? "");
-          if (!same) await container.destroy("a new revision, image or configuration");
+            (info.labels?.configuration ?? "") === (labels.configuration ?? "") &&
+            (info.labels?.domains ?? "") === (labels.domains ?? "");
+          if (!same) await container.destroy("a new revision, image, configuration or domains");
         }
         checked = true;
         if (!container.running) {
@@ -235,9 +247,11 @@ export class Instance {
     }
     const storage = this.ctx.storage;
     if (request.method === "GET") return json(200, (await storage.get(WAKE_KEY)) ?? { at: null });
+    // A start `startNow` asked for keeps its alarm, which sets the wake's once it rang.
+    const starting = Boolean(await storage.get(START_KEY));
     if (request.method === "DELETE") {
       await storage.delete(WAKE_KEY);
-      await storage.deleteAlarm();
+      if (!starting) await storage.deleteAlarm();
       return new Response(null, { status: 204 });
     }
     if (request.method !== "PUT") return problem(405, "GET, PUT or DELETE");
@@ -245,14 +259,55 @@ export class Instance {
     if (!wake) return problem(400, "the body must be { at: an ISO 8601 time }");
     // Whatever it held is replaced: a wake that rings for an older one starts a worker with nothing to do.
     await storage.put(WAKE_KEY, wake);
-    await storage.setAlarm(Date.parse(wake.at));
+    if (starting) await alarmBy(storage, Date.parse(wake.at));
+    else await storage.setAlarm(Date.parse(wake.at));
     return new Response(null, { status: 204 });
   }
 
-  /** The wake is due: start the container and send it `/wake`, then note when. A throw makes Cloudflare retry the alarm. */
-  async alarm() {
-    const wake = await this.ctx.storage.get(WAKE_KEY);
-    if (!wake) return;
+  /**
+   * Starts the container soon and sends it `/wake`, without waiting for it: a run was queued for
+   * it (the sites router's call, over RPC, once a page on the Worker started one). An alarm now,
+   * which outlives the request that asked, makes the start; a wake held for later is set again once it is made.
+   */
+  async startNow() {
+    const storage = this.ctx.storage;
+    await storage.put(START_KEY, true);
+    await alarmBy(storage, Date.now());
+  }
+
+  /**
+   * A start `startNow` asked for, then the wake if it is due: start the container and send it
+   * `/wake` (once for both), then note when the wake rang. A wake not due yet is set again. A throw makes Cloudflare retry the
+   * alarm; a start that still fails after `START_RETRIES` is given up, the wake kept.
+   */
+  async alarm(info) {
+    const storage = this.ctx.storage;
+    let woke = false;
+    if (await storage.get(START_KEY)) {
+      try {
+        await this.#wakeContainer();
+        woke = true;
+      } catch (error) {
+        if ((info?.retryCount ?? 0) < START_RETRIES) throw error;
+        console.error(`starting the container for a queued run failed: ${error?.message ?? error}`);
+      }
+      await storage.delete(START_KEY);
+    }
+    const wake = await storage.get(WAKE_KEY);
+    if (!wake || wake.rang) return;
+    const at = Date.parse(wake.at);
+    if (at > Date.now()) return storage.setAlarm(at);
+    if (!woke) await this.#wakeContainer();
+    // When it rang, which a GET shows: unless another wake replaced it meanwhile.
+    const held = await this.ctx.storage.get(WAKE_KEY);
+    if (held?.at === wake.at) await this.ctx.storage.put(WAKE_KEY, { ...held, rang: new Date().toISOString() });
+  }
+
+  /**
+   * Starts the container unless it runs, then sends it `/wake`: a container that is up may hold a
+   * worker that stopped itself, which only a wake (or a write through its app) starts again.
+   */
+  async #wakeContainer() {
     await this.ensureRunning();
     const res = await this.ctx.container.getTcpPort(this.port).fetch("http://container/wake");
     await res.body?.cancel();
@@ -260,13 +315,19 @@ export class Instance {
       console.error(`GET /wake answered ${res.status}`);
       throw new Error(`the container answered /wake with ${res.status}`);
     }
-    // When it rang, which a GET shows: unless another wake replaced it meanwhile.
-    const held = await this.ctx.storage.get(WAKE_KEY);
-    if (held?.at === wake.at) await this.ctx.storage.put(WAKE_KEY, { ...held, rang: new Date().toISOString() });
   }
 }
 
+/** Sets the object's alarm to ring by `at`: an alarm set to ring sooner is left as it is. */
+async function alarmBy(storage, at) {
+  const set = await storage.getAlarm();
+  if (set === null || set > at) await storage.setAlarm(at);
+}
+
+/** The Worker's one object, which every request and the sites router's `startNow` go to. */
+export const instanceOf = (env) => env[NAMESPACE].getByName("instance");
+
 /** The Worker's default export: every request goes to the one object. */
 export const worker = {
-  fetch: (request, env) => env[NAMESPACE].getByName("instance").fetch(request),
+  fetch: (request, env) => instanceOf(env).fetch(request),
 };

package/worker/sites.js

@@ -0,0 +1,17 @@
+// The company's Worker when it serves public sites: the main module `cloudflare.container`
+// uploads in place of `index.js` once the container built the sites bundle (`sites/index.js`,
+// `buildWorker` in `@sanoma-ai/app/build`). A request the bundle serves (a page of a public site
+// without a login, on its domain) is answered here, on the Worker, and never waits for the
+// container; everything else goes to the one object, as `index.js` sends it. A run a page starts
+// has the object start the container (`startNow`), which runs it.
+import { instanceOf, worker } from "./instance.js";
+import sites from "./sites/index.js";
+
+export { SanomaInstance } from "./index.js";
+
+export default {
+  fetch(request, env, ctx) {
+    if (!sites.serves(request, env)) return worker.fetch(request, env);
+    return sites.fetch(request, env, ctx, { startNow: () => instanceOf(env).startNow() });
+  },
+};