@astrosheep/keiyaku 4.0.6 → 4.1.0

package/build/src/task/store.js

@@ -5,6 +5,7 @@ import { dirname, relative, resolve, sep } from "node:path";
 import { acquireSqliteTransactionLock, SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
 import { parseTaskDocument } from "./document.js";
 import { formatTaskId, parseTaskId, taskAuthorityPath } from "./identity.js";
+export const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3_000;
 function syncTaskDirectory(path) {
     if (process.platform === "win32")
         return;
@@ -17,7 +18,6 @@ function syncTaskDirectory(path) {
     }
 }
 function tasksDirectory(world) { return resolve(world, ".keiyaku", "tasks"); }
-function taskLocksDirectory(world) { return resolve(world, ".keiyaku", "locks", "task"); }
 function allocationLockPath(world) { return resolve(world, ".keiyaku", "locks", "task-allocation.sqlite"); }
 async function authorityFiles(directory) {
     const files = [];
@@ -105,90 +105,14 @@ function lockPath(world, id) {
     const coordinate = parseTaskId(id);
     return resolve(world, ".keiyaku", "locks", "task", ...coordinate.namespace, `${coordinate.localId}.sqlite`);
 }
-async function regularFile(path, label) {
-    try {
-        const entry = await lstat(path);
-        if (!entry.isFile() || entry.isSymbolicLink())
-            throw new Error(`${label} is not a regular file: ${path}`);
-        return true;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-}
-async function taskLockFiles(world, directory = taskLocksDirectory(world)) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const files = [];
-    for (const entry of entries) {
-        const path = resolve(directory, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...await taskLockFiles(world, path));
-            continue;
-        }
-        if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith(".sqlite")) {
-            throw new Error(`Task lock has foreign or corrupt custody: ${path}`);
-        }
-        const local = relative(taskLocksDirectory(world), path);
-        const id = formatTaskId(parseTaskId(`task/${local.slice(0, -7).split(sep).join("/")}`));
-        if (lockPath(world, id) !== path)
-            throw new Error(`Task lock has invalid coordinate: ${path}`);
-        files.push({ id, path });
-    }
-    return files.sort((left, right) => Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)));
-}
-async function taskNukeCustody(world) {
-    const snapshot = await readBoard(world);
-    const locks = await taskLockFiles(world);
-    const allocation = allocationLockPath(world);
-    const lockPaths = [
-        ...(await regularFile(allocation, "Task allocation lock") ? [allocation] : []),
-        ...locks.map((lock) => lock.path),
-    ];
-    return {
-        authorityIds: [...snapshot.board.tasks.keys()].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right))),
-        lockIds: locks.map((lock) => lock.id),
-        lockPaths,
-    };
-}
-function sameIds(left, right) {
-    return left.length === right.length && left.every((id, index) => id === right[index]);
-}
-async function removeRegularFile(path, label) {
-    if (!(await regularFile(path, label)))
-        return;
-    await unlink(path);
-}
 export async function nukeTaskAuthority(world) {
-    const initial = await taskNukeCustody(world);
-    if (initial.authorityIds.length === 0 && initial.lockPaths.length === 0)
+    const ids = [...(await readBoard(world)).board.tasks.keys()]
+        .sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    if (ids.length === 0)
         return;
-    const ids = [...new Set([...initial.authorityIds, ...initial.lockIds])];
     const result = await withTaskLocks({ world, allocation: true, ids }, async () => {
-        const fresh = await taskNukeCustody(world);
-        if (!sameIds(initial.authorityIds, fresh.authorityIds)) {
-            throw new Error("Task authority changed while acquiring reset locks");
-        }
-        const expectedLocks = new Set([
-            ...initial.lockPaths,
-            allocationLockPath(world),
-            ...initial.authorityIds.map((id) => lockPath(world, id)),
-        ]);
-        if (fresh.lockPaths.some((path) => !expectedLocks.has(path))) {
-            throw new Error("Task lock custody changed while acquiring reset locks");
-        }
-        for (const id of fresh.authorityIds) {
-            await removeRegularFile(authorityPath(world, id), "Task authority");
-        }
+        for (const id of ids)
+            await unlink(authorityPath(world, id));
     });
     if (result === "busy")
         return "busy";
@@ -201,7 +125,12 @@ export async function withTaskLocks(input, action) {
     const held = [];
     try {
         for (const path of paths)
-            held.push(await acquireSqliteTransactionLock({ path, mode: "immediate", timeoutMs: 3_000, ...(input.signal === undefined ? {} : { signal: input.signal }) }));
+            held.push(await acquireSqliteTransactionLock({
+                path,
+                mode: "immediate",
+                timeoutMs: input.timeoutMs ?? DEFAULT_TASK_LOCK_TIMEOUT_MS,
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            }));
         return await action();
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.0.6",
+  "version": "4.1.0",
   "files": [
     "build"
   ],