Skip to content

Commit 25631c3

Browse files
josephv123maria-rcksjuliusmarminge
authored
fix(server): new worktrees refresh their index once, so captures and status stop re-hashing every file (#21341)
Co-authored-by: maria-rcks <[email protected]> Co-authored-by: Julius Marminge <[email protected]>
1 parent 24e7747 commit 25631c3

2 files changed

Lines changed: 132 additions & 0 deletions

File tree

‎apps/server/src/vcs/GitVcsDriverCore.test.ts‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ import * as Exit from "effect/Exit";
1313
import * as FileSystem from "effect/FileSystem";
1414
import * as Fiber from "effect/Fiber";
1515
import * as Layer from "effect/Layer";
16+
import * as Option from "effect/Option";
1617
import * as Path from "effect/Path";
1718
import * as Queue from "effect/Queue";
1819
import * as PlatformError from "effect/PlatformError";
@@ -4678,6 +4679,79 @@ it.layer(layerTest)("GitVcsDriver core integration", (it) => {
46784679
assert.isTrue(Result.isSuccess(result), "worktree creation failed in the hook");
46794680
}),
46804681
);
4682+
it.effect("refreshes a new worktree's index once its checkout second is over", () =>
4683+
Effect.gen(function* () {
4684+
const cwd = yield* makeTmpDir();
4685+
const { initialBranch } = yield* initRepoWithCommit(cwd);
4686+
const fs = yield* FileSystem.FileSystem;
4687+
const path = yield* Path.Path;
4688+
const driver = yield* GitVcsDriver.GitVcsDriver;
4689+
for (let file = 0; file < 50; file++) {
4690+
yield* writeTextFile(cwd, `src/file-${file}.txt`, `contents ${file}\n`);
4691+
}
4692+
yield* git(cwd, ["add", "."]);
4693+
yield* git(cwd, ["commit", "-m", "more files"]);
4694+
const worktreePath = path.join(yield* makeTmpDir("git-worktrees-"), "fresh");
4695+
4696+
// The refresh waits on the clock that stamps the files.
4697+
yield* TestClock.withLive(
4698+
driver.createWorktree({
4699+
cwd,
4700+
path: worktreePath,
4701+
refName: initialBranch,
4702+
newRefName: "feature/fresh",
4703+
}),
4704+
);
4705+
4706+
// Git re-reads every entry stamped in the index's own second or later.
4707+
const indexPath = path.resolve(
4708+
worktreePath,
4709+
yield* git(worktreePath, ["rev-parse", "--git-path", "index"]),
4710+
);
4711+
const indexMtime = Option.getOrThrow((yield* fs.stat(indexPath)).mtime);
4712+
const indexSecond = Math.floor(indexMtime.getTime() / 1000);
4713+
const entrySeconds = Array.from(
4714+
(yield* git(worktreePath, ["ls-files", "--debug"])).matchAll(/^ {2}mtime: (\d+):/gm),
4715+
([, seconds]) => Number(seconds),
4716+
);
4717+
assert.equal(entrySeconds.length, 51);
4718+
assert.deepEqual(
4719+
entrySeconds.filter((seconds) => seconds >= indexSecond),
4720+
[],
4721+
);
4722+
}),
4723+
);
4724+
it.effect("returns the worktree when its index refresh fails", () =>
4725+
Effect.gen(function* () {
4726+
const cwd = yield* makeTmpDir();
4727+
const { initialBranch } = yield* initRepoWithCommit(cwd);
4728+
const fs = yield* FileSystem.FileSystem;
4729+
const path = yield* Path.Path;
4730+
const driver = yield* GitVcsDriver.GitVcsDriver;
4731+
// Something else takes the new worktree's index lock as soon as its checkout ends.
4732+
yield* writeTextFile(
4733+
cwd,
4734+
".git/hooks/post-checkout",
4735+
'#!/bin/sh\ntouch "$(git rev-parse --git-path index).lock"\n',
4736+
);
4737+
yield* fs.chmod(path.join(cwd, ".git/hooks/post-checkout"), 0o755);
4738+
const worktreePath = path.join(yield* makeTmpDir("git-worktrees-"), "locked");
4739+
4740+
const created = yield* driver.createWorktree({
4741+
cwd,
4742+
path: worktreePath,
4743+
refName: initialBranch,
4744+
newRefName: "feature/locked",
4745+
});
4746+
4747+
assert.equal(created.worktree.path, worktreePath);
4748+
const indexPath = path.resolve(
4749+
worktreePath,
4750+
yield* git(worktreePath, ["rev-parse", "--git-path", "index"]),
4751+
);
4752+
assert.isTrue(yield* fs.exists(`${indexPath}.lock`));
4753+
}),
4754+
);
46814755
it.effect.each(["commit", "short-commit", "tag", "revision"] as const)(
46824756
"creates a worktree from a %s without recording it as a PR base",
46834757
(kind) =>

‎apps/server/src/vcs/GitVcsDriverCore.ts‎

Lines changed: 58 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,7 @@ const branchBaseConfigKey = (branch: string) => `branch.${branch}.t3-merge-base`
6565
const legacyBranchBaseConfigKey = (branch: string) => `branch.${branch}.gh-merge-base`;
6666
const gitProcesses = Semaphore.makeUnsafe(8);
6767
const backgroundGitProcesses = Semaphore.makeUnsafe(2);
68+
const WORKTREE_INDEX_REFRESH_TIMEOUT_MS = Duration.toMillis(Duration.minutes(5));
6869
const WORKTREE_REMOVE_TIMEOUT_MS = Duration.toMillis(Duration.minutes(5));
6970
const DEFAULT_MAX_OUTPUT_BYTES = 1_000_000;
7071
const OUTPUT_TRUNCATED_MARKER = "\n\n[truncated]";
@@ -4247,6 +4248,52 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
42474248
},
42484249
);
42494250

4251+
// A checkout stamps most files in the second it writes the index, and Git re-reads every file
4252+
// stamped in the index's own second or later ("racily clean") on each status, diff and add.
4253+
// T3's own git calls never rewrite a worktree's index, so refresh it once.
4254+
const refreshNewWorktreeIndex = Effect.fn("refreshNewWorktreeIndex")(function* (
4255+
worktreePath: string,
4256+
) {
4257+
const indexPath = path.resolve(
4258+
worktreePath,
4259+
(yield* runGitStdout("GitVcsDriver.createWorktree.indexPath", worktreePath, [
4260+
"rev-parse",
4261+
"--git-path",
4262+
"index",
4263+
])).trim(),
4264+
);
4265+
const indexSecond = fileSystem.stat(indexPath).pipe(
4266+
Effect.map(({ mtime }) => Option.map(mtime, (date) => Math.floor(date.getTime() / 1000))),
4267+
Effect.orElseSucceed(() => Option.none<number>()),
4268+
);
4269+
// Older Git (such as 2.30) skips the write when racy entries merely check out clean.
4270+
// A refresh re-reads every checked-out file, so allow five minutes outside shared permits.
4271+
const refresh = runGit(
4272+
"GitVcsDriver.createWorktree.refreshIndex",
4273+
worktreePath,
4274+
["update-index", "-q", "--refresh", "--force-write-index"],
4275+
{ timeoutMs: WORKTREE_INDEX_REFRESH_TIMEOUT_MS },
4276+
);
4277+
const checkoutSecond = yield* indexSecond;
4278+
yield* refresh;
4279+
const refreshedSecond = yield* indexSecond;
4280+
if (
4281+
Option.isNone(checkoutSecond) ||
4282+
Option.isNone(refreshedSecond) ||
4283+
refreshedSecond.value > checkoutSecond.value
4284+
) {
4285+
return;
4286+
}
4287+
// The refresh finished within the checkout's second, so its index is just as racy. Wait that
4288+
// second out (file timestamps can trail the clock by a kernel tick) and refresh again. Two
4289+
// seconds or more means this clock does not match the file timestamps, as on a share stamped
4290+
// by another machine, so it cannot say when that second ends.
4291+
const delay = (checkoutSecond.value + 1) * 1000 + 50 - (yield* Clock.currentTimeMillis);
4292+
if (delay >= 2_000) return;
4293+
if (delay > 0) yield* Effect.sleep(Duration.millis(delay));
4294+
yield* refresh;
4295+
});
4296+
42504297
const createWorktree: GitVcsDriver.GitVcsDriver["Service"]["createWorktree"] = Effect.fn(
42514298
"createWorktree",
42524299
)(function* (input, options) {
@@ -4444,6 +4491,17 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
44444491
);
44454492
}
44464493

4494+
// Before the worktree is returned: a refresh holds index.lock, so running it in the
4495+
// background would race the setup script's and the agent's own git commands.
4496+
yield* refreshNewWorktreeIndex(worktreePath).pipe(
4497+
Effect.catch((cause) =>
4498+
Effect.logWarning(
4499+
"worktree index refresh failed; Git keeps re-reading its files until the index is rewritten",
4500+
{ worktreePath, cause },
4501+
),
4502+
),
4503+
);
4504+
44474505
if (newRefName && base) {
44484506
yield* Effect.gen(function* () {
44494507
yield* writeConfigValue({

0 commit comments

Comments
 (0)