Skip to content

Commit 0d78d83

Browse files
committed
fix(server): 让指令失效重试释放会话清理锁
将比较写入的锁限制在单次尝试内,重试之间让会话释放和订阅清理继续执行。 保留失效记录与所有权检查,避免并发更新覆盖新状态或因重试上限丢失失效写入。 新增连续四次写入冲突的回归验证;变更范围检查与 141 个测试全部通过。
1 parent 7f20d1b commit 0d78d83

2 files changed

Lines changed: 75 additions & 24 deletions

File tree

‎apps/server/src/orchestration-v2/ProviderSessionManager.test.ts‎

Lines changed: 47 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2905,13 +2905,15 @@ it.effect.each([
29052905
"queued-completion",
29062906
"released-completion",
29072907
"repeated-close",
2908+
"contended-close",
29082909
"newer-run",
29092910
"newer-session",
29102911
] as const)(
29112912
"ProviderSessionManagerV2 persists instruction invalidation only for its owner (%s)",
29122913
(owner) =>
29132914
Effect.gen(function* () {
29142915
const state = yield* Ref.make(emptyState);
2916+
const beforeUnchangedWrite = yield* Ref.make<Effect.Effect<void>>(Effect.void);
29152917
yield* Effect.gen(function* () {
29162918
const eventSink = yield* EventSink.EventSinkV2;
29172919
const idAllocator = yield* IdAllocator.IdAllocatorV2;
@@ -2989,17 +2991,54 @@ it.effect.each([
29892991
},
29902992
],
29912993
});
2994+
let conflicts = 0;
2995+
let release: Fiber.Fiber<void> | undefined;
2996+
const raceWithCleanup: Effect.Effect<void> = Effect.gen(function* () {
2997+
conflicts++;
2998+
if (conflicts === 1) {
2999+
release = yield* manager
3000+
.release({ providerSessionId, reason: "manual_shutdown" })
3001+
.pipe(Effect.orDie, Effect.forkChild({ startImmediately: true }));
3002+
} else {
3003+
assert.isFalse(
3004+
yield* manager.isLive(providerSessionId),
3005+
"release must enter between retries",
3006+
);
3007+
}
3008+
yield* eventSink.write({
3009+
events: [
3010+
{
3011+
id: yield* idAllocator.allocate.event({ threadId, providerSessionId }),
3012+
type: "provider-thread.updated",
3013+
threadId,
3014+
driver: CODEX_DRIVER,
3015+
occurredAt: now,
3016+
payload: {
3017+
...before,
3018+
nativeMetadata: { ...before.nativeMetadata, title: `conflict ${conflicts}` },
3019+
},
3020+
},
3021+
],
3022+
});
3023+
if (conflicts < 4) yield* Ref.set(beforeUnchangedWrite, raceWithCleanup);
3024+
}).pipe(Effect.orDie);
29923025
yield* subscription.events.pipe(
29933026
Stream.tap(() =>
29943027
Effect.gen(function* () {
29953028
if (owner === "released-completion")
29963029
yield* manager.release({ providerSessionId, reason: "manual_shutdown" });
29973030
if (owner === "queued-completion" || owner === "released-completion")
29983031
yield* restoreCompletion;
3032+
if (owner === "contended-close") {
3033+
yield* restoreCompletion;
3034+
yield* Ref.set(beforeUnchangedWrite, raceWithCleanup);
3035+
}
29993036
}),
30003037
),
30013038
Stream.runHead,
30023039
);
3040+
if (release !== undefined) yield* Fiber.join(release);
3041+
if (owner === "contended-close") assert.equal(conflicts, 4);
30033042
if (owner === "repeated-close") {
30043043
yield* restoreCompletion;
30053044
yield* subscription.close;
@@ -3013,14 +3052,19 @@ it.effect.each([
30133052
owner === "current" ||
30143053
owner === "queued-completion" ||
30153054
owner === "released-completion" ||
3016-
owner === "repeated-close"
3055+
owner === "repeated-close" ||
3056+
owner === "contended-close"
30173057
? {
30183058
...before,
3019-
nativeMetadata: { ...before.nativeMetadata, acpInstructions: null },
3059+
nativeMetadata: {
3060+
...before.nativeMetadata,
3061+
...(owner === "contended-close" ? { title: "conflict 4" } : {}),
3062+
acpInstructions: null,
3063+
},
30203064
}
30213065
: before,
30223066
);
3023-
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
3067+
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000, beforeUnchangedWrite })));
30243068
}),
30253069
);
30263070

‎apps/server/src/orchestration-v2/ProviderSessionManager.ts‎

Lines changed: 28 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1632,16 +1632,17 @@ export const layerWithOptions = (
16321632
yield* Queue.clear(queue);
16331633
yield* Queue.end(queue);
16341634
}
1635-
// Completion can restore its cached receipt after an idle invalidation was persisted.
1636-
if (entry !== undefined) {
1637-
yield* Effect.forEach(
1638-
entry.instructionInvalidations.values(),
1639-
(offered) => persistInstructionInvalidation(entry, offered),
1640-
{ discard: true },
1641-
);
1642-
}
16431635
});
16441636
yield* entry === undefined ? release : entry.requestEventPermit.withPermits(1)(release);
1637+
// Completion can restore its cached receipt after an idle invalidation was persisted.
1638+
// Retry outside the cleanup lock so release can stop a competing runtime writer.
1639+
if (entry !== undefined) {
1640+
yield* Effect.forEach(
1641+
[...entry.instructionInvalidations.values()],
1642+
(offered) => persistInstructionInvalidation(entry, offered),
1643+
{ discard: true },
1644+
);
1645+
}
16451646
}).pipe(Effect.orDie);
16461647
const events = Stream.fromQueue(queue).pipe(
16471648
Stream.mapEffect((signal) =>
@@ -1875,6 +1876,7 @@ export const layerWithOptions = (
18751876
if (threadId === null || offered.nativeMetadata?.acpInstructions !== null) return;
18761877
// Idle updates outlive run subscribers; invalidate only the receipt, not newer thread state.
18771878
yield* Effect.gen(function* () {
1879+
if (entry.instructionInvalidations.get(offered.id) !== offered) return true;
18781880
if (!entry.attachedThreadIds.has(threadId)) return true;
18791881
const projection = yield* projectionStore.getThreadRecords(threadId, ["providerThreads"]);
18801882
const stored = projection.providerThreads.find(
@@ -1903,7 +1905,12 @@ export const layerWithOptions = (
19031905
});
19041906
return (yield* eventSink.writeIfProviderThreadUnchanged({ expected: stored, events }))
19051907
.committed;
1906-
}).pipe(Effect.repeat({ until: (committed) => committed }));
1908+
}).pipe(
1909+
// Each comparison owns the permit; retries must let cleanup and newer receipts through.
1910+
entry.requestEventPermit.withPermits(1),
1911+
Effect.tap((committed) => (committed ? Effect.void : Effect.yieldNow)),
1912+
Effect.repeat({ until: (committed) => committed }),
1913+
);
19071914
});
19081915

19091916
const startEventPump = (entry: LiveSessionEntry) => {
@@ -1970,7 +1977,7 @@ export const layerWithOptions = (
19701977
event.type === "provider_thread.updated" &&
19711978
event.providerThread.nativeMetadata?.acpInstructions !== undefined
19721979
) {
1973-
yield* Effect.gen(function* () {
1980+
yield* Effect.sync(() => {
19741981
if (event.providerThread.nativeMetadata?.acpInstructions === null) {
19751982
entry.instructionInvalidations.set(
19761983
event.providerThread.id,
@@ -1979,18 +1986,18 @@ export const layerWithOptions = (
19791986
} else {
19801987
entry.instructionInvalidations.delete(event.providerThread.id);
19811988
}
1982-
yield* persistInstructionInvalidation(entry, event.providerThread).pipe(
1983-
Effect.mapError(
1984-
(cause) =>
1985-
new ProviderAdapter.ProviderAdapterEventStreamError({
1986-
driver: entry.runtime.driver,
1987-
providerSessionId: entry.runtime.providerSessionId,
1988-
cause,
1989-
}),
1990-
),
1991-
);
1992-
yield* publishToSubscribers(entry.eventSubscribers, { type: "event", event });
19931989
}).pipe(entry.requestEventPermit.withPermits(1));
1990+
yield* persistInstructionInvalidation(entry, event.providerThread).pipe(
1991+
Effect.mapError(
1992+
(cause) =>
1993+
new ProviderAdapter.ProviderAdapterEventStreamError({
1994+
driver: entry.runtime.driver,
1995+
providerSessionId: entry.runtime.providerSessionId,
1996+
cause,
1997+
}),
1998+
),
1999+
);
2000+
yield* publishToSubscribers(entry.eventSubscribers, { type: "event", event });
19942001
return;
19952002
}
19962003
// Some providers can block before a run subscriber exists

0 commit comments

Comments
 (0)