Skip to content
Draft
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
4 changes: 4 additions & 0 deletions pkgs/coverage/CHANGELOG.md
Original file line number Diff line number Diff line change
@@ -1,6 +1,10 @@
## 1.16.2-wip

- Use `getVersion()` instead of `getVM()` when pinging the VM service API.
- 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

Expand Down
64 changes: 31 additions & 33 deletions pkgs/coverage/lib/src/collect.dart
Original file line number Diff line number Diff line change
Expand Up @@ -68,7 +68,7 @@ Future<Map<String, dynamic>> collect(
}) async {
scopedOutput ??= <String>{};

late VmService service;
final VmService service;
if (serviceOverrideForTesting != null) {
service = serviceOverrideForTesting;
} else {
Expand All @@ -77,36 +77,9 @@ Future<Map<String, dynamic>> 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<String>();
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.getVersion().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 {
Expand All @@ -124,12 +97,37 @@ Future<Map<String, dynamic>> 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<VmService> _connect(Uri uri) async {
final socket = await WebSocket.connect(
'$uri',
compression: const CompressionOptions(enabled: false),
);
final controller = StreamController<String>();
socket.listen(
(data) => controller.add(data as String),
onError: (_, _) => controller.close(),
onDone: controller.close,
cancelOnError: true,
);
Comment thread
liamappelbe marked this conversation as resolved.
Resolved
final service = VmService(
controller.stream,
socket.add,
log: StdoutLog(),
disposeHandler: socket.close,
);
try {
await service.getVersion().timeout(_retryInterval);
return service;
} catch (_) {
await service.dispose();
rethrow;
}
}

Future<Map<String, dynamic>> _getAllCoverage(
VmService service,
bool includeDart,
Expand Down
2 changes: 1 addition & 1 deletion pkgs/coverage/pubspec.yaml
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand Down
263 changes: 263 additions & 0 deletions pkgs/coverage/test/retry_connection_test.dart
Original file line number Diff line number Diff line change
@@ -0,0 +1,263 @@
// 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<void> Function(
_ClientConnection connection,
Map<String, dynamic> rpc,
);

class _ClientConnection {
_ClientConnection(this.index, this.socket, _RpcHandler onRpc) {
_subscription = socket.listen((message) {
final rpc = jsonDecode(message as String) as Map<String, dynamic>;
onRpc(this, rpc);
});
}

final int index;
final WebSocket socket;
late final StreamSubscription<dynamic> _subscription;

void pause() => _subscription.pause();

void resume() => _subscription.resume();

Future<void> close() async {
await _subscription.cancel();
await socket.close();
}

void reply(Object? id, Map<String, dynamic> 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<String, dynamic> 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<void> close() async {
await _server.close(force: true);
for (final connection in connections) {
await connection.close();
}
}
}

Map<String, dynamic> _vmResponse(List<String> 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 _versionResponse = <String, dynamic>{
'type': 'Version',
'major': 4,
'minor': 0,
};

const _emptySourceReport = <String, dynamic>{
'type': 'SourceReport',
'ranges': <Object?>[],
'scripts': <Object?>[],
};

void main() {
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 != 'getVersion') {
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 == 'getVersion') {
connection.reply(rpc['id'], _versionResponse);
} else 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': <Object?>[]});
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 != 'getVersion') {
connection.failUnexpectedRpc(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 == 'getVersion') {
connection.reply(rpc['id'], _versionResponse);
} else 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': <Object?>[]});
expect(server.connections.length, 2);
expect(reports, 2);
},
);

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 != 'getVersion') {
connection.failUnexpectedRpc(rpc);
}
await connection.socket.close();
return;
}

if (method == 'getVersion') {
connection.reply(rpc['id'], _versionResponse);
} else 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': <Object?>[]});
expect(server.connections.length, 2);
expect(reports, 1);
});
}
Loading