[joaodinissf]

Why the change

A resource load timeout currently leaves the build running with an incomplete index: a different, healthy resource is silently not indexed. With this change the timeout fails the build visibly instead, and the next build is a full build. It does not change how long the builder waits.

Special things to note

• Behaviour change: a load timeout while writing resource descriptions now cancels the build (rolled back, next build is a full build). On master that phase carried on with an incomplete index; the linking phase already cancelled this way on master, so both phases now behave the same.
• A load that always stalls longer than the timeout (300 s with no result from any worker) now fails every build instead of quietly degrading the index.
• An interrupted wait is handled like a timeout. Without that, the operation would never finish: an interrupted wait delivers no result, so nothing would count it off.
• Raising the timeout alone does not fix the miscount, it only makes it rarer: on master every timeout leaves the counter one short for the rest of the operation.

Change outline

The owed-result counter in ParallelLoadOperation.next():

 result = resourceQueue.poll(waitTime)      # null on timeout or interrupt
-toProcess--                                # also without a result: counter now one short
 if result == null
+  cancel()                                 # toProcess = 0, shutdownNow; "remaining loads are abandoned"
   throw LoadOperationException(null, TimeoutException)
+toProcess--

What the builder does after a timeout:

 MonitoredClusteringBuilderState
   linking loop     timeout -> log, then !hasNext() -> cancel build      (unchanged)
   writeResources   timeout -> log
-                    loop ends when hasNext() is false: rest silently unindexed
+                    isAbandonedByTimeout(ex, loadOperation) -> OperationCanceledException

Tests (ParallelResourceLoaderTest, each run against an unbounded queue and production's synchronous hand-off):

• timeoutAbandonsEveryOutstandingLoad: one timeout ends the operation and queued loads never start. Fails on master.
• interruptedWaitAbandonsEveryOutstandingLoad: an interrupted wait ends the operation too and keeps the interrupt flag. Fails on master.
• failedLoadDoesNotAbandonTheOperation: an ordinary load failure keeps the other loads.
• resultWithinTimeoutIsDelivered: sanity check.
• BuilderLoadTimeoutTest: only a timeout with nothing left to load counts as abandonment; a timeout with loads left, an ordinary load failure and other wrapped exceptions do not.

🤖 Generated with Claude Code

[rubenporras]

I do not get the point of this PR, could we not just increase the timeout if we want to try longer?

[joaodinissf]

The goal isn't to wait longer, it's what happens once a timeout fires. On master the build carries on and silently drops a different, healthy resource from the index: the timed-out wait still counts as a delivered result, so the loop ends one short. Nothing is logged for the resource that went missing, and the index stays incomplete until the next full build. With this change a timeout (or an interrupted wait) cancels the build instead, so the next one is a full build on a consistent index. This is already how the linking phase handles it on master. A longer timeout would only make the silent case rarer.

Posted by Claude Code on behalf of @joaodinissf.