Skip to content

Commit bef9244

Browse files
bkonyiDanTup
authored andcommitted
[flutter_tools] Fix DTD "Stream already subscribed" error in widget preview
During widget preview startup, concurrent calls to retrieve previews (e.g., initial command startup racing with file watcher events) could both call `_waitForLspService()`, causing concurrent `streamListen` calls to the Dart Tooling Daemon on the `Service` stream. DTD throws JSON-RPC error 103 (`Stream already subscribed`) when a client attempts to subscribe to a stream it is already listening to. This change: - Deduplicates in-flight calls to `_waitForLspService()` using a shared future so concurrent callers await the same LSP registration event instead of issuing duplicate DTD requests. - Safely catches and ignores `RpcErrorCodes.kStreamAlreadySubscribed` on `streamListen` calls in `WidgetPreviewDtdServices`. - Adds hermetic regression tests covering concurrent and pre-subscribed stream scenarios. Fixes flutter#192424
1 parent a89783e commit bef9244

2 files changed

Lines changed: 238 additions & 7 deletions

File tree

‎packages/flutter_tools/lib/src/widget_preview/dtd_services.dart‎

Lines changed: 32 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -33,15 +33,16 @@ typedef DtdService = (String, DTDServiceCallback);
3333
/// Provides services, streams, and RPC invocations to interact with the Widget Preview Scaffold.
3434
class WidgetPreviewDtdServices {
3535
WidgetPreviewDtdServices({
36-
required this.previewAnalytics,
36+
required this.addUuidToServiceName,
37+
required this.dtdLauncher,
3738
required this.fs,
3839
required this.logger,
39-
required this.shutdownHooks,
40-
required this.dtdLauncher,
4140
required this.onHotRestartPreviewerRequest,
41+
required this.previewAnalytics,
4242
required this.project,
43-
required this.addUuidToServiceName,
44-
}) {
43+
required this.shutdownHooks,
44+
@visibleForTesting DartToolingDaemon? dtd,
45+
}) : _dtd = dtd {
4546
shutdownHooks.addShutdownHook(() async {
4647
await _dtd?.close();
4748
await dtdLauncher.dispose();
@@ -213,15 +214,26 @@ class WidgetPreviewDtdServices {
213214
throw StateError('Failed to call getFlutterWidgetPreviewsForFile after $maxAttempts attempts.');
214215
}
215216

217+
Future<void>? _waitForLspServiceFuture;
218+
216219
Future<void> _waitForLspService() async {
217220
if (_lspServiceAvailable) {
218221
return;
219222
}
223+
await (_waitForLspServiceFuture ??= () async {
224+
try {
225+
await _waitForLspServiceHelper();
226+
} finally {
227+
_waitForLspServiceFuture = null;
228+
}
229+
}());
230+
}
220231

232+
Future<void> _waitForLspServiceHelper() async {
221233
final lspRegisteredCompleter = Completer<void>();
222234

223235
const kServiceStream = 'Service';
224-
await _dtd!.streamListen(kServiceStream);
236+
await _dtd!.safeStreamListen(kServiceStream);
225237
final StreamSubscription<DTDEvent> serviceSubscription = _dtd!.onEvent(kServiceStream).listen((
226238
DTDEvent event,
227239
) {
@@ -287,7 +299,7 @@ class WidgetPreviewDtdServices {
287299
}
288300
});
289301
await Future.wait(<Future<void>>[
290-
dtd.streamListen(widgetPreviewScaffoldStream),
302+
dtd.safeStreamListen(widgetPreviewScaffoldStream),
291303
for (final (String method, DTDServiceCallback callback) in services)
292304
dtd
293305
.registerService(widgetPreviewService, method, callback)
@@ -379,3 +391,16 @@ class DtdLauncher {
379391

380392
Process? _dtdProcess;
381393
}
394+
395+
extension on DartToolingDaemon {
396+
/// A [streamListen] implementation that ignores already subscribed exceptions.
397+
Future<void> safeStreamListen(String streamId) async {
398+
try {
399+
await streamListen(streamId);
400+
} on RpcException catch (e) {
401+
if (e.code != RpcErrorCodes.kStreamAlreadySubscribed) {
402+
rethrow;
403+
}
404+
}
405+
}
406+
}
Lines changed: 206 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,206 @@
1+
// Copyright 2014 The Flutter Authors. All rights reserved.
2+
// Use of this source code is governed by a BSD-style license that can be
3+
// found in the LICENSE file.
4+
5+
import 'dart:async';
6+
7+
import 'package:dtd/dtd.dart';
8+
import 'package:file/memory.dart';
9+
import 'package:flutter_tools/src/base/file_system.dart';
10+
import 'package:flutter_tools/src/base/logger.dart';
11+
import 'package:flutter_tools/src/base/process.dart';
12+
import 'package:flutter_tools/src/project.dart';
13+
import 'package:flutter_tools/src/widget_preview/analytics.dart';
14+
import 'package:flutter_tools/src/widget_preview/dtd_services.dart';
15+
import 'package:flutter_tools/src/widget_preview/dtd_types.dart';
16+
import 'package:json_rpc_2/json_rpc_2.dart';
17+
import 'package:test/fake.dart';
18+
19+
import '../../../src/common.dart';
20+
import '../../../src/context.dart';
21+
22+
class FakeWidgetPreviewAnalytics extends Fake implements WidgetPreviewAnalytics {
23+
@override
24+
void reportPreviewerConnected() {}
25+
}
26+
27+
class FakeDtdLauncher extends Fake implements DtdLauncher {
28+
@override
29+
Future<void> dispose() async {}
30+
}
31+
32+
class FakeDartToolingDaemon extends Fake implements DartToolingDaemon {
33+
final _eventControllers = <String, StreamController<DTDEvent>>{};
34+
final subscribedStreams = <String>{};
35+
int getRegisteredServicesCallCount = 0;
36+
int streamListenCallCount = 0;
37+
int streamCancelCallCount = 0;
38+
RegisteredServicesResponse registeredServicesResponse = const RegisteredServicesResponse(
39+
clientServices: [],
40+
dtdServices: <String>[],
41+
);
42+
43+
@override
44+
Future<void> streamListen(String streamId) async {
45+
streamListenCallCount++;
46+
if (subscribedStreams.contains(streamId)) {
47+
throw RpcException(RpcErrorCodes.kStreamAlreadySubscribed, 'Stream already subscribed');
48+
}
49+
subscribedStreams.add(streamId);
50+
}
51+
52+
@override
53+
Future<void> streamCancel(String streamId) async {
54+
streamCancelCallCount++;
55+
if (!subscribedStreams.contains(streamId)) {
56+
throw RpcException(RpcErrorCodes.kStreamNotSubscribed, 'Stream not subscribed');
57+
}
58+
subscribedStreams.remove(streamId);
59+
}
60+
61+
@override
62+
Stream<DTDEvent> onEvent(String streamId) {
63+
return _eventControllers.putIfAbsent(streamId, StreamController<DTDEvent>.broadcast).stream;
64+
}
65+
66+
void postFakeEvent(String streamId, String eventKind, Map<String, Object?> eventData) {
67+
_eventControllers[streamId]?.add(DTDEvent(streamId, eventKind, eventData, 0));
68+
}
69+
70+
@override
71+
Future<RegisteredServicesResponse> getRegisteredServices() async {
72+
getRegisteredServicesCallCount++;
73+
return registeredServicesResponse;
74+
}
75+
76+
@override
77+
Future<DTDResponse> call(
78+
String? serviceName,
79+
String methodName, {
80+
Map<String, Object?>? params,
81+
}) async {
82+
if (serviceName == 'Lsp' &&
83+
(methodName == 'dart/workspace/getFlutterWidgetPreviews' ||
84+
methodName == 'dart/textDocument/getFlutterWidgetPreviews')) {
85+
return DTDResponse('1', 'result', <String, Object?>{
86+
'result': <String, Object?>{
87+
'namespaces': <String, String>{},
88+
'previews': <Map<String, Object?>>[],
89+
'scriptUris': <String>[],
90+
},
91+
});
92+
}
93+
throw UnimplementedError('Unexpected call: $serviceName.$methodName');
94+
}
95+
96+
@override
97+
Future<void> close() async {
98+
for (final StreamController<DTDEvent> controller in _eventControllers.values) {
99+
await controller.close();
100+
}
101+
}
102+
}
103+
104+
void main() {
105+
late FileSystem fs;
106+
late Logger logger;
107+
late ShutdownHooks shutdownHooks;
108+
late FakeDartToolingDaemon fakeDtd;
109+
late FlutterProject project;
110+
late WidgetPreviewDtdServices dtdServices;
111+
112+
setUp(() {
113+
fs = MemoryFileSystem.test();
114+
logger = BufferLogger.test();
115+
shutdownHooks = ShutdownHooks();
116+
fakeDtd = FakeDartToolingDaemon();
117+
project = FlutterProject.fromDirectoryTest(fs.directory('project'));
118+
119+
dtdServices = WidgetPreviewDtdServices(
120+
addUuidToServiceName: false,
121+
dtd: fakeDtd,
122+
dtdLauncher: FakeDtdLauncher(),
123+
fs: fs,
124+
logger: logger,
125+
onHotRestartPreviewerRequest: () {},
126+
previewAnalytics: FakeWidgetPreviewAnalytics(),
127+
project: project,
128+
shutdownHooks: shutdownHooks,
129+
);
130+
});
131+
132+
tearDown(() async {
133+
await fakeDtd.close();
134+
});
135+
136+
testUsingContext(
137+
'concurrent calls to getFlutterWidgetPreviews do not throw stream already subscribed',
138+
() async {
139+
const kServiceStream = 'Service';
140+
141+
final Future<FlutterWidgetPreviews> future1 = dtdServices.getFlutterWidgetPreviews();
142+
final Future<FlutterWidgetPreviews> future2 = dtdServices.getFlutterWidgetPreviews();
143+
144+
// Allow both futures to initiate _waitForLspService and reach the waiting state.
145+
await pumpEventQueue();
146+
147+
// Simulate LSP service registering with DTD.
148+
fakeDtd.postFakeEvent(kServiceStream, 'ServiceRegistered', <String, Object?>{
149+
'service': WidgetPreviewDtdServices.kLspStream,
150+
});
151+
152+
final (FlutterWidgetPreviews result1, FlutterWidgetPreviews result2) = await (
153+
future1,
154+
future2,
155+
).wait;
156+
expect(result1.previews, isEmpty);
157+
expect(result2.previews, isEmpty);
158+
expect(fakeDtd.streamListenCallCount, 1);
159+
expect(fakeDtd.getRegisteredServicesCallCount, 1);
160+
},
161+
);
162+
163+
testUsingContext(
164+
'mixed concurrent calls to getFlutterWidgetPreviews and getFlutterWidgetPreviewsForFile do not throw',
165+
() async {
166+
const kServiceStream = 'Service';
167+
168+
final Future<FlutterWidgetPreviews> future1 = dtdServices.getFlutterWidgetPreviews();
169+
final Future<FlutterWidgetPreviews> future2 = dtdServices.getFlutterWidgetPreviewsForFile(
170+
filePath: fs.path.join('lib', 'main.dart'),
171+
);
172+
173+
await pumpEventQueue();
174+
175+
fakeDtd.postFakeEvent(kServiceStream, 'ServiceRegistered', <String, Object?>{
176+
'service': WidgetPreviewDtdServices.kLspStream,
177+
});
178+
179+
final (FlutterWidgetPreviews result1, FlutterWidgetPreviews result2) = await (
180+
future1,
181+
future2,
182+
).wait;
183+
expect(result1.previews, isEmpty);
184+
expect(result2.previews, isEmpty);
185+
expect(fakeDtd.streamListenCallCount, 1);
186+
expect(fakeDtd.getRegisteredServicesCallCount, 1);
187+
},
188+
);
189+
190+
testUsingContext('getFlutterWidgetPreviews succeeds when stream is already subscribed', () async {
191+
const kServiceStream = 'Service';
192+
193+
// Simulate the stream already being subscribed on DTD prior to calling _waitForLspService.
194+
fakeDtd.subscribedStreams.add(kServiceStream);
195+
196+
final Future<FlutterWidgetPreviews> future = dtdServices.getFlutterWidgetPreviews();
197+
await pumpEventQueue();
198+
199+
fakeDtd.postFakeEvent(kServiceStream, 'ServiceRegistered', <String, Object?>{
200+
'service': WidgetPreviewDtdServices.kLspStream,
201+
});
202+
203+
final FlutterWidgetPreviews result = await future;
204+
expect(result.previews, isEmpty);
205+
});
206+
}

0 commit comments

Comments
 (0)