Stop a dropped connection or an expired test certificate from wedging the test host - #2204

Diagnosing a wedged Garnet.test run surfaced several defects that each turn a transient or environmental problem into a hang, or into a silent loss of coverage. None of them is the expired certificate itself — that is fixed by #2202, which this branch merges — but together they are why the expiry took the whole suite down instead of failing one test.

A caller could be left awaiting a reply that can never arrive

GarnetClient.DisposeOffset handled every task type except LongAsync and LongCallback, so a pending Task<long> was never faulted on teardown. CheckLength and GarnetClientProcessReplies both handle longTcs; only this path had been missed.

Dispose also tore down the socket and the writer without draining the requests still holding a slot. Connection teardown and the client's own disposal are independent — the handler's drain can run while Disposed is still false — so a request issued in between owned a slot nobody would complete. Dispose now drains too.

Because those two paths are gated by separate guards (disposeCount on the handler, disposed on the client), they can also run concurrently, and two drains over one slot would complete the same request twice and advance the cursor past another. So the drain is serialized, and re-reads the shared cursor each turn rather than copying it into a local that a re-entered drain would leave stale. DisposeOffset retires its slot before completing it, as ProcessReplies already does, and completion is guarded so that a throwing callback cannot strand the requests behind it or abandon the rest of teardown.

Finally, AwaitPreviousTaskAsync now ends on disposal. A request can be allocated a task ID and have its slot retired by a drain before it publishes, which advances the slot past that task so IsNext never comes true again; the TaskType.None branch only yields and never throws, so the existing catch could not end that wait.

Observed originally as an async Task that never completes, with no Garnet frames on any stack: both handlers disposed, and the reply with nowhere to go.

An expired test certificate hangs the host instead of failing a test

Under TLS 1.3 the client completes its half of the handshake before the server validates the client certificate, so ConnectAsync succeeds and the first request is the one that dies. The server closes without a RESP error — deliberately, since writing one mid-handshake would be a protocol violation — so the client has nothing to react to. The host wedges until the hang detector kills it and reports a crash, naming no cause.

TestCertificateExpiryTests reports it in milliseconds instead, with the renewal steps in the failure message, and warns 30 days ahead. The certificates carry a one-year validity, so this deadline recurs.

A port-allocator test could be skipped by block placement alone

PinnedRunSpanningTwoBlocksLeasesBoth probed its ports and only then reserved them, while leasing from a private directory that deliberately hides concurrent test hosts, so a real host could bind or lease the chosen blocks in between. Its fixed search window above the host's own block could also run off the end of the range, or fall entirely inside the Docker reservation, reporting nothing tried on a completely idle host.

It now walks the whole block range with wraparound, skips the host's own block, spends its attempt budget only on eligible boundaries, retries when a reservation loses a race, and reports how many boundaries were actually attempted.

Tests

GarnetClientDisposalTests runs against a listener that accepts and then stays silent, so no reply can arrive and every completion comes from teardown. That makes these paths deterministic, and mirrors the failure that motivated them — a server that goes mute with a request in flight.

• DisposeWithRequestsInFlightCompletesEveryCaller, covering the Task<long> path as well.
• ConcurrentTeardownCompletesEachRequestExactlyOnce, which starts the connection drop and the disposal together on a Barrier and asserts the completion count is exactly the number of requests issued, so a double-completion fails.
• ThrowingCallbackDoesNotStrandOtherRequests.

Each is bounded and reports how many requests were left pending, because the failure being guarded against otherwise exceeds any timeout.

Validation

• Full Garnet.test: 1314 passed, 0 failed, 3 skipped (pre-existing skips), repeated across runs.
• Expiry guard negative-tested against the expired certificate: fails in 100 ms with the regeneration hint, versus a six-minute wedge.
• Allocator fix verified at the two host-block placements that previously skipped silently (ownBlock 508 and 421, pinned via GARNET_TEST_PORT_BASE): both now reserve a straddling run instead of ignoring. Also verified it retries when the first candidate's ports are deliberately held, where the previous code silently skipped.