Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 3 additions & 2 deletions .github/workflows/ci.yaml
Original file line number Diff line number Diff line change
Expand Up @@ -183,12 +183,13 @@ jobs:
# Every step targets $udid; anything else booted could answer in its place.
xcrun simctl list devices booted
# The network stack's view of every connection the tests make (QUIC vs TCP races, handshakes), uploaded below.
# Cheap, and the only way to see why a connection stalled or fell back to HTTP/2.
# Cheap, and the only way to see why a connection stalled or fell back to HTTP/2. trustd too: certificate
# evaluation happens there, and in run 42427208429 one took 151 ms (2-10 ms usually) and let TCP win the race.
- name: Record the simulator's network log
timeout-minutes: 2
run: |
nohup xcrun simctl spawn "${{ steps.simulator.outputs.udid }}" log stream --level debug --style compact \
--predicate '(process == "Runner" OR process == "xctest") AND (subsystem == "com.apple.network" OR subsystem == "com.apple.CFNetwork")' \
--predicate '((process == "Runner" OR process == "xctest") AND (subsystem == "com.apple.network" OR subsystem == "com.apple.CFNetwork")) OR process == "trustd"' \
> "$RUNNER_TEMP/sim-network.log" 2>&1 &
# First, since it also warms up the simulator: right after boot, the first minute of connections from the Dart
# suite stalled before the TLS handshake on every run, and passed when the suite ran again.
Expand Down
5 changes: 3 additions & 2 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -206,8 +206,9 @@ Neither platform finishes a stream on its own while the client still has its req

It covers unary calls, errors, deadlines, server streaming, and full-duplex bidi where the server speaks first and
finishes first. It also checks the failure classes (`notSent`, `untrusted`) and the negotiated protocol: HTTP/3 on
iOS, and HTTP/2 on Android, since the server's private CA keeps Cronet off QUIC. On iOS a fresh client's first call
must already be HTTP/3: on this local path, a fallback to TCP is a failure.
iOS, and HTTP/2 on Android, since the server's private CA keeps Cronet off QUIC. On iOS a fresh client's first call,
before any Alt-Svc, must reach HTTP/3 within a few fresh clients. A loaded simulator sometimes lets TCP win
URLSession's race even locally, so a single fallback is logged rather than failed.

The script starts the server with a 3 s idle timeout and 1 s pings. Over HTTP/3 (iOS) the tests also check two
things: a quiet stream outlives the idle timeout, and a frozen path fails an open stream within it.
Expand Down
73 changes: 40 additions & 33 deletions example/integration_test/eliza_test.dart
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@ import 'package:connect_native_http_example/gen/connectrpc/eliza/v1/eliza.pb.dar
import 'package:connectrpc/connect.dart';
import 'package:connectrpc/protobuf.dart';
import 'package:connectrpc/protocol/connect.dart' as connect_protocol;
import 'package:flutter/foundation.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';

Expand Down Expand Up @@ -89,26 +90,31 @@ Future<(StreamController<ConverseRequest>, StreamIterator<ConverseResponse>)> op
return (requests, responses);
}

/// A client whose pooled connection to the server negotiated HTTP/3, for the cases that only apply over QUIC.
/// A client whose pooled connection to the server negotiated [protocol], such as `HTTP/3.0`.
///
/// URLSession races QUIC against TCP for each new connection and keeps whichever connects first, so on a loaded
/// device a connection sometimes lands on HTTP/2 even for an HTTP/3 origin. A client keeps reusing the connection it
/// has, so each attempt uses a fresh client, closing the ones that got HTTP/2.
Future<Harness> harnessOverHttp3() async {
/// has, so each attempt uses a fresh client, closing the ones that got another protocol. Each attempt is that
/// client's first call, before any Alt-Svc: reaching HTTP/3 shows the client tried QUIC because of http3Origins.
Future<Harness> harnessNegotiating(String protocol) async {
final deadline = DateTime.now().add(const Duration(seconds: 5));
final protocols = <String>[];
while (true) {
final harness = await Harness.create(serverUrl, http3Origins: {Uri.parse(serverUrl)});
await harness.eliza.say(SayRequest(sentence: 'which protocol'), onHeader: harness.recordHeaders);
final protocol = harness.serverProtocols.last;
if (protocol == 'HTTP/3.0') {
final negotiated = harness.serverProtocols.last;
if (negotiated == protocol) {
if (protocols.isNotEmpty) {
// Not a failure, but worth seeing in CI's log: how often a local HTTP/3 connection lost the race to TCP.
debugPrint('negotiated $protocol after ${protocols.length} other connections: $protocols');
}
addTearDown(harness.native.close);
return harness;
}
protocols.add(protocol);
protocols.add(negotiated);
await harness.native.close();
if (DateTime.now().isAfter(deadline)) {
fail('no connection negotiated HTTP/3 in ${protocols.length} attempts: $protocols');
fail('no connection negotiated $protocol in ${protocols.length} attempts: $protocols');
}
}
}
Expand All @@ -131,6 +137,25 @@ void main() {
IntegrationTestWidgetsFlutterBinding.ensureInitialized();
late Harness harness;

// One call on a throwaway client before any case. Right after the app launches, the simulator and the test server
// on the same CI runner are both slow (a QUIC connection took 66 ms to set up, and the server answered its first
// packet 130 ms after it was sent), so the first call's QUIC attempt loses URLSession's race to TCP. The cases then
// start on a warm app and server. The protocol it got is logged, not checked.
setUpAll(() async {
if (serverUrl.isEmpty) {
return; // setUp reports it.
}
final warmup = await Harness.create(serverUrl, http3Origins: {Uri.parse(serverUrl)});
try {
await warmup.eliza
.say(SayRequest(sentence: 'warm up'), onHeader: warmup.recordHeaders)
.timeout(const Duration(seconds: 10));
debugPrint('warm-up call went over ${warmup.serverProtocols.single}');
} finally {
await warmup.native.close();
}
});

setUp(() async {
expect(serverUrl, isNotEmpty, reason: 'run with --dart-define=SERVER_URL=...');
final origin = Uri.parse(serverUrl);
Expand Down Expand Up @@ -227,28 +252,10 @@ void main() {
markTestSkipped('EXPECT_PROTOCOL not set');
return;
}
// URLSession only moves to HTTP/3 on a new connection after an Alt-Svc response, so keep calling for a while.
final deadline = DateTime.now().add(const Duration(seconds: 5));
while (DateTime.now().isBefore(deadline) && !harness.serverProtocols.contains(expectedProtocol)) {
await harness.eliza.say(SayRequest(sentence: 'which protocol'), onHeader: harness.recordHeaders);
await Future<void>.delayed(const Duration(milliseconds: 500));
}
expect(
harness.serverProtocols,
contains(expectedProtocol),
reason: 'server saw ${harness.serverProtocols}; platform reported ${harness.platformProtocols}',
);
});

testCase('the first call to an HTTP/3 origin goes over HTTP/3', (_) async {
if (expectedProtocol != 'HTTP/3.0') {
markTestSkipped('needs EXPECT_PROTOCOL=HTTP/3.0');
return;
}
// The origin is in http3Origins, so the client tries QUIC from its first connection. Real networks can block or
// slow QUIC and fall back to TCP, but on this local path a fallback means something is wrong.
await harness.eliza.say(SayRequest(sentence: 'first'), onHeader: harness.recordHeaders);
expect(harness.serverProtocols.single, 'HTTP/3.0', reason: 'the first connection fell back to TCP');
// Fresh clients, since one that connected over HTTP/2 keeps that connection. A loaded simulator sometimes lets
// TCP win the race even on this local path (a QUIC handshake held 150 ms in certificate verification while TCP
// started 100 ms in and finished first), so one fallback isn't a failure; never reaching HTTP/3 is.
await harnessNegotiating(expectedProtocol);
});

// The idle-timeout cases freeze the server's UDP path, so they only apply where calls go over HTTP/3.
Expand All @@ -260,14 +267,14 @@ void main() {
return false;
}

// Up to 5 s of harnessOverHttp3 on top of the case itself, which waits up to 7 s for the idle timeout.
// Up to 5 s of harnessNegotiating on top of the case itself, which waits up to 7 s for the idle timeout.
const http3CaseTimeout = Duration(seconds: 20);

testCase('a quiet HTTP/3 stream outlives the idle timeout while the server pings', (_) async {
if (skipUnlessHttp3()) {
return;
}
final h3 = await harnessOverHttp3();
final h3 = await harnessNegotiating('HTTP/3.0');
final (requests, responses) = await openQuietConverse(h3);
expect(h3.serverProtocols.last, 'HTTP/3.0');
await Future<void>.delayed(serverMaxIdle * 2);
Expand All @@ -283,7 +290,7 @@ void main() {
if (skipUnlessHttp3()) {
return;
}
final h3 = await harnessOverHttp3();
final h3 = await harnessNegotiating('HTTP/3.0');
final hold = serverMaxIdle * 2 + const Duration(seconds: 1);
final res = await h3.eliza.say(
SayRequest(sentence: 'sleep:${hold.inMilliseconds}'),
Expand All @@ -298,7 +305,7 @@ void main() {
if (skipUnlessHttp3()) {
return;
}
final h3 = await harnessOverHttp3();
final h3 = await harnessNegotiating('HTTP/3.0');
final (requests, responses) = await openQuietConverse(h3);
expect(h3.serverProtocols.last, 'HTTP/3.0');
addTearDown(() => admin('/unfreeze'));
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -69,8 +69,10 @@ public final class URLSessionBridge {
// URLSession fails a task that receives nothing for this long. Its default of 60 s would end a quiet stream
// or a long-running unary call; callers bound calls with deadlines instead.
configuration.timeoutIntervalForRequest = 24 * 60 * 60
let session = URLSession(
configuration: configuration, delegate: Delegate(bridge: self), delegateQueue: self.delegateQueue)
// Only a bridge with its own roots implements the trust challenge. With the system's roots there is nothing
// for the delegate to decide, so certificate checks are left entirely to the network stack.
let delegate = self.trustedRoots.isEmpty ? Delegate(bridge: self) : TrustingDelegate(bridge: self)
let session = URLSession(configuration: configuration, delegate: delegate, delegateQueue: self.delegateQueue)
let id = self.nextSessionId
self.nextSessionId += 1
self.sessions[id] = Session(urlSession: session, http3Origins: Set(origins))
Expand Down Expand Up @@ -226,8 +228,7 @@ public final class URLSessionBridge {
fileprivate func serverTrust(_ challenge: URLAuthenticationChallenge) -> (
URLSession.AuthChallengeDisposition, URLCredential?
) {
guard !trustedRoots.isEmpty,
challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
let trust = challenge.protectionSpace.serverTrust
else {
return (.performDefaultHandling, nil)
Expand All @@ -243,21 +244,13 @@ public final class URLSessionBridge {
}

// URLSession keeps its delegate until the session is invalidated, so this holds the bridge weakly.
private final class Delegate: NSObject, URLSessionDataDelegate {
private class Delegate: NSObject, URLSessionDataDelegate {
weak var bridge: URLSessionBridge?

init(bridge: URLSessionBridge) {
self.bridge = bridge
}

func urlSession(
_ session: URLSession, didReceive challenge: URLAuthenticationChallenge,
completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
) {
let (disposition, credential) = bridge?.serverTrust(challenge) ?? (.performDefaultHandling, nil)
completionHandler(disposition, credential)
}

func urlSession(
_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void
Expand Down Expand Up @@ -287,3 +280,16 @@ private final class Delegate: NSObject, URLSessionDataDelegate {
bridge?.didComplete(task, error: error)
}
}

// A Delegate that also checks server certificates against the bridge's own roots. URLSession looks the method up by
// its Objective-C selector, hence the explicit name: a subclass doesn't inherit the protocol's @objc inference.
private final class TrustingDelegate: Delegate {
@objc(URLSession:didReceiveChallenge:completionHandler:)
func urlSession(
_ session: URLSession, didReceive challenge: URLAuthenticationChallenge,
completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
) {
let (disposition, credential) = bridge?.serverTrust(challenge) ?? (.performDefaultHandling, nil)
completionHandler(disposition, credential)
}
}
Loading