Skip to content

Commit 51cb848

Browse files
fix(server): a zero Git fetch interval also stops the fetch on window focus (pingdotgg#13253)
Co-authored-by: Julius Marminge <[email protected]>
1 parent 6d266ea commit 51cb848

5 files changed

Lines changed: 180 additions & 94 deletions

File tree

‎apps/server/src/git/GitManager.test.ts‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -902,6 +902,12 @@ it.layer(layerGitManagerTest)("GitManager", (it) => {
902902
);
903903
const broadcasterContext = yield* Layer.build(
904904
VcsStatusBroadcaster.layer.pipe(
905+
Layer.provide(
906+
Layer.succeed(
907+
VcsStatusBroadcaster.VcsAutomaticFetchInterval,
908+
Effect.succeed(Duration.seconds(1)),
909+
),
910+
),
905911
Layer.provide(
906912
Layer.succeed(
907913
GitWorkflowService.GitWorkflowService,
@@ -927,10 +933,7 @@ it.layer(layerGitManagerTest)("GitManager", (it) => {
927933
let snapshotCount = 0;
928934
for (const cwd of [repoDir, worktreeDir]) {
929935
yield* Stream.runForEach(
930-
broadcaster.streamStatus(
931-
{ cwd, includeRemote: false },
932-
{ automaticRemoteRefreshInterval: Effect.succeed(Duration.seconds(1)) },
933-
),
936+
broadcaster.streamStatus({ cwd, includeRemote: false }),
934937
(event) => {
935938
if (
936939
cwd === worktreeDir &&

‎apps/server/src/server.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -401,6 +401,7 @@ const layerVcs = Layer.empty.pipe(
401401
Layer.provideMerge(
402402
VcsStatusBroadcaster.layer.pipe(
403403
Layer.provide(layerGitWorkflow),
404+
Layer.provide(VcsStatusBroadcaster.layerAutomaticFetchInterval),
404405
// The orchestration runtime also consumes the broadcaster (run
405406
// finalization), so the policy cannot read the store from the runtime's
406407
// output.

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

Lines changed: 133 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -79,11 +79,18 @@ function layerTestFor(state: {
7979
remoteInvalidationCalls: number;
8080
remoteStatusRefreshUpstreamValues?: Array<boolean | undefined>;
8181
backgroundWorkEnabled?: boolean;
82+
automaticFetchInterval?: Effect.Effect<Duration.Duration>;
8283
beforeRemoteStatus?: Effect.Effect<void>;
8384
}) {
8485
return VcsStatusBroadcaster.layer.pipe(
8586
Layer.provideMerge(NodeServices.layer),
8687
Layer.provide(layerBackgroundPolicy(() => state.backgroundWorkEnabled !== false)),
88+
Layer.provide(
89+
Layer.succeed(
90+
VcsStatusBroadcaster.VcsAutomaticFetchInterval,
91+
state.automaticFetchInterval ?? Effect.succeed(Duration.seconds(30)),
92+
),
93+
),
8794
Layer.provide(
8895
Layer.mock(GitWorkflowService.GitWorkflowService)({
8996
localStatus: () =>
@@ -212,6 +219,93 @@ describe("VcsStatusBroadcaster", () => {
212219
},
213220
);
214221

222+
it.effect.each(["status refresh", "initial stream"] as const)(
223+
"%s updates local and PR status without fetching or pulling when the interval is zero",
224+
(entryPoint) => {
225+
let interval = Duration.zero;
226+
let pullCalls = 0;
227+
let invalidations = 0;
228+
const refreshUpstreamValues: Array<boolean | undefined> = [];
229+
const local: VcsStatusLocalResult = {
230+
...baseLocalStatus,
231+
isDefaultRef: true,
232+
refName: "main",
233+
};
234+
const remote = { ...remoteStatusWithPr, behindCount: 2 };
235+
const testLayer = VcsStatusBroadcaster.layer.pipe(
236+
Layer.provideMerge(NodeServices.layer),
237+
Layer.provide(
238+
Layer.succeed(
239+
VcsStatusBroadcaster.VcsAutomaticFetchInterval,
240+
Effect.sync(() => interval),
241+
),
242+
),
243+
Layer.provide(layerBackgroundPolicy(() => true)),
244+
Layer.provide(
245+
Layer.succeed(VcsStatusBroadcaster.VcsAutoPullPolicy, {
246+
isEnabled: () => Effect.succeed(true),
247+
}),
248+
),
249+
Layer.provide(
250+
Layer.mock(GitWorkflowService.GitWorkflowService)({
251+
localStatus: () => Effect.succeed(local),
252+
remoteStatus: (_input, options) =>
253+
Effect.sync(() => {
254+
refreshUpstreamValues.push(options?.refreshUpstream);
255+
return remote;
256+
}),
257+
invalidateLocalStatus: () => Effect.void,
258+
invalidateRemoteStatus: () => Effect.void,
259+
invalidateStatus: () =>
260+
Effect.sync(() => {
261+
invalidations += 1;
262+
}),
263+
pullCurrentBranch: () =>
264+
Effect.sync(() => {
265+
pullCalls += 1;
266+
return { status: "pulled" as const, refName: "main", upstreamRef: "origin/main" };
267+
}),
268+
}),
269+
),
270+
);
271+
272+
return Effect.gen(function* () {
273+
const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
274+
if (entryPoint === "status refresh") {
275+
const status = yield* broadcaster.refreshStatus("/repo");
276+
assert.deepStrictEqual(status, { ...local, ...remote });
277+
assert.equal(invalidations, 1);
278+
} else {
279+
const update = yield* broadcaster.streamStatus({ cwd: "/repo" }).pipe(
280+
Stream.filter(
281+
(event) =>
282+
event._tag === "remoteUpdated" ||
283+
(event._tag === "snapshot" && event.remote !== null),
284+
),
285+
Stream.runHead,
286+
);
287+
assert.deepStrictEqual(Option.getOrThrow(update), {
288+
_tag: "remoteUpdated",
289+
remote,
290+
});
291+
assert.deepStrictEqual(yield* broadcaster.getStatus({ cwd: "/repo" }), {
292+
...local,
293+
...remote,
294+
});
295+
}
296+
assert.deepStrictEqual(refreshUpstreamValues, [false]);
297+
assert.equal(pullCalls, 0);
298+
299+
if (entryPoint === "status refresh") {
300+
interval = Duration.minutes(1);
301+
yield* broadcaster.refreshStatus("/repo");
302+
assert.deepStrictEqual(refreshUpstreamValues, [false, true, false]);
303+
assert.equal(pullCalls, 1);
304+
}
305+
}).pipe(Effect.provide(testLayer));
306+
},
307+
);
308+
215309
it.effect.each([
216310
{ refresh: "explicit", failure: "pull" },
217311
{ refresh: "explicit", failure: "post-pull remote read" },
@@ -778,6 +872,7 @@ describe("VcsStatusBroadcaster", () => {
778872
currentRemoteStatus: remoteStatusWithPr,
779873
localStatusCalls: 0,
780874
remoteStatusCalls: 0,
875+
automaticFetchInterval: Effect.succeed(Duration.zero),
781876
localInvalidationCalls: 0,
782877
remoteInvalidationCalls: 0,
783878
remoteStatusRefreshUpstreamValues: [] as Array<boolean | undefined>,
@@ -788,21 +883,15 @@ describe("VcsStatusBroadcaster", () => {
788883
const scope = yield* Scope.make();
789884
const snapshotDeferred = yield* Deferred.make<VcsStatusStreamEvent>();
790885
const remoteUpdatedDeferred = yield* Deferred.make<VcsStatusStreamEvent>();
791-
yield* Stream.runForEach(
792-
broadcaster.streamStatus(
793-
{ cwd: "/repo" },
794-
{ automaticRemoteRefreshInterval: Effect.succeed(Duration.zero) },
795-
),
796-
(event) => {
797-
if (event._tag === "snapshot") {
798-
return Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore);
799-
}
800-
if (event._tag === "remoteUpdated") {
801-
return Deferred.succeed(remoteUpdatedDeferred, event).pipe(Effect.ignore);
802-
}
803-
return Effect.void;
804-
},
805-
).pipe(Effect.forkIn(scope));
886+
yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) => {
887+
if (event._tag === "snapshot") {
888+
return Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore);
889+
}
890+
if (event._tag === "remoteUpdated") {
891+
return Deferred.succeed(remoteUpdatedDeferred, event).pipe(Effect.ignore);
892+
}
893+
return Effect.void;
894+
}).pipe(Effect.forkIn(scope));
806895

807896
const snapshot = yield* Deferred.await(snapshotDeferred);
808897
const remoteUpdated = yield* Deferred.await(remoteUpdatedDeferred);
@@ -846,6 +935,12 @@ describe("VcsStatusBroadcaster", () => {
846935
let firstRemoteAttemptDeferred: Deferred.Deferred<void> | null = null;
847936
const layerTest = VcsStatusBroadcaster.layer.pipe(
848937
Layer.provideMerge(NodeServices.layer),
938+
Layer.provide(
939+
Layer.succeed(
940+
VcsStatusBroadcaster.VcsAutomaticFetchInterval,
941+
Effect.succeed(Duration.zero),
942+
),
943+
),
849944
Layer.provide(layerBackgroundPolicy(() => true)),
850945
Layer.provide(
851946
Layer.mock(GitWorkflowService.GitWorkflowService)({
@@ -893,15 +988,10 @@ describe("VcsStatusBroadcaster", () => {
893988
const scope = yield* Scope.make();
894989
firstRemoteAttemptDeferred = yield* Deferred.make<void>();
895990
const remoteUpdatedDeferred = yield* Deferred.make<VcsStatusStreamEvent>();
896-
yield* Stream.runForEach(
897-
broadcaster.streamStatus(
898-
{ cwd: privateCwd },
899-
{ automaticRemoteRefreshInterval: Effect.succeed(Duration.zero) },
900-
),
901-
(event) =>
902-
event._tag === "remoteUpdated"
903-
? Deferred.succeed(remoteUpdatedDeferred, event).pipe(Effect.ignore)
904-
: Effect.void,
991+
yield* Stream.runForEach(broadcaster.streamStatus({ cwd: privateCwd }), (event) =>
992+
event._tag === "remoteUpdated"
993+
? Deferred.succeed(remoteUpdatedDeferred, event).pipe(Effect.ignore)
994+
: Effect.void,
905995
).pipe(Effect.forkIn(scope));
906996

907997
yield* Deferred.await(firstRemoteAttemptDeferred);
@@ -955,6 +1045,7 @@ describe("VcsStatusBroadcaster", () => {
9551045
currentRemoteStatus: baseRemoteStatus,
9561046
localStatusCalls: 0,
9571047
remoteStatusCalls: 0,
1048+
automaticFetchInterval: Effect.succeed(Duration.minutes(1)),
9581049
localInvalidationCalls: 0,
9591050
remoteInvalidationCalls: 0,
9601051
};
@@ -964,15 +1055,10 @@ describe("VcsStatusBroadcaster", () => {
9641055
yield* broadcaster.getStatus({ cwd: "/repo" });
9651056
const scope = yield* Scope.make();
9661057
const snapshotDeferred = yield* Deferred.make<VcsStatusStreamEvent>();
967-
yield* Stream.runForEach(
968-
broadcaster.streamStatus(
969-
{ cwd: "/repo" },
970-
{ automaticRemoteRefreshInterval: Effect.succeed(Duration.minutes(1)) },
971-
),
972-
(event) =>
973-
event._tag === "snapshot"
974-
? Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore)
975-
: Effect.void,
1058+
yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) =>
1059+
event._tag === "snapshot"
1060+
? Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore)
1061+
: Effect.void,
9761062
).pipe(Effect.forkIn(scope));
9771063

9781064
yield* Deferred.await(snapshotDeferred);
@@ -1000,6 +1086,7 @@ describe("VcsStatusBroadcaster", () => {
10001086
currentRemoteStatus: initialRemote as VcsStatusRemoteResult | null,
10011087
localStatusCalls: 0,
10021088
remoteStatusCalls: 0,
1089+
automaticFetchInterval: Effect.succeed(Duration.minutes(1)),
10031090
localInvalidationCalls: 0,
10041091
remoteInvalidationCalls: 0,
10051092
};
@@ -1010,17 +1097,12 @@ describe("VcsStatusBroadcaster", () => {
10101097
const scope = yield* Scope.make();
10111098
const snapshotDeferred = yield* Deferred.make<VcsStatusStreamEvent>();
10121099
const localUpdatedDeferred = yield* Deferred.make<VcsStatusStreamEvent>();
1013-
yield* Stream.runForEach(
1014-
broadcaster.streamStatus(
1015-
{ cwd: "/repo" },
1016-
{ automaticRemoteRefreshInterval: Effect.succeed(Duration.minutes(1)) },
1017-
),
1018-
(event) =>
1019-
event._tag === "snapshot"
1020-
? Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore)
1021-
: event._tag === "localUpdated"
1022-
? Deferred.succeed(localUpdatedDeferred, event).pipe(Effect.ignore)
1023-
: Effect.void,
1100+
yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) =>
1101+
event._tag === "snapshot"
1102+
? Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore)
1103+
: event._tag === "localUpdated"
1104+
? Deferred.succeed(localUpdatedDeferred, event).pipe(Effect.ignore)
1105+
: Effect.void,
10241106
).pipe(Effect.forkIn(scope));
10251107
yield* Deferred.await(snapshotDeferred);
10261108

@@ -1127,6 +1209,12 @@ describe("VcsStatusBroadcaster", () => {
11271209
};
11281210
const layerTest = VcsStatusBroadcaster.layer.pipe(
11291211
Layer.provideMerge(NodeServices.layer),
1212+
Layer.provide(
1213+
Layer.succeed(
1214+
VcsStatusBroadcaster.VcsAutomaticFetchInterval,
1215+
Effect.succeed(Duration.seconds(1)),
1216+
),
1217+
),
11301218
Layer.provide(layerBackgroundPolicy(() => false)),
11311219
Layer.provide(
11321220
Layer.mock(GitWorkflowService.GitWorkflowService)({
@@ -1154,12 +1242,7 @@ describe("VcsStatusBroadcaster", () => {
11541242

11551243
return Effect.gen(function* () {
11561244
const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
1157-
const snapshot = yield* Stream.runHead(
1158-
broadcaster.streamStatus(
1159-
{ cwd: "/repo" },
1160-
{ automaticRemoteRefreshInterval: Effect.succeed(Duration.seconds(1)) },
1161-
),
1162-
);
1245+
const snapshot = yield* Stream.runHead(broadcaster.streamStatus({ cwd: "/repo" }));
11631246

11641247
assert.isTrue(Option.isSome(snapshot));
11651248
assert.equal(state.remoteStatusCalls, 0);

0 commit comments

Comments
 (0)