@stringsync/splates 0.0.0-stage → 0.0.45

package/index-xmfmy729.js

@@ -0,0 +1,249 @@
+import {
+  LEGACY_DIR
+} from "./index-k73tsw5g.js";
+import {
+  splatesHome
+} from "./index-43pq33n4.js";
+
+// heavy.ts
+import { HeavyJobs } from "webappwiz/system";
+
+// slots.ts
+import { FileLock } from "webappwiz/system";
+import { Duration, sleep } from "webappwiz/time";
+import { z } from "zod";
+var SERVER_PID = "server.pid";
+var SLOT = "SPLATES_SLOT";
+var MACHINE_HOME = "SPLATES_MACHINE_HOME";
+var STOP_WAIT = Duration.secs(5);
+var FORMAT = 1;
+
+class Slots {
+  path;
+  deps;
+  constructor(path, deps) {
+    this.path = path;
+    this.deps = deps;
+  }
+  static ofMachine({ fs, ps, log }) {
+    const home = ps.env(MACHINE_HOME) ?? splatesHome(ps);
+    return new Slots(`${home}/slots.json`, {
+      fs,
+      ps,
+      lock: new FileLock(`${home}/slots.lock`, { fs, ps, log })
+    });
+  }
+  async owns(tree) {
+    const { fs } = this.deps;
+    return await fs.exists(tree) && !await fs.exists(`${tree}/.git/splates`) && !await fs.exists(`${tree}/.git/${LEGACY_DIR}`);
+  }
+  async claim(tree) {
+    const { fs, lock, pool = SLOT_POOL } = this.deps;
+    await fs.mkdir(this.path.slice(0, this.path.lastIndexOf("/")));
+    await lock.acquire();
+    try {
+      const claims = await this.read();
+      const held = pool.find(({ word }) => claims[word] === tree);
+      if (held !== undefined) {
+        return held;
+      }
+      const holders = [];
+      for (const slot of pool) {
+        const holder = claims[slot.word];
+        if (holder !== undefined && await this.owns(holder)) {
+          holders.push(`  ${slot.word}: ${holder}`);
+          continue;
+        }
+        const pid = await this.server(slot);
+        if (pid !== null) {
+          holders.push(`  ${slot.word}: pid ${pid}${holder === undefined ? "" : `, run from ${holder}`}`);
+          continue;
+        }
+        await this.write({ ...claims, [slot.word]: tree });
+        return slot;
+      }
+      throw new Error([
+        "every dev slot is held:",
+        ...holders,
+        "each is another task's: `splates slots prune` frees those no task owns any more, and stops their servers; never stop another task's server or edit its claim"
+      ].join(`
+`));
+    } finally {
+      await lock.release();
+    }
+  }
+  home(slot) {
+    return `${this.path.slice(0, this.path.lastIndexOf("/"))}/slots/${slot.word}`;
+  }
+  async server(slot) {
+    const { fs, ps } = this.deps;
+    const file = `${this.home(slot)}/${SERVER_PID}`;
+    if (!await fs.exists(file)) {
+      return null;
+    }
+    const pid = Number.parseInt((await fs.read(file)).trim(), 10);
+    if (!Number.isInteger(pid) || pid === ps.pid || !ps.alive(pid)) {
+      return null;
+    }
+    const running = (await ps.processes()).find((each) => each.pid === pid);
+    if (running !== undefined && !/\bdev\b/.test(running.command)) {
+      return null;
+    }
+    return pid;
+  }
+  async list() {
+    const { pool = SLOT_POOL } = this.deps;
+    const claims = await this.read();
+    const held = [];
+    for (const slot of pool) {
+      const tree = claims[slot.word];
+      if (tree !== undefined && await this.owns(tree)) {
+        held.push({ slot, tree });
+      }
+    }
+    return held;
+  }
+  async status() {
+    const { pool = SLOT_POOL } = this.deps;
+    const claims = await this.read();
+    const held = [];
+    for (const slot of pool) {
+      const tree = claims[slot.word];
+      if (tree !== undefined) {
+        held.push({
+          slot,
+          tree,
+          pid: await this.server(slot),
+          orphaned: !await this.owns(tree)
+        });
+      }
+    }
+    return held;
+  }
+  async stop(slot) {
+    const { ps } = this.deps;
+    const pid = await this.server(slot);
+    if (pid === null) {
+      return null;
+    }
+    await ps.spawnCapture(["kill", String(pid)]);
+    const deadline = Date.now() + STOP_WAIT.ms;
+    while (ps.alive(pid)) {
+      if (Date.now() >= deadline) {
+        await ps.spawnCapture(["kill", "-KILL", String(pid)]);
+        break;
+      }
+      await sleep(Duration.ms(100));
+    }
+    return pid;
+  }
+  async release(tree) {
+    const { lock, pool = SLOT_POOL } = this.deps;
+    if (!Object.values(await this.read()).includes(tree)) {
+      return null;
+    }
+    await lock.acquire();
+    try {
+      const claims = await this.read();
+      const slot = pool.find(({ word }) => claims[word] === tree);
+      if (slot === undefined) {
+        return null;
+      }
+      const stopped = await this.stop(slot);
+      const { [slot.word]: _, ...rest } = claims;
+      await this.write(rest);
+      return { slot, stopped };
+    } finally {
+      await lock.release();
+    }
+  }
+  async prune() {
+    const { lock } = this.deps;
+    if (!await this.deps.fs.exists(this.path)) {
+      return [];
+    }
+    await lock.acquire();
+    try {
+      const orphans = (await this.status()).filter(({ orphaned }) => orphaned);
+      const claims = await this.read();
+      for (const orphan of orphans) {
+        await this.stop(orphan.slot);
+        delete claims[orphan.slot.word];
+      }
+      if (orphans.length > 0) {
+        await this.write(claims);
+      }
+      return orphans;
+    } finally {
+      await lock.release();
+    }
+  }
+  async read() {
+    const raw = await this.deps.fs.read(this.path).catch(() => null);
+    if (raw === null) {
+      return {};
+    }
+    const parsed = Claims.safeParse(JSON.parse(raw));
+    if (!parsed.success || parsed.data.format > FORMAT) {
+      throw new Error(`${this.path} is not slots this splates reads: remove it to start over`);
+    }
+    return parsed.data.claims;
+  }
+  async write(claims) {
+    const tmp = `${this.path}.${crypto.randomUUID()}.tmp`;
+    await this.deps.fs.write(tmp, `${JSON.stringify({ format: FORMAT, claims }, null, "\t")}
+`);
+    await this.deps.fs.rename(tmp, this.path);
+  }
+}
+var SLOT_POOL = [
+  { word: "cat", emoji: "\uD83D\uDE38" },
+  { word: "bee", emoji: "\uD83D\uDC1D" },
+  { word: "dog", emoji: "\uD83D\uDC36" },
+  { word: "fox", emoji: "\uD83E\uDD8A" },
+  { word: "owl", emoji: "\uD83E\uDD89" },
+  { word: "pig", emoji: "\uD83D\uDC37" },
+  { word: "lion", emoji: "\uD83E\uDD81" },
+  { word: "wolf", emoji: "\uD83D\uDC3A" },
+  { word: "bear", emoji: "\uD83D\uDC3B" },
+  { word: "frog", emoji: "\uD83D\uDC38" },
+  { word: "duck", emoji: "\uD83E\uDD86" },
+  { word: "crab", emoji: "\uD83E\uDD80" }
+];
+function freedLine({
+  slot,
+  stopped
+}) {
+  return `${slot.word} ${slot.emoji} given back${stopped === null ? "" : `, its server (pid ${stopped}) stopped`}`;
+}
+function slotOf(word) {
+  return SLOT_POOL.find((each) => each.word === word) ?? null;
+}
+var Claims = z.object({
+  format: z.number(),
+  claims: z.record(z.string(), z.string())
+});
+
+// heavy.ts
+var HEAVY_JOBS_DEFAULT2 = 2;
+var HEAVY_JOBS2 = "SPLATES_HEAVY_JOBS";
+var HEAVY_HELD2 = "SPLATES_HEAVY";
+function heavyJobsOfMachine2({
+  fs,
+  ps,
+  log
+}) {
+  return HeavyJobs.under(ps.env(MACHINE_HOME) ?? splatesHome(ps), {
+    fs,
+    ps,
+    log,
+    cap: capOf2(ps.env(HEAVY_JOBS2)),
+    held: HEAVY_HELD2
+  });
+}
+function capOf2(value) {
+  const cap = Number(value);
+  return Number.isInteger(cap) && cap > 0 ? cap : HEAVY_JOBS_DEFAULT2;
+}
+
+export { SERVER_PID, SLOT, MACHINE_HOME, Slots, SLOT_POOL, freedLine, slotOf, HEAVY_JOBS_DEFAULT2, HEAVY_JOBS2, HEAVY_HELD2, heavyJobsOfMachine2, capOf2 };

package/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};