@jokerized/decksmith 0.1.0

package/dist/server/queue.js

@@ -0,0 +1,195 @@
+import { explain } from "./errors.js";
+class QueueFullError extends Error {
+  hint;
+  status = 503;
+  constructor(max) {
+    super(`The queue is full \u2014 ${max} ${max === 1 ? "job is" : "jobs are"} already waiting.`);
+    this.name = "QueueFullError";
+    this.hint = "Decks are made one at a time because a render is minutes of CPU and RAM. Try again in a few minutes.";
+  }
+}
+class Queue {
+  #jobs = /* @__PURE__ */ new Map();
+  #waiting = [];
+  #watchers = /* @__PURE__ */ new Map();
+  #maxQueued;
+  #ttlMs;
+  #maxLog;
+  #now;
+  #onExpire;
+  #running;
+  constructor(opts = {}) {
+    this.#maxQueued = opts.maxQueued ?? 8;
+    this.#ttlMs = opts.ttlMs ?? 2 * 60 * 6e4;
+    this.#maxLog = opts.maxLog ?? 400;
+    this.#now = opts.now ?? Date.now;
+    this.#onExpire = opts.onExpire ?? (() => {
+    });
+  }
+  get depth() {
+    return this.#waiting.length;
+  }
+  get running() {
+    return this.#running;
+  }
+  /**
+   * Take a job, or refuse. Refusing is the point: an unbounded queue on a
+   * one-at-a-time worker is a promise the server cannot keep, and a caller told
+   * "position 400" has been lied to more politely than one told "full".
+   */
+  submit(input) {
+    if (this.#waiting.length >= this.#maxQueued) throw new QueueFullError(this.#maxQueued);
+    const job = {
+      id: input.id,
+      dir: input.dir,
+      state: "queued",
+      steps: input.stages.map((name) => ({ name, state: "pending" })),
+      log: [],
+      dropped: 0,
+      createdAt: this.#now(),
+      run: input.run
+    };
+    this.#jobs.set(job.id, job);
+    this.#waiting.push(job.id);
+    const ahead = this.#waiting.length - 1 + (this.#running ? 1 : 0);
+    this.#note(
+      job,
+      this.#waiting.length === 1 && !this.#running ? "queued" : `queued behind ${ahead} ${ahead === 1 ? "job" : "jobs"}`
+    );
+    for (const id of this.#waiting) this.#emit(id);
+    void this.#pump();
+    return this.view(job.id);
+  }
+  view(id) {
+    const job = this.#jobs.get(id);
+    if (!job) return void 0;
+    const at = this.#waiting.indexOf(id);
+    return {
+      id: job.id,
+      state: job.state,
+      ...job.stage ? { stage: job.stage } : {},
+      steps: job.steps.map((s) => ({ ...s })),
+      log: job.dropped ? [`\u2026 ${job.dropped} earlier line(s) dropped`, ...job.log] : [...job.log],
+      ...job.error ? { error: job.error } : {},
+      ...job.result ? { result: job.result } : {},
+      ...at >= 0 ? { queuePosition: at + 1 } : {},
+      createdAt: job.createdAt,
+      ms: (job.endedAt ?? this.#now()) - job.createdAt
+    };
+  }
+  /** Subscribe to changes for one job. Returns the unsubscribe. */
+  watch(id, fn) {
+    const set = this.#watchers.get(id) ?? /* @__PURE__ */ new Set();
+    set.add(fn);
+    this.#watchers.set(id, set);
+    return () => {
+      set.delete(fn);
+      if (set.size === 0) this.#watchers.delete(id);
+    };
+  }
+  /**
+   * Drop every job whose time is up and report their ids, so the caller can
+   * delete the directories. A running job is never swept, however old — the TTL
+   * measures how long an ANSWER is kept, not how long work may take.
+   */
+  sweep() {
+    const cutoff = this.#now() - this.#ttlMs;
+    const expired = [];
+    for (const job of [...this.#jobs.values()]) {
+      if (job.state === "running" || job.state === "queued") continue;
+      if ((job.endedAt ?? job.createdAt) > cutoff) continue;
+      this.#jobs.delete(job.id);
+      this.#watchers.delete(job.id);
+      expired.push(job.id);
+      this.#onExpire(job.id, job.dir);
+    }
+    return expired;
+  }
+  /* ---------------------------------------------------------------- internals */
+  async #pump() {
+    if (this.#running) return;
+    const id = this.#waiting.shift();
+    if (!id) return;
+    const job = this.#jobs.get(id);
+    if (!job) return void this.#pump();
+    this.#running = id;
+    job.state = "running";
+    this.#note(job, "running");
+    for (const other of this.#waiting) this.#emit(other);
+    try {
+      job.result = await job.run(this.#handle(job));
+      job.state = "done";
+      job.stage = void 0;
+      this.#note(job, "done");
+    } catch (err) {
+      job.state = "error";
+      job.error = explain(err);
+      const active = job.steps.find((s) => s.state === "running");
+      if (active) {
+        active.state = "error";
+        active.ms = this.#now() - (active.startedAt ?? this.#now());
+      }
+      this.#note(job, `error: ${job.error.message}`);
+    } finally {
+      job.endedAt = this.#now();
+      this.#running = void 0;
+      this.#emit(job.id);
+      void this.#pump();
+    }
+  }
+  #handle(job) {
+    return {
+      id: job.id,
+      dir: job.dir,
+      begin: (stage, detail) => {
+        job.stage = stage;
+        const step = this.#step(job, stage);
+        step.state = "running";
+        step.startedAt = this.#now();
+        if (detail) step.detail = detail;
+        this.#note(job, `${stage}: started`);
+      },
+      done: (stage, detail) => {
+        const step = this.#step(job, stage);
+        step.state = "done";
+        step.ms = this.#now() - (step.startedAt ?? this.#now());
+        if (detail) step.detail = detail;
+        this.#emit(job.id);
+      },
+      skip: (stage, why) => {
+        const step = this.#step(job, stage);
+        step.state = "skipped";
+        step.detail = why;
+        this.#emit(job.id);
+      },
+      log: (line) => this.#note(job, line)
+    };
+  }
+  /** A stage the caller did not declare still gets a row rather than vanishing. */
+  #step(job, stage) {
+    const found = job.steps.find((s) => s.name === stage);
+    if (found) return found;
+    const added = { name: stage, state: "pending" };
+    job.steps.push(added);
+    return added;
+  }
+  #note(job, line) {
+    job.log.push(line);
+    if (job.log.length > this.#maxLog) {
+      job.dropped += job.log.length - this.#maxLog;
+      job.log.splice(0, job.log.length - this.#maxLog);
+    }
+    this.#emit(job.id);
+  }
+  #emit(id) {
+    const watchers = this.#watchers.get(id);
+    if (!watchers?.size) return;
+    const view = this.view(id);
+    if (!view) return;
+    for (const fn of watchers) fn(view);
+  }
+}
+export {
+  Queue,
+  QueueFullError
+};