@davideasden/pi-undo 0.1.2 → 0.2.1

package/src/quarantine.ts

@@ -9,6 +9,8 @@ import type { MutationJournal } from "./mutation-journal.ts";
 import type { MutationRecord } from "./model.ts";
 import { assertNoSymlinkEscape, relativeSafePath } from "./path-safety.ts";
 
+const BATCH_FILE_IO_CONCURRENCY = 32;
+
 export interface ReplaceFileRequest {
 	readonly path: string;
 	readonly targetBytes: Uint8Array;
@@ -18,6 +20,14 @@ export interface ReplaceFileRequest {
 	readonly beforeInstall?: () => void | Promise<void>;
 }
 
+interface PreparedFileReplacement {
+	readonly request: ReplaceFileRequest;
+	readonly sourceArtifact: string;
+	readonly targetArtifact: string;
+	readonly targetAbsolutePath: string;
+	readonly intent: MutationRecord;
+}
+
 export interface ReplaceSymlinkRequest {
 	readonly path: string;
 	readonly targetLinkText: string;
@@ -89,7 +99,7 @@ export class QuarantineManager {
 		this.beforeTargetCreate = options.beforeTargetCreate;
 	}
 
-	async replaceFile(request: ReplaceFileRequest): Promise<void> {
+	async replaceFile(request: ReplaceFileRequest): Promise<MutationRecord> {
 		await this.assertWorkspaceIdentity();
 		await this.assertPath(request.path);
 		assertFingerprint(request.sourceFingerprint);
@@ -106,7 +116,12 @@ export class QuarantineManager {
 		const targetArtifact = this.absolute(artifacts.targetArtifact!);
 		await this.beforeTargetCreate?.();
 		await this.assertMutationPaths(request.path, artifacts.targetArtifact!);
-		await writeBytesExclusive(targetArtifact, request.targetBytes, request.targetMode);
+		await writeBytesExclusive(
+			targetArtifact,
+			request.targetBytes,
+			request.targetMode,
+			{ syncDirectory: false },
+		);
 		await this.assertFingerprint(targetArtifact, request.path, request.targetFingerprint);
 		await this.quarantineSource(intent);
 		await request.beforeInstall?.();
@@ -121,15 +136,196 @@ export class QuarantineManager {
 			throw error;
 		}
 		await fsyncDirectory(dirname(this.absolute(request.path)));
-		await this.journal.advance(intent.ordinal, "TARGET_INSTALLED");
 		await this.assertFingerprint(this.absolute(request.path), request.path, request.targetFingerprint);
 		await this.assertArtifactPath(request.path, artifacts.targetArtifact!);
+		const targetStates = await this.journal.advanceMany(
+			intent.ordinal,
+			["SOURCE_QUARANTINED", "SOURCE_VERIFIED", "TARGET_INSTALLED", "TARGET_VERIFIED"],
+		);
 		await unlink(targetArtifact);
-		await fsyncDirectory(dirname(targetArtifact));
-		await this.journal.advance(intent.ordinal, "TARGET_VERIFIED");
+		return targetStates.at(-1)!;
+	}
+
+	async replaceFiles(requests: readonly ReplaceFileRequest[]): Promise<void> {
+		if (requests.length === 0) return;
+		const prepared: Array<Omit<PreparedFileReplacement, "intent">> = [];
+		for (const request of requests) {
+			await this.assertWorkspaceIdentity();
+			await this.assertPath(request.path);
+			assertFingerprint(request.sourceFingerprint);
+			assertFingerprint(request.targetFingerprint);
+			assertMode(request.targetMode);
+			const artifacts = await this.artifactPaths(request.path, true);
+			prepared.push({
+				request,
+				sourceArtifact: artifacts.sourceArtifact,
+				targetArtifact: artifacts.targetArtifact!,
+				targetAbsolutePath: this.absolute(artifacts.targetArtifact!),
+			});
+		}
+		const intents = await this.journal.beginMany(prepared.map(({ request, sourceArtifact, targetArtifact }) => ({
+			kind: "write" as const,
+			path: request.path,
+			sourceArtifact,
+			targetArtifact,
+			sourceFingerprint: request.sourceFingerprint,
+			targetFingerprint: request.targetFingerprint,
+		})));
+		const replacements: PreparedFileReplacement[] = prepared.map((replacement, index) => ({
+			...replacement,
+			intent: intents[index]!,
+		}));
+		const createTarget = async (replacement: PreparedFileReplacement): Promise<void> => {
+			await this.beforeTargetCreate?.();
+			await this.assertMutationPaths(replacement.request.path, replacement.targetArtifact);
+			await writeBytesExclusive(
+				replacement.targetAbsolutePath,
+				replacement.request.targetBytes,
+				replacement.request.targetMode,
+				{ syncDirectory: false },
+			);
+			await this.assertFingerprint(
+				replacement.targetAbsolutePath,
+				replacement.request.path,
+				replacement.request.targetFingerprint,
+			);
+		};
+		if (this.beforeTargetCreate === undefined) {
+			await mapConcurrentFailClosed(replacements, BATCH_FILE_IO_CONCURRENCY, createTarget);
+		} else {
+			for (const replacement of replacements) await createTarget(replacement);
+		}
+		await this.quarantineFileSources(replacements);
+		const installDirectories = new Set<string>();
+		for (const replacement of replacements) {
+			const { request, targetArtifact, targetAbsolutePath } = replacement;
+			await request.beforeInstall?.();
+			await this.assertMutationPaths(request.path, targetArtifact);
+			await this.assertFingerprint(targetAbsolutePath, request.path, request.targetFingerprint);
+			try {
+				await this.linkFile(targetAbsolutePath, this.absolute(request.path));
+			} catch (error) {
+				if (hasErrorCode(error, "EEXIST")) {
+					throw new QuarantineError("external_concurrency", `检测到外部并发修改：${request.path}`);
+				}
+				throw error;
+			}
+			installDirectories.add(dirname(this.absolute(request.path)));
+		}
+		await syncDirectories(installDirectories);
+		for (const { request, targetArtifact, targetAbsolutePath } of replacements) {
+			await this.assertArtifactPath(request.path, targetArtifact);
+			await this.assertSameFileIdentity(this.absolute(request.path), targetAbsolutePath, request.path);
+			await this.assertFingerprint(targetAbsolutePath, request.path, request.targetFingerprint);
+		}
+		const targetRecords = await this.journal.advanceBatch(replacements.map(({ intent }) => ({
+			ordinal: intent.ordinal,
+			states: ["SOURCE_QUARANTINED", "SOURCE_VERIFIED", "TARGET_INSTALLED", "TARGET_VERIFIED"],
+		})));
+		const verifiedByOrdinal = new Map(
+			targetRecords.filter((record) => record.state === "TARGET_VERIFIED")
+				.map((record) => [record.ordinal, record]),
+		);
+		const verifiedRecords: MutationRecord[] = [];
+		for (const replacement of replacements) {
+			const verified = verifiedByOrdinal.get(replacement.intent.ordinal);
+			if (verified === undefined) throw new Error("批量 TARGET_VERIFIED record 缺失");
+			verifiedRecords.push(await this.assertOwnedRecord(verified));
+		}
+		await this.cleanupVerifiedArtifactsBatch(verifiedRecords);
+		await this.journal.advanceBatch(replacements.map(({ intent }) => ({
+			ordinal: intent.ordinal,
+			states: ["CLEANED"],
+		})));
+	}
+
+	private async quarantineFileSources(
+		replacements: readonly { readonly intent: MutationRecord }[],
+	): Promise<void> {
+		const capturedDirectories = new Set<string>();
+		for (const { intent } of replacements) {
+			const original = this.absolute(intent.path);
+			const source = this.absolute(intent.sourceArtifact);
+			await this.assertFingerprint(original, intent.path, intent.sourceFingerprint);
+			if (intent.sourceFingerprint === fingerprintAbsent(intent.path)) {
+				if (await exists(source)) {
+					throw new QuarantineError("unsafe_artifact", `absent source 不应存在 artifact：${intent.path}`);
+				}
+				continue;
+			}
+			const metadata = await lstat(original);
+			if (!metadata.isFile()) throw new QuarantineError("unsafe_artifact", "批量 quarantine 只支持普通文件");
+			await this.beforeSourceCapture?.();
+			await this.assertMutationPaths(intent.path, intent.sourceArtifact);
+			try {
+				await link(original, source);
+			} catch (error) {
+				if (hasErrorCode(error, "EEXIST")) {
+					throw new QuarantineError("external_concurrency", `source artifact 被抢占：${intent.path}`);
+				}
+				throw error;
+			}
+			capturedDirectories.add(dirname(original));
+		}
+		await syncDirectories(capturedDirectories);
+
+		const removedDirectories = new Set<string>();
+		for (const { intent } of replacements) {
+			if (intent.sourceFingerprint === fingerprintAbsent(intent.path)) continue;
+			const original = this.absolute(intent.path);
+			const source = this.absolute(intent.sourceArtifact);
+			await this.beforeSourceRemove?.();
+			await this.assertMutationPaths(intent.path, intent.sourceArtifact);
+			await this.assertFingerprint(source, intent.path, intent.sourceFingerprint);
+			await this.assertFingerprint(original, intent.path, intent.sourceFingerprint);
+			const [sourceMetadata, originalMetadata] = await Promise.all([lstat(source), lstat(original)]);
+			if (sourceMetadata.dev !== originalMetadata.dev || sourceMetadata.ino !== originalMetadata.ino) {
+				throw new QuarantineError("external_concurrency", `source 隔离前原路径已变化：${intent.path}`);
+			}
+			await unlink(original);
+			removedDirectories.add(dirname(original));
+		}
+		await syncDirectories(removedDirectories);
+		for (const { intent } of replacements) {
+			await this.assertFingerprint(this.absolute(intent.path), intent.path, fingerprintAbsent(intent.path));
+			if (intent.sourceFingerprint !== fingerprintAbsent(intent.path)) {
+				await this.assertFingerprint(
+					this.absolute(intent.sourceArtifact),
+					intent.path,
+					intent.sourceFingerprint,
+				);
+			}
+		}
+	}
+
+	private async cleanupVerifiedArtifactsBatch(records: readonly MutationRecord[]): Promise<void> {
+		const directories = new Set<string>();
+		for (const owned of records) {
+			if (owned.state !== "TARGET_VERIFIED") {
+				throw new QuarantineError("unsafe_artifact", "只有 TARGET_VERIFIED mutation 可以批量清理");
+			}
+			await this.assertFingerprint(this.absolute(owned.path), owned.path, owned.targetFingerprint);
+			const source = this.absolute(owned.sourceArtifact);
+			if (await exists(source)) {
+				await this.assertArtifactPath(owned.path, owned.sourceArtifact);
+				await this.assertFingerprint(source, owned.path, owned.sourceFingerprint);
+				await unlink(source);
+				directories.add(dirname(source));
+			}
+			if (owned.targetArtifact !== null) {
+				const target = this.absolute(owned.targetArtifact);
+				if (await exists(target)) {
+					await this.assertArtifactPath(owned.path, owned.targetArtifact);
+					await this.assertFingerprint(target, owned.path, owned.targetFingerprint);
+					await unlink(target);
+					directories.add(dirname(target));
+				}
+			}
+		}
+		await syncDirectories(directories);
 	}
 
-	async replaceSymlink(request: ReplaceSymlinkRequest): Promise<void> {
+	async replaceSymlink(request: ReplaceSymlinkRequest): Promise<MutationRecord> {
 		await this.assertWorkspaceIdentity();
 		await this.assertPath(request.path);
 		assertFingerprint(request.sourceFingerprint);
@@ -157,12 +353,14 @@ export class QuarantineManager {
 			throw error;
 		}
 		await fsyncDirectory(dirname(this.absolute(request.path)));
-		await this.journal.advance(intent.ordinal, "TARGET_INSTALLED");
 		await this.assertFingerprint(this.absolute(request.path), request.path, request.targetFingerprint);
-		await this.journal.advance(intent.ordinal, "TARGET_VERIFIED");
+		return (await this.journal.advanceMany(
+			intent.ordinal,
+			["SOURCE_QUARANTINED", "SOURCE_VERIFIED", "TARGET_INSTALLED", "TARGET_VERIFIED"],
+		)).at(-1)!;
 	}
 
-	async deleteLeaf(request: DeleteLeafRequest): Promise<void> {
+	async deleteLeaf(request: DeleteLeafRequest): Promise<MutationRecord> {
 		await this.assertWorkspaceIdentity();
 		await this.assertPath(request.path);
 		assertFingerprint(request.sourceFingerprint);
@@ -179,9 +377,61 @@ export class QuarantineManager {
 			targetFingerprint: request.targetFingerprint,
 		});
 		await this.quarantineSource(intent);
-		await this.journal.advance(intent.ordinal, "TARGET_INSTALLED");
 		await this.assertFingerprint(this.absolute(request.path), request.path, request.targetFingerprint);
-		await this.journal.advance(intent.ordinal, "TARGET_VERIFIED");
+		return (await this.journal.advanceMany(
+			intent.ordinal,
+			["SOURCE_QUARANTINED", "SOURCE_VERIFIED", "TARGET_INSTALLED", "TARGET_VERIFIED"],
+		)).at(-1)!;
+	}
+
+	async deleteFiles(requests: readonly DeleteLeafRequest[]): Promise<void> {
+		if (requests.length === 0) return;
+		const prepared: Array<{
+			readonly request: DeleteLeafRequest;
+			readonly sourceArtifact: string;
+		}> = [];
+		for (const request of requests) {
+			await this.assertWorkspaceIdentity();
+			await this.assertPath(request.path);
+			assertFingerprint(request.sourceFingerprint);
+			assertFingerprint(request.targetFingerprint);
+			if (request.targetFingerprint !== fingerprintAbsent(request.path)) {
+				throw new QuarantineError("fingerprint_mismatch", `删除目标 fingerprint 不是 absent：${request.path}`);
+			}
+			const artifacts = await this.artifactPaths(request.path, false);
+			prepared.push({ request, sourceArtifact: artifacts.sourceArtifact });
+		}
+		const intents = await this.journal.beginMany(prepared.map(({ request, sourceArtifact }) => ({
+			kind: "delete" as const,
+			path: request.path,
+			sourceArtifact,
+			targetArtifact: null,
+			sourceFingerprint: request.sourceFingerprint,
+			targetFingerprint: request.targetFingerprint,
+		})));
+		const mutations = intents.map((intent) => ({ intent }));
+		await this.quarantineFileSources(mutations);
+		for (const { request } of prepared) {
+			await this.assertFingerprint(this.absolute(request.path), request.path, request.targetFingerprint);
+		}
+		const targetRecords = await this.journal.advanceBatch(intents.map((intent) => ({
+			ordinal: intent.ordinal,
+			states: ["SOURCE_QUARANTINED", "SOURCE_VERIFIED", "TARGET_INSTALLED", "TARGET_VERIFIED"],
+		})));
+		const verifiedRecords: MutationRecord[] = [];
+		for (const record of targetRecords) {
+			if (record.state === "TARGET_VERIFIED") {
+				verifiedRecords.push(await this.assertOwnedRecord(record));
+			}
+		}
+		if (verifiedRecords.length !== intents.length) {
+			throw new Error("批量 delete TARGET_VERIFIED record 缺失");
+		}
+		await this.cleanupVerifiedArtifactsBatch(verifiedRecords);
+		await this.journal.advanceBatch(intents.map((intent) => ({
+			ordinal: intent.ordinal,
+			states: ["CLEANED"],
+		})));
 	}
 
 	async restoreMutation(record: MutationRecord): Promise<void> {
@@ -199,11 +449,20 @@ export class QuarantineManager {
 			await this.assertTargetArtifactAbsent(owned);
 			return;
 		}
+		if (
+			owned.state === "TARGET_VERIFIED" && !sourceWasAbsent && !sourceExists &&
+			originalFingerprint === owned.targetFingerprint
+		) {
+			await this.cleanupRollbackTarget(owned);
+			await this.journal.markRollbackCleaned(owned.ordinal);
+			return;
+		}
 		if (sourceWasAbsent) {
 			if (sourceExists) {
 				throw new QuarantineError("unsafe_artifact", `absent source 不应存在 artifact：${owned.path}`);
 			}
 			if (originalFingerprint === owned.targetFingerprint) {
+				await this.assertRollbackTargetOwned(owned);
 				await this.assertFingerprint(original, owned.path, owned.targetFingerprint);
 				await unlink(original);
 				await fsyncDirectory(dirname(original));
@@ -234,6 +493,7 @@ export class QuarantineManager {
 			originalFingerprint === owned.targetFingerprint
 		) {
 			await this.assertMutationPaths(owned.path, owned.sourceArtifact);
+			await this.assertRollbackTargetOwned(owned);
 			await this.assertFingerprint(original, owned.path, owned.targetFingerprint);
 			await unlink(original);
 			await fsyncDirectory(dirname(original));
@@ -272,6 +532,35 @@ export class QuarantineManager {
 
 	async rollForwardMutation(record: MutationRecord): Promise<void> {
 		let owned = await this.assertOwnedRecord(record);
+		if (owned.state === "INTENT") {
+			const source = this.absolute(owned.sourceArtifact);
+			const original = this.absolute(owned.path);
+			const originalFingerprint = await fingerprintLeaf(original, owned.path);
+			if (owned.sourceFingerprint === fingerprintAbsent(owned.path)) {
+				if (await exists(source) || originalFingerprint !== owned.sourceFingerprint) {
+					throw new QuarantineError("external_concurrency", `INTENT absent source 现场冲突：${owned.path}`);
+				}
+			} else {
+				await this.assertFingerprint(source, owned.path, owned.sourceFingerprint);
+				if (originalFingerprint === owned.sourceFingerprint) {
+					const [sourceMetadata, originalMetadata] = await Promise.all([lstat(source), lstat(original)]);
+					if (
+					sourceMetadata.isFile() &&
+					(sourceMetadata.dev !== originalMetadata.dev || sourceMetadata.ino !== originalMetadata.ino)
+					) {
+						throw new QuarantineError("external_concurrency", `INTENT source inode 冲突：${owned.path}`);
+					}
+					await unlink(original);
+					await fsyncDirectory(dirname(original));
+				} else if (originalFingerprint !== fingerprintAbsent(owned.path)) {
+					throw new QuarantineError("external_concurrency", `INTENT original 现场冲突：${owned.path}`);
+				}
+			}
+			owned = (await this.journal.advanceMany(
+				owned.ordinal,
+				["SOURCE_QUARANTINED", "SOURCE_VERIFIED"],
+			)).at(-1)!;
+		}
 		if (owned.state === "SOURCE_QUARANTINED") {
 			if (owned.sourceFingerprint === fingerprintAbsent(owned.path)) {
 				if (await exists(this.absolute(owned.sourceArtifact))) {
@@ -323,9 +612,15 @@ export class QuarantineManager {
 	async cleanupMutation(record: MutationRecord): Promise<void> {
 		const owned = await this.assertOwnedRecord(record);
 		if (owned.state === "CLEANED") return;
+		await this.cleanupVerifiedArtifacts(owned);
+		await this.journal.advance(owned.ordinal, "CLEANED");
+	}
+
+	private async cleanupVerifiedArtifacts(owned: MutationRecord): Promise<void> {
 		if (owned.state !== "TARGET_VERIFIED") {
 			throw new QuarantineError("unsafe_artifact", "只有 TARGET_VERIFIED mutation 可以清理");
 		}
+		await this.assertFingerprint(this.absolute(owned.path), owned.path, owned.targetFingerprint);
 		const source = this.absolute(owned.sourceArtifact);
 		if (await exists(source)) {
 			await this.assertArtifactPath(owned.path, owned.sourceArtifact);
@@ -342,7 +637,6 @@ export class QuarantineManager {
 				await fsyncDirectory(dirname(target));
 			}
 		}
-		await this.journal.advance(owned.ordinal, "CLEANED");
 	}
 
 	async inspectArtifacts(): Promise<readonly QuarantineArtifact[]> {
@@ -373,9 +667,7 @@ export class QuarantineManager {
 			if (await exists(source)) {
 				throw new QuarantineError("unsafe_artifact", `absent source 不应存在 artifact：${record.path}`);
 			}
-			await this.journal.advance(record.ordinal, "SOURCE_QUARANTINED");
 			await this.assertFingerprint(original, record.path, record.sourceFingerprint);
-			await this.journal.advance(record.ordinal, "SOURCE_VERIFIED");
 			return;
 		}
 		const metadata = await lstat(original);
@@ -409,10 +701,7 @@ export class QuarantineManager {
 			}
 		}
 		await unlink(original);
-		await fsyncDirectory(dirname(original));
-		await this.journal.advance(record.ordinal, "SOURCE_QUARANTINED");
 		await this.assertFingerprint(source, record.path, record.sourceFingerprint);
-		await this.journal.advance(record.ordinal, "SOURCE_VERIFIED");
 	}
 
 	private async cleanupRollbackTarget(record: MutationRecord): Promise<void> {
@@ -484,6 +773,27 @@ export class QuarantineManager {
 		}
 	}
 
+	private async assertRollbackTargetOwned(owned: MutationRecord): Promise<void> {
+		if (owned.targetArtifact === null) return;
+		const target = this.absolute(owned.targetArtifact);
+		if (!await exists(target)) return;
+		await this.assertArtifactPath(owned.path, owned.targetArtifact);
+		await this.assertFingerprint(target, owned.path, owned.targetFingerprint);
+		await this.assertSameFileIdentity(this.absolute(owned.path), target, owned.path);
+	}
+
+	private async assertSameFileIdentity(original: string, artifact: string, path: string): Promise<void> {
+		const [originalMetadata, artifactMetadata] = await Promise.all([lstat(original), lstat(artifact)]);
+		if (
+			!originalMetadata.isFile() ||
+			!artifactMetadata.isFile() ||
+			originalMetadata.dev !== artifactMetadata.dev ||
+			originalMetadata.ino !== artifactMetadata.ino
+		) {
+			throw new QuarantineError("external_concurrency", `target artifact ownership 已变化：${path}`);
+		}
+	}
+
 	private async assertFingerprint(absolutePath: string, logicalPath: string, expected: string): Promise<void> {
 		const actual = await fingerprintLeaf(absolutePath, logicalPath);
 		if (actual !== expected) {
@@ -576,6 +886,36 @@ function immutableMutation(record: MutationRecord): string {
 	});
 }
 
+async function mapConcurrentFailClosed<T>(
+	values: readonly T[],
+	concurrency: number,
+	operation: (value: T) => Promise<void>,
+): Promise<void> {
+	let nextIndex = 0;
+	let failed = false;
+	let failure: unknown;
+	async function worker(): Promise<void> {
+		while (!failed && nextIndex < values.length) {
+			const index = nextIndex;
+			nextIndex += 1;
+			try {
+				await operation(values[index]!);
+			} catch (error) {
+				if (!failed) failure = error;
+				failed = true;
+			}
+		}
+	}
+	await Promise.all(
+		Array.from({ length: Math.min(concurrency, values.length) }, () => worker()),
+	);
+	if (failed) throw failure;
+}
+
+async function syncDirectories(directories: ReadonlySet<string>): Promise<void> {
+	for (const directory of directories) await fsyncDirectory(directory);
+}
+
 async function exists(path: string): Promise<boolean> {
 	try {
 		await lstat(path);