mirror of
https://github.com/stablyai/orca.git
synced 2026-11-18 03:45:08 +00:00
Keep retimed PR retry gates on their current request
This commit is contained in:
@@ -535,3 +535,78 @@ it('a watch that waited for quota while Off slowed it to Minimal reads at the Mi
|
||||
await vi.advanceTimersByTimeAsync(1)
|
||||
expect(readsOf('watched')).toBe(2)
|
||||
})
|
||||
|
||||
it('retiming an old HEAD failure cannot delay the newer HEAD return under Off', async () => {
|
||||
const { coordinator, switchTo } = await load()
|
||||
const target = makeCandidate({ branch: 'target', linkedPRNumber: 7, currentHeadOid: 'head-a' })
|
||||
const older = Promise.withResolvers<PRRefreshOutcome>()
|
||||
const newer = Promise.withResolvers<PRRefreshOutcome>()
|
||||
const observed: PRRefreshOutcome[] = []
|
||||
coordinator.addPRRefreshOutcomeObserver((_, outcome) => observed.push(outcome))
|
||||
provider.resolve.mockImplementationOnce(() => older.promise)
|
||||
coordinator.reportVisiblePRRefreshCandidates([target], 1, 1)
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
|
||||
await vi.advanceTimersByTimeAsync(1_000)
|
||||
const current = { ...target, currentHeadOid: 'head-b' }
|
||||
coordinator.reportVisiblePRRefreshCandidates([current], 2, 1)
|
||||
provider.resolve.mockImplementationOnce(() => newer.promise)
|
||||
const manual = coordinator.refreshPRNow(current, 'manual')
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
await vi.advanceTimersByTimeAsync(1_000)
|
||||
older.resolve(failed())
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
const errorsBeforeRetime = observed.filter((outcome) => outcome.kind === 'upstream-error').length
|
||||
expect(errorsBeforeRetime).toBe(1)
|
||||
await switchTo('off', 3_500)
|
||||
await vi.advanceTimersByTimeAsync(500)
|
||||
newer.resolve({
|
||||
kind: 'found',
|
||||
fetchedAt: 4_000,
|
||||
pr: makePR({
|
||||
number: 7,
|
||||
title: 'newer',
|
||||
headSha: 'head-b',
|
||||
state: 'merged',
|
||||
checksStatus: 'success'
|
||||
})
|
||||
})
|
||||
expect(await manual).toMatchObject({ fetchedAt: 4_000, pr: { title: 'newer' } })
|
||||
expect(deliveredTo('target')).toBe('newer')
|
||||
coordinator.clearVisiblePRRefreshWindow(1)
|
||||
await vi.advanceTimersByTimeAsync(65_000 - Date.now())
|
||||
provider.resolve.mockImplementationOnce(async () => ({
|
||||
kind: 'found',
|
||||
fetchedAt: Date.now(),
|
||||
pr: makePR({
|
||||
number: 7,
|
||||
title: 'returned',
|
||||
headSha: 'head-b',
|
||||
state: 'merged',
|
||||
checksStatus: 'success'
|
||||
})
|
||||
}))
|
||||
coordinator.reportVisiblePRRefreshCandidates(
|
||||
[
|
||||
{
|
||||
...current,
|
||||
cachedFetchedAt: 4_000,
|
||||
cachedHeadOid: 'head-b',
|
||||
cachedHasPR: true,
|
||||
cachedPRState: 'merged',
|
||||
cachedChecksStatus: 'success'
|
||||
}
|
||||
],
|
||||
3,
|
||||
1
|
||||
)
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
expect(deliveredTo('target')).toBe('returned')
|
||||
const delivered = coordinatorMocks.sendToTrustedUIRendererMock.mock.calls
|
||||
.map(([, event]) => event)
|
||||
.findLast((event) => event.outcome?.pr?.title === 'returned')
|
||||
expect(delivered?.outcome.fetchedAt).toBe(65_000)
|
||||
expect(observed.filter((outcome) => outcome.kind === 'upstream-error')).toHaveLength(
|
||||
errorsBeforeRetime
|
||||
)
|
||||
})
|
||||
|
||||
@@ -124,7 +124,7 @@ export async function runImmediatePRRefresh(
|
||||
queue,
|
||||
producer,
|
||||
visibility.has(key),
|
||||
queue.ownsRequest(key, requestSequence)
|
||||
() => queue.ownsRequest(key, requestSequence)
|
||||
)
|
||||
events.observe(candidate, settled, aliases)
|
||||
return settled
|
||||
|
||||
@@ -224,7 +224,7 @@ export class PRRefreshQueueDrainer {
|
||||
this.queue,
|
||||
next.hosted ? { retained: producer.retained } : producer,
|
||||
Boolean(next.hosted) || this.visibility.has(next.key),
|
||||
this.queue.ownsRequest(next.key, requestSequence)
|
||||
() => this.queue.ownsRequest(next.key, requestSequence)
|
||||
)
|
||||
this.events.observe(next.candidate, settled, aliases)
|
||||
// A host job's read also plans the visible row of the same request, under its own claim.
|
||||
|
||||
@@ -189,7 +189,15 @@ export class PRRefreshQueueScheduler {
|
||||
candidate,
|
||||
prepared,
|
||||
this.queue,
|
||||
producer
|
||||
producer,
|
||||
true,
|
||||
() => {
|
||||
const current = this.visibility.shown(key)
|
||||
return (
|
||||
current !== undefined &&
|
||||
prBranchReadKeys(...candidateReadRequest(current, 'visible'))[1] === prepared.key
|
||||
)
|
||||
}
|
||||
)
|
||||
// A rate limit the read reported holds the row's retries, as a local read's would.
|
||||
this.retry.noteManualGate(key, settled)
|
||||
|
||||
@@ -27,7 +27,7 @@ type ErrorBackoff = {
|
||||
* and delivery all read this; `retime` re-plans it and returns the key's gate, or null once a
|
||||
* newer read replaced it. */
|
||||
settled?: PRRefreshOutcome
|
||||
retime?: () => { gate: number; timed: boolean } | null
|
||||
retime?: () => { gate: number; timed: boolean; ownsRequest: boolean } | null
|
||||
/** Whether the settled failure still owns its request: no newer provider read started, its scope
|
||||
* is unchanged and the exact cache still holds the error it scheduled. */
|
||||
current?: () => boolean
|
||||
@@ -180,7 +180,9 @@ export class PRRefreshRetryState {
|
||||
revoke(state)
|
||||
} else if (plan !== undefined) {
|
||||
const gate = Math.max(plan.gate, this.manualGateUntil(key))
|
||||
queue.protectBackgroundUntil(key, gate)
|
||||
if (plan.ownsRequest) {
|
||||
queue.protectBackgroundUntil(key, gate)
|
||||
}
|
||||
if (plan.timed) {
|
||||
retries.set(key, gate)
|
||||
}
|
||||
@@ -244,7 +246,7 @@ export class PRRefreshRetryState {
|
||||
queue: PRRefreshQueue,
|
||||
producer: Parameters<PRReadSettlement>[1] = { retained: true },
|
||||
demand = true,
|
||||
ownsRequest = true
|
||||
ownsRequest: () => boolean = () => true
|
||||
): PRRefreshOutcome {
|
||||
if (outcome.kind !== 'upstream-error' || !demand || (!producer.retained && !producer.hold)) {
|
||||
return outcome
|
||||
@@ -298,10 +300,11 @@ export class PRRefreshRetryState {
|
||||
state.settled = next
|
||||
return {
|
||||
gate: Math.max(this.errorGateAt(key, candidate, planned), rateLimitedUntil),
|
||||
timed: Number.isFinite(planned)
|
||||
timed: Number.isFinite(planned),
|
||||
ownsRequest: ownsRequest()
|
||||
}
|
||||
}
|
||||
if (ownsRequest) {
|
||||
if (ownsRequest()) {
|
||||
queue.protectBackgroundUntil(
|
||||
key,
|
||||
Math.max(this.errorGateAt(key, candidate, retryAt), rateLimitedUntil)
|
||||
|
||||
Reference in New Issue
Block a user