From 8f778a9cda2df1a3717dd8086c4ed0e70db8f68a Mon Sep 17 00:00:00 2001 From: Liam Appelbe Date: Thu, 19 Nov 2026 12:28:52 +1100 Subject: [PATCH 1/4] wip --- pkgs/coverage/CHANGELOG.md | 7 + pkgs/coverage/lib/src/collect.dart | 62 ++--- pkgs/coverage/pubspec.yaml | 4 +- pkgs/coverage/test/retry_connection_test.dart | 251 ++++++++++++++++++ 4 files changed, 289 insertions(+), 35 deletions(-) create mode 100644 pkgs/coverage/test/retry_connection_test.dart diff --git a/pkgs/coverage/CHANGELOG.md b/pkgs/coverage/CHANGELOG.md index 2c7140215a..7074c6e5b3 100644 --- a/pkgs/coverage/CHANGELOG.md +++ b/pkgs/coverage/CHANGELOG.md @@ -1,3 +1,10 @@ +## 1.16.2-wip + +- Fix a race condition in `collect()` when retrying VM service connections so a + delayed socket close from a failed connection attempt cannot dispose the + active retry connection, and ensure failed attempts are always disposed. +- Update `package:vm_service` constraints to `'>=14.2.2 <16.0.0'`. + ## 1.16.1 - Fix `HitMap.parseFiles` to allow empty `{}` coverage files written by diff --git a/pkgs/coverage/lib/src/collect.dart b/pkgs/coverage/lib/src/collect.dart index b53e0b1157..b69855cc92 100644 --- a/pkgs/coverage/lib/src/collect.dart +++ b/pkgs/coverage/lib/src/collect.dart @@ -68,7 +68,7 @@ Future> collect( }) async { scopedOutput ??= {}; - late VmService service; + final VmService service; if (serviceOverrideForTesting != null) { service = serviceOverrideForTesting; } else { @@ -77,36 +77,9 @@ Future> collect( serviceUri.pathSegments.where((c) => c.isNotEmpty).toList()..add('ws'); final uri = serviceUri.replace(scheme: 'ws', pathSegments: pathSegments); - await retry( - () async { - try { - final options = const CompressionOptions(enabled: false); - final socket = await WebSocket.connect('$uri', compression: options); - final controller = StreamController(); - socket.listen( - (data) => controller.add(data as String), - onDone: () { - controller.close(); - service.dispose(); - }, - ); - service = VmService( - controller.stream, - socket.add, - log: StdoutLog(), - disposeHandler: socket.close, - ); - await service.getVM().timeout(_retryInterval); - } on TimeoutException { - // The signature changed in vm_service version 6.0.0. - // ignore: await_only_futures - await service.dispose(); - rethrow; - } - }, - _retryInterval, - timeout: timeout, - ); + service = + await retry(() => _connect(uri), _retryInterval, timeout: timeout) + as VmService; } try { @@ -124,12 +97,35 @@ Future> collect( if (resume && !waitPaused) { await _resumeIsolates(service); } - // The signature changed in vm_service version 6.0.0. - // ignore: await_only_futures await service.dispose(); } } +Future _connect(Uri uri) async { + final socket = await WebSocket.connect( + '$uri', + compression: const CompressionOptions(enabled: false), + ); + final controller = StreamController(); + socket.listen( + (data) => controller.add(data as String), + onDone: controller.close, + ); + final service = VmService( + controller.stream, + socket.add, + log: StdoutLog(), + disposeHandler: socket.close, + ); + try { + await service.getVM().timeout(_retryInterval); + return service; + } catch (_) { + await service.dispose(); + rethrow; + } +} + Future> _getAllCoverage( VmService service, bool includeDart, diff --git a/pkgs/coverage/pubspec.yaml b/pkgs/coverage/pubspec.yaml index 29420aeb9a..30a1c5fc23 100644 --- a/pkgs/coverage/pubspec.yaml +++ b/pkgs/coverage/pubspec.yaml @@ -1,5 +1,5 @@ name: coverage -version: 1.16.1 +version: 1.16.2-wip description: Coverage data manipulation and formatting repository: https://github.com/dart-lang/tools/tree/main/pkgs/coverage issue_tracker: https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Acoverage @@ -18,7 +18,7 @@ dependencies: path: ^1.8.0 source_maps: ^0.10.10 stack_trace: ^1.10.0 - vm_service: '>=12.0.0 <16.0.0' + vm_service: '>=14.2.2 <16.0.0' yaml: ^3.1.3 dev_dependencies: diff --git a/pkgs/coverage/test/retry_connection_test.dart b/pkgs/coverage/test/retry_connection_test.dart new file mode 100644 index 0000000000..e5e00d79bf --- /dev/null +++ b/pkgs/coverage/test/retry_connection_test.dart @@ -0,0 +1,251 @@ +// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; + +import 'package:coverage/coverage.dart'; +import 'package:test/test.dart'; + +typedef _RpcHandler = + FutureOr Function( + _ClientConnection connection, + Map rpc, + ); + +class _ClientConnection { + _ClientConnection(this.index, this.socket, _RpcHandler onRpc) { + _subscription = socket.listen((message) { + final rpc = jsonDecode(message as String) as Map; + onRpc(this, rpc); + }); + } + + final int index; + final WebSocket socket; + late final StreamSubscription _subscription; + + void pause() => _subscription.pause(); + + void resume() => _subscription.resume(); + + Future close() async { + await _subscription.cancel(); + await socket.close(); + } + + void reply(Object? id, Map result) { + if (socket.readyState == WebSocket.open) { + socket.add(jsonEncode({'jsonrpc': '2.0', 'id': id, 'result': result})); + } + } + + void replyError(Object? id, String message) { + if (socket.readyState == WebSocket.open) { + socket.add( + jsonEncode({ + 'jsonrpc': '2.0', + 'id': id, + 'error': {'code': -32000, 'message': message}, + }), + ); + } + } + + void failUnexpectedRpc(Map rpc) { + final message = 'Unexpected RPC on connection $index: ${rpc['method']}'; + replyError(rpc['id'], message); + fail(message); + } +} + +class _FakeVmServiceServer { + _FakeVmServiceServer._(this._server); + + final HttpServer _server; + final List<_ClientConnection> connections = []; + + Uri get uri => Uri.parse('http://127.0.0.1:${_server.port}/'); + + static Future<_FakeVmServiceServer> start(_RpcHandler onRpc) async { + final httpServer = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + final fakeServer = _FakeVmServiceServer._(httpServer); + addTearDown(fakeServer.close); + + httpServer.listen((request) async { + expect(request.uri.path, '/ws'); + final socket = await WebSocketTransformer.upgrade(request); + fakeServer.connections.add( + _ClientConnection(fakeServer.connections.length + 1, socket, onRpc), + ); + }); + + return fakeServer; + } + + Future close() async { + await _server.close(force: true); + for (final connection in connections) { + await connection.close(); + } + } +} + +Map _vmResponse(List isolateIds) => { + 'type': 'VM', + 'isolates': [ + for (var i = 0; i < isolateIds.length; i++) + { + 'type': '@Isolate', + 'id': isolateIds[i], + 'isolateGroupId': 'isolateGroups/${i + 1}', + 'name': 'suite_${i + 1}', + 'number': '${i + 1}', + 'isSystemIsolate': false, + }, + ], +}; + +const _emptySourceReport = { + 'type': 'SourceReport', + 'ranges': [], + 'scripts': [], +}; + +void main() { + test('disposes failed connection on non-timeout getVM error', () async { + var reports = 0; + final server = await _FakeVmServiceServer.start((connection, rpc) { + final method = rpc['method']; + if (connection.index == 1) { + if (method != 'getVM') { + connection.failUnexpectedRpc(rpc); + } + // Return an RPC error while keeping connection 1 open on the server. + // collect() must dispose and close this failed connection itself. + connection.replyError(rpc['id'], 'Transient readiness failure'); + return; + } + + if (method == 'getVM') { + connection.reply(rpc['id'], _vmResponse(['isolates/1'])); + } else if (method == 'getSourceReport') { + reports++; + connection.reply(rpc['id'], _emptySourceReport); + } else { + connection.failUnexpectedRpc(rpc); + } + }); + + final coverage = await collect( + server.uri, + false, + false, + false, + {}, + timeout: const Duration(seconds: 5), + ); + + expect(coverage, {'type': 'CodeCoverage', 'coverage': []}); + expect(server.connections.length, 2); + expect(reports, 1); + await server.connections.first.socket.done.timeout( + const Duration(seconds: 1), + onTimeout: () => + fail('Expected collect() to close the failed connection'), + ); + }); + + test( + 'delayed close of a failed attempt does not dispose active retry', + () async { + var reports = 0; + late final _FakeVmServiceServer server; + server = await _FakeVmServiceServer.start((connection, rpc) async { + final method = rpc['method']; + if (connection.index == 1) { + if (method != 'getVM') { + connection.failUnexpectedRpc(rpc); + } + // Stall getVM past _retryInterval and pause reading so the server + // withholds its close handshake response until connection 2 has an + // in-flight getSourceReport RPC. + connection.pause(); + return; + } + + if (method == 'getVM') { + connection.reply( + rpc['id'], + _vmResponse(['isolates/1', 'isolates/2']), + ); + } else if (method == 'getSourceReport') { + reports++; + if (reports == 1) { + // Complete connection 1's close handshake while connection 2's + // getSourceReport is in flight, delivering connection 1's onDone + // to the client before the second isolate's RPC completes. + final first = server.connections.first; + first.resume(); + await first.socket.close(); + await first.socket.done; + } + connection.reply(rpc['id'], _emptySourceReport); + } else { + connection.failUnexpectedRpc(rpc); + } + }); + + final coverage = await collect( + server.uri, + false, + false, + false, + {}, + timeout: const Duration(seconds: 5), + ); + + expect(coverage, {'type': 'CodeCoverage', 'coverage': []}); + expect(server.connections.length, 2); + expect(reports, 2); + }, + ); + + test('retries when peer closes socket during getVM readiness', () async { + var reports = 0; + final server = await _FakeVmServiceServer.start((connection, rpc) async { + final method = rpc['method']; + if (connection.index == 1) { + if (method != 'getVM') { + connection.failUnexpectedRpc(rpc); + } + await connection.socket.close(); + return; + } + + if (method == 'getVM') { + connection.reply(rpc['id'], _vmResponse(['isolates/1'])); + } else if (method == 'getSourceReport') { + reports++; + connection.reply(rpc['id'], _emptySourceReport); + } else { + connection.failUnexpectedRpc(rpc); + } + }); + + final coverage = await collect( + server.uri, + false, + false, + false, + {}, + timeout: const Duration(seconds: 5), + ); + + expect(coverage, {'type': 'CodeCoverage', 'coverage': []}); + expect(server.connections.length, 2); + expect(reports, 1); + }); +} From 82e23ac025a191b4eb7914d84f063344b50c2967 Mon Sep 17 00:00:00 2001 From: Liam Appelbe Date: Thu, 19 Nov 2026 13:16:26 +1100 Subject: [PATCH 2/4] merge --- pkgs/coverage/lib/src/collect.dart | 2 +- pkgs/coverage/test/retry_connection_test.dart | 34 +++++++++++++------ 2 files changed, 24 insertions(+), 12 deletions(-) diff --git a/pkgs/coverage/lib/src/collect.dart b/pkgs/coverage/lib/src/collect.dart index b69855cc92..e19d8761e3 100644 --- a/pkgs/coverage/lib/src/collect.dart +++ b/pkgs/coverage/lib/src/collect.dart @@ -118,7 +118,7 @@ Future _connect(Uri uri) async { disposeHandler: socket.close, ); try { - await service.getVM().timeout(_retryInterval); + await service.getVersion().timeout(_retryInterval); return service; } catch (_) { await service.dispose(); diff --git a/pkgs/coverage/test/retry_connection_test.dart b/pkgs/coverage/test/retry_connection_test.dart index e5e00d79bf..5bb5af6412 100644 --- a/pkgs/coverage/test/retry_connection_test.dart +++ b/pkgs/coverage/test/retry_connection_test.dart @@ -108,6 +108,12 @@ Map _vmResponse(List isolateIds) => { ], }; +const _versionResponse = { + 'type': 'Version', + 'major': 4, + 'minor': 0, +}; + const _emptySourceReport = { 'type': 'SourceReport', 'ranges': [], @@ -115,12 +121,12 @@ const _emptySourceReport = { }; void main() { - test('disposes failed connection on non-timeout getVM error', () async { + test('disposes failed connection on non-timeout getVersion error', () async { var reports = 0; final server = await _FakeVmServiceServer.start((connection, rpc) { final method = rpc['method']; if (connection.index == 1) { - if (method != 'getVM') { + if (method != 'getVersion') { connection.failUnexpectedRpc(rpc); } // Return an RPC error while keeping connection 1 open on the server. @@ -129,7 +135,9 @@ void main() { return; } - if (method == 'getVM') { + if (method == 'getVersion') { + connection.reply(rpc['id'], _versionResponse); + } else if (method == 'getVM') { connection.reply(rpc['id'], _vmResponse(['isolates/1'])); } else if (method == 'getSourceReport') { reports++; @@ -166,17 +174,19 @@ void main() { server = await _FakeVmServiceServer.start((connection, rpc) async { final method = rpc['method']; if (connection.index == 1) { - if (method != 'getVM') { + if (method != 'getVersion') { connection.failUnexpectedRpc(rpc); } - // Stall getVM past _retryInterval and pause reading so the server - // withholds its close handshake response until connection 2 has an - // in-flight getSourceReport RPC. + // Stall getVersion past _retryInterval and pause reading so the + // server withholds its close handshake response until connection 2 + // has an in-flight getSourceReport RPC. connection.pause(); return; } - if (method == 'getVM') { + if (method == 'getVersion') { + connection.reply(rpc['id'], _versionResponse); + } else if (method == 'getVM') { connection.reply( rpc['id'], _vmResponse(['isolates/1', 'isolates/2']), @@ -213,19 +223,21 @@ void main() { }, ); - test('retries when peer closes socket during getVM readiness', () async { + test('retries when peer closes socket during getVersion readiness', () async { var reports = 0; final server = await _FakeVmServiceServer.start((connection, rpc) async { final method = rpc['method']; if (connection.index == 1) { - if (method != 'getVM') { + if (method != 'getVersion') { connection.failUnexpectedRpc(rpc); } await connection.socket.close(); return; } - if (method == 'getVM') { + if (method == 'getVersion') { + connection.reply(rpc['id'], _versionResponse); + } else if (method == 'getVM') { connection.reply(rpc['id'], _vmResponse(['isolates/1'])); } else if (method == 'getSourceReport') { reports++; From 417ca0e93ce922cbafbf8e670c25e10b4f934ca0 Mon Sep 17 00:00:00 2001 From: Liam Appelbe Date: Thu, 19 Nov 2026 13:32:30 +1100 Subject: [PATCH 3/4] Apply batched suggestions from code review Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com> --- pkgs/coverage/lib/src/collect.dart | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/coverage/lib/src/collect.dart b/pkgs/coverage/lib/src/collect.dart index e19d8761e3..47d8ad22a9 100644 --- a/pkgs/coverage/lib/src/collect.dart +++ b/pkgs/coverage/lib/src/collect.dart @@ -78,8 +78,7 @@ Future> collect( final uri = serviceUri.replace(scheme: 'ws', pathSegments: pathSegments); service = - await retry(() => _connect(uri), _retryInterval, timeout: timeout) - as VmService; + await retry(() => _connect(uri), _retryInterval, timeout: timeout); } try { @@ -109,6 +108,7 @@ Future _connect(Uri uri) async { final controller = StreamController(); socket.listen( (data) => controller.add(data as String), + onError: controller.addError, onDone: controller.close, ); final service = VmService( From a8c2ceee2a34393954f9d1a82823a6b5c2457e26 Mon Sep 17 00:00:00 2001 From: Liam Appelbe Date: Thu, 19 Nov 2026 14:25:00 +1100 Subject: [PATCH 4/4] clean up --- pkgs/coverage/lib/src/collect.dart | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pkgs/coverage/lib/src/collect.dart b/pkgs/coverage/lib/src/collect.dart index 47d8ad22a9..ff6bd9abb0 100644 --- a/pkgs/coverage/lib/src/collect.dart +++ b/pkgs/coverage/lib/src/collect.dart @@ -78,7 +78,8 @@ Future> collect( final uri = serviceUri.replace(scheme: 'ws', pathSegments: pathSegments); service = - await retry(() => _connect(uri), _retryInterval, timeout: timeout); + await retry(() => _connect(uri), _retryInterval, timeout: timeout) + as VmService; } try { @@ -108,8 +109,9 @@ Future _connect(Uri uri) async { final controller = StreamController(); socket.listen( (data) => controller.add(data as String), - onError: controller.addError, + onError: (_, _) => controller.close(), onDone: controller.close, + cancelOnError: true, ); final service = VmService( controller.stream,