@bjornpagen/bumbledb-log 0.19.2 → 0.20.0

package/src/tenants.ts

@@ -17,15 +17,13 @@ import * as path from "node:path"
 import type { Schema, SchemaRelations } from "@bjornpagen/bumbledb"
 import * as errors from "@superbuilders/errors"
 import { regex } from "arkregex"
-import { tenantPrefix } from "#keys.ts"
+import { TEMP_NAMESPACE, tenantPrefix } from "#keys.ts"
 import type { Replica } from "#replica.ts"
 import { openReplica } from "#replica.ts"
 import type { FsLease, ObjectStore } from "#store.ts"
-import { acquireFsLease, releaseFsLease } from "#store.ts"
+import { acquireFsLease, encodeLease, parseLease, releaseFsLease, sweepStaleTemps, syncedTemp } from "#store.ts"
 
 const PINNED_TENANT = "_shared"
-const SIGNED_DECIMAL = regex("^-?\\d+$")
-const UNSIGNED_DECIMAL = regex("^\\d+$")
 const TENANT_ID = regex("^[A-Za-z0-9._-]+$")
 
 /** Directory-lease lifetime: one owner per replica directory. The pool
@@ -88,25 +86,6 @@ function codeOf(error: Error): string | undefined {
 	return (error as NodeJS.ErrnoException).code
 }
 
-function encodeLease(holder: bigint, token: bigint, expires: bigint): Uint8Array {
-	return new TextEncoder().encode(`${holder}\n${token}\n${expires}\n`)
-}
-
-function parseLease(raw: string): { holder: bigint; token: bigint; expires: bigint } | null {
-	const lines = raw.trim().split("\n")
-	if (lines.length !== 3) {
-		return null
-	}
-	const [holderLine, tokenLine, expiresLine] = lines
-	if (holderLine === undefined || tokenLine === undefined || expiresLine === undefined) {
-		return null
-	}
-	if (!SIGNED_DECIMAL.test(holderLine) || !UNSIGNED_DECIMAL.test(tokenLine) || !SIGNED_DECIMAL.test(expiresLine)) {
-		return null
-	}
-	return { holder: BigInt(holderLine), token: BigInt(tokenLine), expires: BigInt(expiresLine) }
-}
-
 async function fsyncDir(dir: string): Promise<void> {
 	const handle = await fs.open(dir, "r")
 	const synced = await errors.try(handle.sync())
@@ -131,23 +110,13 @@ async function renewDirLease(held: FsLease, ttlMs: number): Promise<void> {
 	if (lease === null || lease.holder !== held.holder || lease.token !== held.token) {
 		throw errors.new("directory lease is no longer ours")
 	}
-	const body = encodeLease(held.holder, held.token, BigInt(Date.now() + ttlMs))
-	const tmp = `${held.path}.renew.${process.pid}`
-	const file = await fs.open(tmp, "w")
-	const written = await errors.try(
-		(async function writeAll() {
-			await file.writeFile(body)
-			await file.sync()
-		})()
-	)
-	await file.close()
-	if (written.error) {
-		await fs.rm(tmp, { force: true })
-		throw written.error
-	}
-	const replaced = await errors.try(fs.rename(tmp, held.path))
+	const body = encodeLease({ holder: held.holder, token: held.token, expires: BigInt(Date.now() + ttlMs) })
+	// The temp lives under the reserved `{root}/~tmp` namespace, where a
+	// crash strands sweepable litter — never beside the lease path.
+	const temp = await syncedTemp(held.root, body)
+	const replaced = await errors.try(fs.rename(temp, held.path))
 	if (replaced.error) {
-		await fs.rm(tmp, { force: true })
+		await fs.rm(temp, { force: true })
 		if (codeOf(replaced.error) === "ENOENT") {
 			return
 		}
@@ -199,6 +168,9 @@ function openTenants<Rels extends SchemaRelations>(options: OpenTenantsOptions<R
 	const renewEveryMs = Math.max(1, Math.floor(dirLeaseMs / 3))
 	const open = new Map<string, TenantSlot<Rels>>()
 	const opening = new Map<string, Promise<LiveHandle<Rels>>>()
+	/** The pool root's `~tmp` holds lease mint/renew/release temps; stale
+	 *  ones are crash litter swept once per pool open, best-effort. */
+	const swept = errors.try(sweepStaleTemps(path.join(options.dir, TEMP_NAMESPACE)))
 	let tick = 0
 	let closed = false
 	let renewTimer: ReturnType<typeof setInterval> | undefined
@@ -328,8 +300,14 @@ function openTenants<Rels extends SchemaRelations>(options: OpenTenantsOptions<R
 	}
 
 	async function openOne(tenant: string): Promise<LiveHandle<Rels>> {
+		await swept
 		const dir = path.join(options.dir, tenant)
-		const lease = await acquireFsLease(dir, "dir", dirLeaseMs, "refuse")
+		/** The dir-lease mirrors Rust `acquire_named`: tokens live at
+		 *  `{options.dir}/~lease/{tenant}`, outside the disposable replica
+		 *  directory `{options.dir}/{tenant}` — the replica-open sweep
+		 *  rm-rfs the replica dir's own `~lease` and must not touch the
+		 *  held tenant lease. */
+		const lease = await acquireFsLease(options.dir, tenant, dirLeaseMs, "refuse")
 		let replica: LiveHandle<Rels>
 		try {
 			replica = brandLive(
@@ -432,5 +410,5 @@ function openTenants<Rels extends SchemaRelations>(options: OpenTenantsOptions<R
 	}
 }
 
-export type { DisposedHandle, LiveHandle, OpenTenantsOptions, Tenants }
+export type { OpenTenantsOptions, Tenants }
 export { openTenants }

package/src/vector.ts

@@ -1,34 +1,19 @@
 /**
- * The per-braid generation map. Sum, domination, checkpoint order,
- * apply's increment, and the coordinate's one binary encoding live
- * here. Overflow is a refusal of `sum` and of nowhere else.
+ * The per-braid generation map. Sum, domination, checkpoint order, and
+ * apply's increment live here. Overflow is a refusal of `sum` and of
+ * nowhere else.
  */
 
-import { ByteReader, ByteWriter, U64_MAX } from "#bytes.ts"
+import { U64_MAX } from "#bytes.ts"
 import type { Braid } from "#descriptor.ts"
-import { braidHex } from "#descriptor.ts"
 import type { Generation } from "#keys.ts"
 import { generation } from "#keys.ts"
 
-/** One braid id and its applied count on the wire: u32le + u64le. */
-const PAIR_BYTES = 12n
-
 const Overflow = { tag: "overflow" } as const
 type Overflow = typeof Overflow
 
 type CheckpointOrder = "before" | "equal" | "after"
 
-type VectorParse =
-	| { readonly tag: "ok"; readonly vector: Vector }
-	| { readonly tag: "truncated" }
-	| { readonly tag: "trailing"; readonly bytes: number }
-	| { readonly tag: "malformed" }
-	| { readonly tag: "overflow" }
-
-function braidIdOf(id: Braid): number {
-	return Number.parseInt(id.slice(1), 16)
-}
-
 /** Applied counts keyed by braid. Any vector is a legal restore point. */
 class Vector {
 	readonly #counts: Map<Braid, bigint>
@@ -112,62 +97,7 @@ class Vector {
 		next.set(braid, current === U64_MAX ? U64_MAX : current + 1n)
 		return new Vector(next)
 	}
-
-	/** `u32le` count, then `(u32le braid, u64le g)` pairs in braid order. */
-	encode(): Uint8Array {
-		const braids = [...this.#counts.keys()].sort()
-		const out = new ByteWriter(4 + braids.length * 12)
-		out.u32le(braids.length)
-		for (const id of braids) {
-			out.u32le(braidIdOf(id))
-			out.u64le(this.#counts.get(id) ?? 0n)
-		}
-		return out.finish()
-	}
-
-	/**
-	 * Inverse of `encode`. A count the remaining bytes cannot open is
-	 * truncated; entries must ascend; overflow is `sum`.
-	 */
-	static parse(bytes: Uint8Array): VectorParse {
-		const short = { tag: "short" } as const
-		const reader = new ByteReader(bytes, {
-			fail(): never {
-				throw short
-			}
-		})
-		try {
-			const count = BigInt(reader.u32le("count"))
-			if (count > 0n && BigInt(reader.remaining()) / PAIR_BYTES < count) {
-				return { tag: "truncated" }
-			}
-			const entries: Array<readonly [Braid, bigint]> = []
-			let last: Braid | undefined
-			for (let i = 0n; i < count; i++) {
-				const name = braidHex(reader.u32le("braid"))
-				const g = reader.u64le("g")
-				if (last !== undefined && last >= name) {
-					return { tag: "malformed" }
-				}
-				entries.push([name, g])
-				last = name
-			}
-			if (reader.remaining() !== 0) {
-				return { tag: "trailing", bytes: reader.remaining() }
-			}
-			const vector = new Vector(entries)
-			if (typeof vector.sum() !== "bigint") {
-				return { tag: "overflow" }
-			}
-			return { tag: "ok", vector }
-		} catch (error) {
-			if (error === short) {
-				return { tag: "truncated" }
-			}
-			throw error
-		}
-	}
 }
 
-export type { CheckpointOrder, VectorParse }
+export type { CheckpointOrder }
 export { Overflow, Vector }