fix(studio-server): a claim waits for a changing file's first copy, so its edit stays undoable (#7497)

This commit is contained in:
Miguel Ángel
2026-11-10 12:34:52 +00:00
committed by GitHub
parent ad1a5eab29
commit 248f56fbaa
2 changed files with 91 additions and 22 deletions
@@ -4,7 +4,7 @@ import { open as openFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { basename, join } from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";
import { fileContentVersion, hashOfVersion } from "../helpers/fileVersion";
import { fileContentVersion, hashOfVersion, recordFileWriteReceipt } from "../helpers/fileVersion";
import { SETTLE_MS } from "./blobStore";
import { START, type HistoryWho } from "./historyLog";
import { openProjectHistory, type ProjectHistory } from "./projectHistory";
@@ -172,4 +172,37 @@ describe("a file still being written when the history first opens", () => {
await history.step("back", you);
expect(existsSync(media)).toBe(true);
});
it("waits for that first copy when claimed, so the claim keeps the edit and undo restores the copy", async () => {
const projectDir = tempDir("hf-history-project-");
const historyRoot = tempDir("hf-history-root-");
const media = join(projectDir, "media.txt");
writeFileSync(media, "recorded");
changing.set("media.txt", 2);
const history = await openProjectHistory({ projectDir, historyRoot });
cleanup.push(() => history.close());
writeFileSync(media, "edited");
recordFileWriteReceipt(media, {
path: "media.txt",
version: fileContentVersion("edited"),
writeToken: "studio",
overwrote: "recorded",
});
const edit = await history.claim(you, "Edited", ["media.txt"]);
expect(history.peek(START)).toHaveProperty("media.txt");
expect(history.list().map((entry) => entry.label)).toEqual(["Edited"]);
expect((await history.undo(edit!.id, { who: you })).ok).toBe(true);
expect(readFileSync(media, "utf-8")).toBe("recorded");
});
it("holds a claim for one retry only, when the file is still changing after it", async () => {
const projectDir = tempDir("hf-history-project-");
const historyRoot = tempDir("hf-history-root-");
writeFileSync(join(projectDir, "media.txt"), "recorded");
changing.set("media.txt", 4);
const history = await openProjectHistory({ projectDir, historyRoot });
cleanup.push(() => history.close());
expect(await history.claim(you, "Edited", ["media.txt"])).toBeNull();
expect(history.peek(START)).not.toHaveProperty("media.txt");
});
});
@@ -216,6 +216,13 @@ const statKey = (file: { size: number; mtimeMs: number; ctimeMs: number }, swept
type Copied = { hash: string } | "gone" | "changing";
const ADOPT_RETRY_AT_MOST_MS = 30_000;
/** Owed until a whole copy is recorded, the file is gone or history closes; retryNow waits for a fresh try. */
interface Adoption {
firstTry: Promise<unknown>;
ended: Promise<void>;
retryNow(): Promise<void>;
}
const FIRST_COPY_SLOTS_IN_PROCESS = 4;
let firstCopiesRunning = 0;
const firstCopiesWaiting: (() => void)[] = [];
@@ -394,7 +401,7 @@ class Engine {
outside: Group | null = null;
/** A coalescing claim, open until another key, its idle timer, an operation, a window, or another write. */
claimed: { group: Group; key: string; timer?: NodeJS.Timeout } | null = null;
adopting = new Map<string, Promise<void>>();
adopting = new Map<string, Adoption>();
/** Per path and hash an API write left, the hash of the bytes it replaced, until walked or written past. */
overwritten = new Map<string, Map<string, string>>();
stopHearing: (() => void) | undefined;
@@ -614,10 +621,11 @@ class Engine {
}
adoptMediaInBackground(files: ListedFile[], sweptAt: number): void {
let copied = Promise.resolve();
let turn: Promise<unknown> = Promise.resolve();
for (const file of files) {
copied = copied.then(() => this.adopt(file, sweptAt));
this.adopting.set(file.path, copied);
const adoption = this.adopt(file, sweptAt, turn);
turn = adoption.firstTry;
this.adopting.set(file.path, adoption);
}
this.saveAdopting();
}
@@ -629,32 +637,58 @@ class Engine {
replaceFileAtomically(file, JSON.stringify([...this.adopting.keys()]), 0o644);
}
async adopt(file: ListedFile, sweptAt: number, tries = 0) {
/** A file still changing stays named until a whole copy of it lands; the next open retries it. */
adopt(file: ListedFile, sweptAt: number, turn: Promise<unknown>): Adoption {
let asked: Array<() => void> = [];
let wake = () => {};
const tryOnce = async () => {
const served = asked;
asked = [];
const tried = await this.tryAdopting(file, sweptAt);
for (const answer of served) answer();
return tried === "over";
};
const firstTry = turn.then(tryOnce);
const ended = firstTry.then(async (done) => {
for (let tries = 1; !done && !this.closing; tries += 1) {
const ms = Math.min(SETTLE_MS * 2 ** tries, ADOPT_RETRY_AT_MOST_MS);
if (!asked.length)
await new Promise<void>((retry) => {
const timer = setTimeout(retry, ms);
timer.unref?.();
wake = () => {
clearTimeout(timer);
retry();
};
});
done = this.closing !== undefined || (await tryOnce());
}
});
const retryNow = () => {
const next = new Promise<void>((answer) => asked.push(answer));
wake();
return Promise.race([ended, next]);
};
return { firstTry, ended, retryNow };
}
async tryAdopting(file: ListedFile, sweptAt: number): Promise<"over" | "changing"> {
try {
if (this.whereFolder() !== "here") return;
if (this.whereFolder() !== "here") return "over";
const copied = await this.storeIfPresent(file.path);
await this.queue(async () => {
return await this.queue(async () => {
// Still named for the next open until recorded, so a failed record is never logged as added.
if ((await this.recordAdopted(file, sweptAt, copied)) === "changing")
return this.adoptLater(file, sweptAt, tries + 1);
if ((await this.recordAdopted(file, sweptAt, copied)) === "changing") return "changing";
this.adopting.delete(file.path);
this.saveAdopting();
return "over";
});
} catch (error) {
if (!(error instanceof HistoryClosedError)) this.options.onError?.(error);
return "over";
}
}
/** A file still changing stays named until a whole copy of it lands; the next open retries it. */
adoptLater(file: ListedFile, sweptAt: number, tries: number): void {
if (this.closing) return;
const timer = setTimeout(
() => void this.adopt(file, sweptAt, tries),
Math.min(SETTLE_MS * 2 ** tries, ADOPT_RETRY_AT_MOST_MS),
);
timer.unref?.();
}
async recordAdopted(file: ListedFile, sweptAt: number, first: Copied): Promise<Copied> {
if (typeof first === "string" || this.whereFolder() !== "here") return first;
// A prune that ran while this copy waited for the queue may have taken its bytes.
@@ -1376,7 +1410,7 @@ class Engine {
options.exclusive === true,
),
claim: async (who, label, paths, options = {}) => {
await Promise.all(paths.map((path) => this.adopting.get(this.logPath(path))));
await Promise.all(paths.map((path) => this.adopting.get(this.logPath(path))?.retryNow()));
return this.queue(() => this.claimNow(who, label, paths, options));
},
noteChange: (path) => {
@@ -1447,7 +1481,9 @@ class Engine {
close: () =>
(this.closing ??= (async () => {
// A copy cut short would leave its media out of the baseline, so a change made while closed is lost.
await Promise.all(this.adopting.values());
const owed = [...this.adopting.values()];
for (const adoption of owed) void adoption.retryNow();
await Promise.all(owed.map((adoption) => adoption.ended));
if (this.notedTimer) clearTimeout(this.notedTimer);
this.stopHearing?.();
const settled = this.queue(() => this.settleAll());