Repository navigation
Race connection attempts across resolved addresses for the Classic client (RFC 8305) - #936
arturobernalg wants to merge 1 commit into
Conversation
9a052a2 to
cd5e03d
Compare
|
Validated the racing mechanism and fallback timing against real clients over real hosts:
Same race semantics in all three that have it; winner differs only by each client's own DNS ordering (v4 vs v6), not by the racing logic. Fallback timing confirmed with a stalled address + real local listener: 266ms, matching the 250ms stagger. Also marked the opt-in setters |
|
@arturobernalg This feature was requested by @rschmitt I am not sure I am able to review this or any of the related pull requests. |
|
Ryan hasn't been around in a long time, so I don't think we should block on that. I've tested this thoroughly - real fallback timing, live comparisons against Go's net.Dialer and curl's native Happy Eyeballs across multiple hosts, concurrency stress tests on the race/cleanup paths - and I'm confident it's correct and behaves as intended. Happy to walk through any specific part you're unsure about. |
|
@arturobernalg This is true @rschmitt has not been around much, but he has not resigned from the project either. Invite him to review the pull requests. If he does not respond, feel free to merge them but please keep this feature as opt-in, at least initially. I would also wait until 5.8 unless you have pressing reasons to put this feature into 5.7. |
|
@arturobernalg And please fix the deprecation warnings |
|
Sounds good, will target 5.8 then. @rschmitt if you get a chance, would appreciate you taking a look at this new version - opt-in, disabled by default. |
cd5e03d to
38e8db5
Compare
|
@arturobernalg I tried the racing path against a host where one address accepts TCP but fails the TLS handshake, and wanted to check whether this is intended. With two addresses, where the first completes the TCP handshake but the TLS handshake fails and the second is healthy:
The winner is picked on TCP connect in I measured it end to end with the classic client, a new connection per request. DNS returns
A packet capture of the HE-on runs shows no SYN to ::1 at all. With HE off, every request goes on to ::1 and completes the handshake there. Here is a test that runs the same case against the operator directly. It passes with HappyEyeballsTlsFallbackProbeTest@ParameterizedTest(name = "happyEyeballs={0}")
@ValueSource(booleans = {false, true})
void tlsFailureOnFirstAddressFallsBackToNextAddress(final boolean happyEyeballs) throws Exception {
try (ServerSocket broken = new ServerSocket(0, 50, InetAddress.getLoopbackAddress());
ServerSocket healthy = new ServerSocket(0, 50, InetAddress.getLoopbackAddress())) {
final List<InetSocketAddress> remoteAddresses = Arrays.asList(
new InetSocketAddress(InetAddress.getLoopbackAddress(), broken.getLocalPort()),
new InetSocketAddress(InetAddress.getLoopbackAddress(), healthy.getLocalPort()));
final DnsResolver dnsResolver = Mockito.mock(DnsResolver.class);
Mockito.when(dnsResolver.resolve(Mockito.anyString(), Mockito.anyInt())).thenReturn(remoteAddresses);
final AtomicInteger handshakes = new AtomicInteger();
final AtomicInteger upgradedPort = new AtomicInteger();
final TlsSocketStrategy tls = (socket, target, port, attachment, context) -> {
handshakes.incrementAndGet();
if (socket.getPort() == broken.getLocalPort()) {
throw new IOException("handshake failed on " + socket.getRemoteSocketAddress());
}
upgradedPort.set(socket.getPort());
return Mockito.mock(SSLSocket.class);
};
final Lookup<TlsSocketStrategy> tlsLookup = scheme -> tls;
final DefaultHttpClientConnectionOperator operator = new DefaultHttpClientConnectionOperator(
proxy -> new Socket(), DefaultSchemePortResolver.INSTANCE, dnsResolver, tlsLookup,
happyEyeballs, TimeValue.ofMilliseconds(250));
final DefaultManagedHttpClientConnection conn = new DefaultManagedHttpClientConnection(
"test", null, null, null, null, null, null, null, null);
operator.connect(conn, new HttpHost("https", "somehost", 443), null,
TimeValue.ofSeconds(5), SocketConfig.DEFAULT, HttpClientContext.create());
assertEquals(healthy.getLocalPort(), upgradedPort.get());
assertEquals(2, handshakes.get());
}
}I can see arguments for this being intended. RFC 8305 section 5 counts an attempt as successful once the TCP handshake completes, and section 9 leaves TLS failures out of scope. Is the HE-on behavior what you want here? If so, maybe it's worth mentioning in the javadoc for |
…ient Replaces the one-thread-per-address, sleep-based stagger with a single dispatcher that starts the first address immediately and waits up to the connection attempt delay for an outstanding attempt to finish before starting the next; on a failure it advances immediately, at the RFC 8305 minimum spacing (10ms), instead of waiting out the full delay. No worker thread ever sleeps a delay itself, bounding concurrency to the number of resolved addresses actually in flight. Socket registration goes through a small atomic registry instead of a bare reference: deciding a winner and a worker registering its socket can happen at the same instant, and whichever runs second closes the socket, so nothing registered around that moment survives open regardless of timing. shutdownNow() alone cannot abort a blocking Socket#connect; closing the socket is what actually does that, on every exit path (winner found, every address failed, or interrupted) via one cleanup call in a finally block. An interruption during the minimum-spacing wait is now propagated instead of swallowed, aborting the race immediately like interruption anywhere else in it. Racing is skipped in favor of the existing sequential path when a specific, non-ephemeral local port is requested, since binding several attempts to it concurrently would trade a real connect failure for a spurious bind conflict. Public, blocking connect() behavior, TLS, SOCKS and local binding are otherwise unchanged.
38e8db5 to
4d1e562
Compare
|
@shinseongsu Confirmed, reproduced end to end with real TCP/TLS servers — same exceptions you measured. Fixed: on TLS failure after the race picks a winner, the operator now falls back to the remaining addresses, same as the non-racing path. Async doesn't do this either and RFC 8305 §9.2 leaves it out of scope, but the Classic client already guaranteed it before this PR, so dropping it under Happy Eyeballs would've been a silent regression. Added your test plus a couple more. Pushed. |
|
@arturobernalg Thanks for the quick fix. I reran everything on 4d1e562. The probe test now passes with Happy Eyeballs both on and off, and the end-to-end runs with HE on are all OK: 100/100 when 127.0.0.1 resets, 10/10 when it stalls. The capture shows each request moving on to ::1 and finishing the handshake there. |
|
@arturobernalg @shinseongsu If you feel the change-set has been reasonably well tests, feel free to merge into master for the coming 5.7 release |
|
@shinseongsu Pushed a branch with #935 (async) and #936 (classic) combined and hardened, if you want to try it: https://github.com/arturobernalg/httpcomponents-client/tree/happy-eyeballs-combined |
…8305) MultihomeIOSessionRequester only retried a TCP-level connect failure across the resolved addresses; a TLS failure on an address that had already connected at the TCP level, racing or not, ended the whole attempt instead of trying the others, the same regression apache#936 fixed for the classic client. Adds a SessionValidator hook run on every connected session before it is accepted, shared by the plain sequential path and the race's post-win fallback, mirroring DefaultHttpClientConnectionOperator's connectSequentially. Hardens cancellation around that fallback: a cancel arriving while a TLS-triggered fallback attempt is in flight reaches the live attempt, in both the plain sequential path and the racing path's post-win fallback. executeNext() checks future.isDone() before starting a new attempt, at the top of executeNext() itself and in onFailure(), the two places that start a new attempt, and holds a single ReentrantLock per connectSequentially() run, shared across all its attempts, across the index check and the future's dependency retarget, so a same-thread reentrant rejection and a cross-thread one can never race on which attempt is tracked. Race's own six synchronized blocks are converted the same way, matching the project's lock discipline for virtual threads. A TlsStrategy that reports an outcome and then throws, in violation of its contract, is a no-op on the second signal instead of double-advancing the fallback. The handshake result is reported before the onAfterTlsHandshake hook runs, so a throwing hook cannot hang the connect() future. The cancellation this hardening targets can still be lost underneath it, in httpcore5: SingleCoreIOReactor#processConnectionRequest connects and completes an IOSessionRequest before assigning it a closeable, so a cancel() landing in that window returns true without anything to close. A separate, narrower check-then-set race in ComplexFuture#setDependency itself is also unclosed. Both are out of scope here and belong in httpcore5. TestHttpAsyncMinimalTlsHandshake.testTlsHandshakeFailure is pinned to a literal address: "localhost" resolves to more than one address in this environment, and a TLS failure is no longer necessarily final for the last-tried address, so a second, unlistened-on address could mask the TLS failure the test asserts. TestHappyEyeballsTlsFallbackAsync's probe accepts the TCP connection, reads the ClientHello and replies in plaintext, producing a real SSLException. Its cancel-during-fallback scenario's own server observes the client disconnecting directly, so the test cannot pass merely because cancelling a future completes it locally regardless of whether cancellation propagated anywhere. This test is flaky under heavy CPU load (the cancel can still land in the httpcore5 window above); a validated fix exists but is not applied here. Unit tests cover: the isDone() guard at both its entry points (the racing one directly, via Race.onWinnerRejected()'s call into executeNext(); the sequential one indirectly, via onFailure(), which does not on its own exercise the top-of-executeNext() guard); the session never being closed when a throwing onAfterTlsHandshake hook is swallowed; and the double-invocation guard on both the callback and the throw-without-callback paths.
Implements RFC 8305 (Happy Eyeballs v2) connection racing for the Classic (blocking) client, as the third and final PR of this series, alongside #935 (Async connection racing) and arturobernalg#20 (Async independent A/AAAA resolution, stacked on #935 pending its merge). This PR is independent of the other two: the Classic client has its own connection path (java.net.Socket, not the reactor), so it needed its own, smaller mechanism rather than reusing the Async internals.
Dependency
None. Based directly on upstream master, independent of #935 and arturobernalg#20.