@davideasden/pi-undo 0.2.2 → 0.2.4

package/src/snapshot-store.ts

@@ -20,7 +20,7 @@ import type {
 	SnapshotManifest,
 	SnapshotRoot,
 } from "./model.ts";
-import { assertNoSymlinkEscape, relativeSafePath } from "./path-safety.ts";
+import { assertNoSymlinkEscape, pathSetsOverlap, relativeSafePath } from "./path-safety.ts";
 import { RootDiscovery, type RootTopology } from "./root-discovery.ts";
 import { WorkspaceLock } from "./workspace-lock.ts";
 
@@ -96,6 +96,12 @@ export interface CaptureOptions {
 	readonly excludePaths?: readonly string[];
 }
 
+export interface SnapshotBlobRequest {
+	readonly rootPath: string;
+	readonly blobId: string;
+	readonly relativePath?: string;
+}
+
 export type SnapshotStoreErrorCode =
 	| "capture_failed"
 	| "invalid_manifest_id"
@@ -125,6 +131,7 @@ export interface SnapshotStore {
 	pin(id: ManifestId, reason: string): Promise<void>;
 	unpin(id: ManifestId, reason: string): Promise<void>;
 	collectGarbage(): Promise<number>;
+	durableCacheDirectory(): Promise<string>;
 }
 
 export class SnapshotStore {
@@ -150,6 +157,39 @@ export class SnapshotStore {
 		this.clock = options.clock ?? Date.now;
 	}
 
+	static supportsValidatedBlobBatch(store: SnapshotStore): boolean {
+		return store instanceof SnapshotStore &&
+			store.readBlob === SnapshotStore.prototype.readBlob &&
+			store.loadManifest === SnapshotStore.prototype.loadManifest;
+	}
+
+	static async readBlobs(
+		store: SnapshotStore,
+		id: ManifestId,
+		requests: readonly SnapshotBlobRequest[],
+	): Promise<readonly Uint8Array[]> {
+		if (requests.length === 0) return [];
+		if (SnapshotStore.supportsValidatedBlobBatch(store)) {
+			return (store as SnapshotStore).readBlobsValidated(id, requests);
+		}
+		const result: Uint8Array[] = [];
+		for (const request of requests) {
+			result.push(await store.readBlob(
+				id,
+				request.rootPath,
+				request.blobId,
+				request.relativePath,
+			));
+		}
+		return result;
+	}
+
+	async durableCacheDirectory(): Promise<string> {
+		const directory = join(this.storeRoot, "durable-cache");
+		await mkdir(directory, { recursive: true });
+		return directory;
+	}
+
 	async capture(
 		topology: RootTopology,
 		scope?: readonly string[],
@@ -302,7 +342,10 @@ export class SnapshotStore {
 	}
 
 	async loadManifest(id: ManifestId): Promise<SnapshotManifest> {
-		const manifestPath = await this.findManifestPath(id);
+		return this.loadManifestFromPath(id, await this.findManifestPath(id));
+	}
+
+	private async loadManifestFromPath(id: ManifestId, manifestPath: string): Promise<SnapshotManifest> {
 		try {
 			const value: unknown = JSON.parse(await readFile(manifestPath, "utf8"));
 			const manifest = assertManifest(value);
@@ -342,10 +385,10 @@ export class SnapshotStore {
 				const gitDirectory = this.rootGitDirectory(storeDirectory, root);
 				await this.assertNoAlternates(gitDirectory);
 				const entries = await this.readTreeEntries(gitDirectory, root.treeId, rootScope);
-				if (root.ignoredPresentPaths.some((ignoredPath) => entries.some(
-					(entry) => isPathAtOrBelow(ignoredPath, entry.relativePath) ||
-						isPathAtOrBelow(entry.relativePath, ignoredPath),
-				))) {
+				if (pathSetsOverlap(
+					root.ignoredPresentPaths,
+					entries.map((entry) => entry.relativePath),
+				)) {
 					throw new SnapshotStoreError("object_missing", "ignored-present proof 与 root tree 冲突");
 				}
 				await this.assertObjectsComplete(gitDirectory, root.treeId, entries);
@@ -425,41 +468,67 @@ export class SnapshotStore {
 		blobId: string,
 		relativePath?: string,
 	): Promise<Uint8Array> {
-		relativeSafePath("/", rootPath);
-		if (!isObjectId(blobId)) {
-			throw new SnapshotStoreError("object_missing", "blob ID 无效");
+		return (await this.readBlobOperation(id, [{ rootPath, blobId, relativePath }], false))[0]!;
+	}
+
+	private readBlobsValidated(
+		id: ManifestId,
+		requests: readonly SnapshotBlobRequest[],
+	): Promise<readonly Uint8Array[]> {
+		return this.readBlobOperation(id, requests, true);
+	}
+
+	private async readBlobOperation(
+		id: ManifestId,
+		requests: readonly SnapshotBlobRequest[],
+		revalidateManifest: boolean,
+	): Promise<readonly Uint8Array[]> {
+		for (const request of requests) {
+			relativeSafePath("/", request.rootPath);
+			if (!isObjectId(request.blobId)) {
+				throw new SnapshotStoreError("object_missing", "blob ID 无效");
+			}
 		}
 		const manifestPath = await this.findManifestPath(id);
-		const manifest = await this.loadManifest(id);
-		const root = manifest.roots.find((candidate) => candidate.relativeRoot === rootPath);
-		if (root === undefined) {
-			throw new SnapshotStoreError("root_not_found", "manifest 中不存在指定 root");
-		}
-		if (root.state !== "active" || root.treeId === null) {
-			throw new SnapshotStoreError("object_missing", "指定 root 没有可读取的 tree");
-		}
-
+		const manifest = revalidateManifest
+			? await this.loadManifestFromPath(id, manifestPath)
+			: await this.loadManifest(id);
+		const roots = new Map(manifest.roots.map((root) => [root.relativeRoot, root]));
 		const storeDirectory = dirname(dirname(manifestPath));
-		const gitDirectory = this.rootGitDirectory(storeDirectory, root);
 		try {
-			const safeRelativePath = relativePath === undefined ? undefined : relativeSafePath("/", relativePath);
-			if (safeRelativePath === undefined) {
-				const entries = await this.readTreeEntries(gitDirectory, root.treeId);
-				if (!entries.some((entry) => entry.objectId === blobId)) {
-					throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree");
+			const result: Uint8Array[] = [];
+			for (const request of requests) {
+				const root = roots.get(request.rootPath);
+				if (root === undefined) {
+					throw new SnapshotStoreError("root_not_found", "manifest 中不存在指定 root");
 				}
-			} else {
-				const membershipKey = treeBlobMembershipKey(gitDirectory, root.treeId, safeRelativePath);
-				let ownedBlobId = this.treeBlobMembership.get(membershipKey);
-				if (ownedBlobId === undefined) {
-					await this.readTreeEntries(gitDirectory, root.treeId, [safeRelativePath]);
-					ownedBlobId = this.treeBlobMembership.get(membershipKey);
+				if (root.state !== "active" || root.treeId === null) {
+					throw new SnapshotStoreError("object_missing", "指定 root 没有可读取的 tree");
 				}
-				if (ownedBlobId !== blobId) {
-					throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree path");
+				const gitDirectory = this.rootGitDirectory(storeDirectory, root);
+				const safeRelativePath = request.relativePath === undefined
+					? undefined
+					: relativeSafePath("/", request.relativePath);
+				if (safeRelativePath === undefined) {
+					const entries = await this.readTreeEntries(gitDirectory, root.treeId);
+					if (!entries.some((entry) => entry.objectId === request.blobId)) {
+						throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree");
+					}
+				} else {
+					const membershipKey = treeBlobMembershipKey(gitDirectory, root.treeId, safeRelativePath);
+					let ownedBlobId = this.treeBlobMembership.get(membershipKey);
+					if (ownedBlobId === undefined) {
+						await this.readTreeEntries(gitDirectory, root.treeId, [safeRelativePath]);
+						ownedBlobId = this.treeBlobMembership.get(membershipKey);
+					}
+					if (ownedBlobId !== request.blobId) {
+						throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree path");
+					}
 				}
+				result.push(new Uint8Array(await this.readBlobBytes(gitDirectory, request.blobId)));
 			}
-			return new Uint8Array(await this.readBlobBytes(gitDirectory, blobId));
+			if (revalidateManifest) await this.loadManifestFromPath(id, manifestPath);
+			return result;
 		} catch (error) {
 			if (error instanceof SnapshotStoreError) {
 				throw error;
@@ -627,7 +696,7 @@ export class SnapshotStore {
 		gitBacked: boolean,
 		inclusions: readonly string[] | null,
 		exclusions: readonly string[],
-		exactExclusions: readonly string[],
+		exactExclusions: ReadonlySet<string>,
 	): Promise<string[]> {
 		if (inclusions === null) {
 			return [];
@@ -650,7 +719,7 @@ export class SnapshotStore {
 		for (const relativePath of parseNulPaths(output)) {
 			if (
 				exclusions.some((excluded) => isPathAtOrBelow(excluded, relativePath)) ||
-				exactExclusions.includes(relativePath)
+				exactExclusions.has(relativePath)
 			) {
 				continue;
 			}
@@ -679,7 +748,7 @@ export class SnapshotStore {
 		gitBacked: boolean,
 		inclusions: readonly string[] | null,
 		exclusions: readonly string[],
-		exactExclusions: readonly string[],
+		exactExclusions: ReadonlySet<string>,
 	): Promise<void> {
 		const leaves = await this.collectVisibleLeaves(
 			cwd,
@@ -751,7 +820,7 @@ export class SnapshotStore {
 		gitBacked: boolean,
 		inclusions: readonly string[] | null,
 		exclusions: readonly string[],
-		exactExclusions: readonly string[],
+		exactExclusions: ReadonlySet<string>,
 		excludeDeleted = false,
 	): Promise<string[]> {
 		if (inclusions === null) return [];
@@ -785,7 +854,7 @@ export class SnapshotStore {
 		return parseNulPaths(output).filter((relativePath) =>
 			!deletedPaths.has(relativePath) &&
 			!exclusions.some((excluded) => isPathAtOrBelow(excluded, relativePath)) &&
-			!exactExclusions.includes(relativePath));
+			!exactExclusions.has(relativePath));
 	}
 
 	private async collectVisibleLeaves(
@@ -794,7 +863,7 @@ export class SnapshotStore {
 		gitBacked: boolean,
 		inclusions: readonly string[] | null,
 		exclusions: readonly string[],
-		exactExclusions: readonly string[],
+		exactExclusions: ReadonlySet<string>,
 	): Promise<VisibleLeaf[]> {
 		const paths = await this.queryVisibleLeafPaths(
 			cwd,
@@ -1189,7 +1258,7 @@ function ownedArtifactExclusions(
 	roots: readonly DiscoveryRoot[],
 	rootPath: string,
 	exclusions: readonly string[],
-): string[] {
+): ReadonlySet<string> {
 	const result: string[] = [];
 	for (const exclusion of exclusions) {
 		const owner = roots
@@ -1204,7 +1273,7 @@ function ownedArtifactExclusions(
 		}
 		result.push(rootRelativePath(rootPath, exclusion));
 	}
-	return result;
+	return new Set(result);
 }
 
 function rootRelativeScope(rootPath: string, scope: readonly string[] | undefined): string[] | undefined {

package/src/workspace-lock.ts

@@ -116,7 +116,7 @@ export class WorkspaceLock {
 				await rename(candidateDirectory, lockDirectory);
 				published = true;
 			} catch (error) {
-				if (!await pathExists(lockDirectory)) {
+				if (!isPublishCollision(error) && !await pathExists(lockDirectory)) {
 					throw error;
 				}
 			} finally {
@@ -402,6 +402,10 @@ function assertPositive(value: number, name: string): void {
 	}
 }
 
+function isPublishCollision(error: unknown): boolean {
+	return hasErrorCode(error, "EEXIST") || hasErrorCode(error, "ENOTEMPTY");
+}
+
 function hasErrorCode(error: unknown, code: string): error is NodeJS.ErrnoException {
 	return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }