From c262f775015206f3e4bba6fc4ee896c09b0d9a24 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 21 Oct 2026 13:24:11 +0100 Subject: [PATCH 1/2] feat(app): add Flutter websocket transport --- app/lib/core/transport/pipelines_client.dart | 183 ++++++++++++++++++ app/lib/core/transport/server_url.dart | 47 +++++ app/notes/F1.md | 13 ++ .../core/transport/pipelines_client_test.dart | 78 ++++++++ app/test/core/transport/server_url_test.dart | 23 +++ 5 files changed, 344 insertions(+) create mode 100644 app/lib/core/transport/pipelines_client.dart create mode 100644 app/lib/core/transport/server_url.dart create mode 100644 app/notes/F1.md create mode 100644 app/test/core/transport/pipelines_client_test.dart create mode 100644 app/test/core/transport/server_url_test.dart diff --git a/app/lib/core/transport/pipelines_client.dart b/app/lib/core/transport/pipelines_client.dart new file mode 100644 index 00000000..923b66f3 --- /dev/null +++ b/app/lib/core/transport/pipelines_client.dart @@ -0,0 +1,183 @@ +import 'dart:async'; +import 'dart:convert'; + +import 'package:web_socket_channel/web_socket_channel.dart'; + +import '../api_gateway.dart'; +import 'server_url.dart'; + +enum ConnectionKind { idle, connecting, connected, disconnected } + +class ConnectionState { + const ConnectionState(this.kind, {this.attempt = 0, this.reason = '', this.retrying = false}); + final ConnectionKind kind; + final int attempt; + final String reason; + final bool retrying; +} + +class ProtocolError implements Exception { + const ProtocolError(this.message); + final String message; + @override + String toString() => message; +} + +class NotConnectedError implements Exception { + const NotConnectedError(); + @override + String toString() => 'Not connected to the Pipelines server'; +} + +typedef ChannelFactory = WebSocketChannel Function(Uri uri); + +/// One correlated websocket transport shared by all feature gateways. +class PipelinesClient implements ApiGateway { + PipelinesClient({ChannelFactory? channelFactory, + this.requestTimeout = const Duration(seconds: 30), + this.backoffBase = const Duration(seconds: 1), + this.backoffMax = const Duration(seconds: 30)}) : _factory = channelFactory ?? WebSocketChannel.connect; + + final ChannelFactory _factory; + final Duration requestTimeout, backoffBase, backoffMax; + final _frames = StreamController.broadcast(); + final _states = StreamController.broadcast(); + final Map> _pending = {}; + WebSocketChannel? _channel; + StreamSubscription? _subscription; + Uri? _endpoint; + Timer? _reconnect; + int _generation = 0, _sequence = 0, _attempt = 0; + bool _manual = true, _disposed = false; + ConnectionState _state = const ConnectionState(ConnectionKind.idle); + Future _queue = Future.value(); + + @override + Stream get frames => _frames.stream; + Stream get states => _states.stream; + ConnectionState get state => _state; + + Future connect(Uri uri) async { + if (_disposed) throw StateError('Client has been disposed'); + final endpoint = ServerUrl.validate(uri.toString()); + _endpoint = Uri.parse(endpoint.wsUrl); + _manual = false; + _attempt = 0; + _reconnect?.cancel(); + await _open(); + } + + Future _open() async { + final endpoint = _endpoint; + if (endpoint == null || _disposed) return; + final generation = ++_generation; + _setState(ConnectionState(ConnectionKind.connecting, attempt: ++_attempt)); + final old = _channel; + _channel = null; + await _subscription?.cancel(); + _failPending('Connection replaced'); + if (old != null) unawaited(old.sink.close()); + try { + final channel = _factory(endpoint); + _channel = channel; + _subscription = channel.stream.listen((data) { + if (generation == _generation) _onMessage(data); + }, onError: (Object error) { + if (generation == _generation) _closed(error.toString()); + }, onDone: () { + if (generation == _generation) _closed('Connection closed'); + }); + await channel.ready; + if (generation != _generation) return; + _attempt = 0; + _setState(const ConnectionState(ConnectionKind.connected)); + } catch (error) { + if (generation == _generation) _closed(error.toString()); + } + } + + void _setState(ConnectionState value) { _state = value; if (!_states.isClosed) _states.add(value); } + + @override + Future call(String type, [JsonMap fields = const {}]) { + final completer = Completer(); + final run = _queue.then((_) => _sendCall(type, fields, completer)); + _queue = run.catchError((_) {}); + return completer.future; + } + + Future _sendCall(String type, JsonMap fields, Completer result) async { + final channel = _channel; + if (channel == null || _state.kind != ConnectionKind.connected) { result.completeError(const NotConnectedError()); return; } + final id = 'flutter-${++_sequence}'; + _pending[id] = result; + final timer = Timer(requestTimeout, () { + if (_pending.remove(id) != null) result.completeError(TimeoutException('request timed out after ${requestTimeout.inMilliseconds}ms')); + }); + result.future.then((_) => timer.cancel(), onError: (Object error, StackTrace stack) => timer.cancel()); + try { + channel.sink.add(jsonEncode({...fields, 'type': type, 'id': id})); + } catch (error) { + timer.cancel(); + if (_pending.remove(id) != null) result.completeError(error); + } + } + + String sendOnly(String type, [JsonMap fields = const {}]) { + final channel = _channel; + if (channel == null || _state.kind != ConnectionKind.connected) throw const NotConnectedError(); + final id = 'flutter-${++_sequence}'; + channel.sink.add(jsonEncode({...fields, 'type': type, 'id': id})); + return id; + } + + void _onMessage(dynamic data) { + if (data is! String) return; + final Object? decoded; + try { decoded = jsonDecode(data); } on FormatException { return; } + if (decoded is! Map) return; + final message = decoded; + final id = message['id']; + final pending = id is String ? _pending.remove(id) : null; + if (pending != null) { + if (message['type'] == 'error') { + final reason = (message['error'] as String? ?? '').trim(); + pending.completeError(ProtocolError(reason.isEmpty ? 'server error' : reason)); + } else { + pending.complete(message); + } + } else if (!_frames.isClosed) { _frames.add(message); } + } + + void _failPending(String reason) { + final values = _pending.values.toList(); _pending.clear(); + for (final item in values) { if (!item.isCompleted) item.completeError(StateError(reason)); } + } + + void _closed(String reason) { + _generation++; + _channel = null; + _failPending(reason); + if (_manual || _disposed) { _setState(const ConnectionState(ConnectionKind.idle)); return; } + _setState(ConnectionState(ConnectionKind.disconnected, attempt: _attempt, reason: reason, retrying: true)); + final shift = (_attempt - 1).clamp(0, 6); + final delay = backoffBase * (1 << shift); + _reconnect?.cancel(); + _reconnect = Timer(delay > backoffMax ? backoffMax : delay, () => unawaited(_open())); + } + + Future disconnect() async { + _manual = true; _reconnect?.cancel(); _generation++; + final channel = _channel; _channel = null; + await _subscription?.cancel(); _subscription = null; + _failPending('Disconnected'); + if (channel != null) await channel.sink.close(); + _setState(const ConnectionState(ConnectionKind.idle)); + } + + Future dispose() async { + if (_disposed) return; + await disconnect(); _disposed = true; + await _frames.close(); await _states.close(); + } +} diff --git a/app/lib/core/transport/server_url.dart b/app/lib/core/transport/server_url.dart new file mode 100644 index 00000000..7f2eb59b --- /dev/null +++ b/app/lib/core/transport/server_url.dart @@ -0,0 +1,47 @@ +/// Validation result for a configured Pipelines websocket endpoint. +class ServerUrl { + const ServerUrl._({required this.wsUrl, required this.httpUrl, + required this.host, required this.port, required this.secure}); + + final String wsUrl; + final String httpUrl; + final String host; + final int port; + final bool secure; + + static ServerUrl validate(String raw) { + final value = raw.trim(); + if (value.isEmpty) throw const FormatException('Enter the Pipelines server URL, for example ws://192.168.1.20:8081/connect'); + final uri = Uri.tryParse(value); + if (uri == null || !uri.hasScheme) throw const FormatException('That is not a valid URL.'); + final scheme = uri.scheme.toLowerCase(); + if (scheme != 'ws' && scheme != 'wss') { + throw FormatException('Unsupported scheme "$scheme"; use ws:// (trusted LAN/VPN) or wss://'); + } + if (uri.userInfo.isNotEmpty) throw const FormatException('Credentials are not supported; the server has no authentication. Remove userinfo from the URL'); + if (uri.hasFragment) throw const FormatException('Remove the # fragment; it is not part of the server endpoint'); + if (uri.host.isEmpty) throw const FormatException('The URL is missing a host, for example ws://192.168.1.20:8081/connect'); + final secure = scheme == 'wss'; + final port = uri.hasPort ? uri.port : secure ? 443 : 80; + final path = uri.path.isEmpty || uri.path == '/' ? '/connect' : uri.path; + final authority = uri.hasPort ? '${uri.host}:$port' : uri.host; + final suffix = uri.hasQuery ? '?${uri.query}' : ''; + return ServerUrl._(wsUrl: '$scheme://$authority$path$suffix', + httpUrl: '${secure ? 'https' : 'http'}://$authority$path$suffix', + host: uri.host, port: port, secure: secure); + } + + static Uri? resolveArtifactUrl(String configured, String artifactUrl) { + final path = artifactUrl.trim(); + if (path.isEmpty) return null; + final parsed = Uri.tryParse(path); + if (parsed != null && (parsed.scheme == 'http' || parsed.scheme == 'https')) return parsed; + try { + final endpoint = validate(configured); + final portPart = endpoint.port != (endpoint.secure ? 443 : 80) ? ':${endpoint.port}' : ''; + return Uri.parse('${endpoint.secure ? 'https' : 'http'}://${endpoint.host}$portPart/${path.replaceFirst(RegExp(r'^/+'), '')}'); + } on FormatException { + return null; + } + } +} diff --git a/app/notes/F1.md b/app/notes/F1.md new file mode 100644 index 00000000..269e2685 --- /dev/null +++ b/app/notes/F1.md @@ -0,0 +1,13 @@ +# F1 transport + +`PipelinesClient` implements the shared `ApiGateway` contract using one +`web_socket_channel` connection, correlated JSON replies, timeout handling, +unsolicited envelope broadcast, and reconnect with capped exponential backoff. +The URL helper validates ws/wss endpoints and resolves artifact URLs. + +Manager integration import: `package:pipelines_app/core/transport/pipelines_client.dart`; +endpoint helper: `package:pipelines_app/core/transport/server_url.dart`. + +The client accepts an injected `ChannelFactory` for deterministic tests. No live +server was used. Browser and mobile target verification should be reported +separately from these unit tests. diff --git a/app/test/core/transport/pipelines_client_test.dart b/app/test/core/transport/pipelines_client_test.dart new file mode 100644 index 00000000..01840d05 --- /dev/null +++ b/app/test/core/transport/pipelines_client_test.dart @@ -0,0 +1,78 @@ +import 'dart:async'; +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/transport/pipelines_client.dart'; +import 'package:web_socket_channel/web_socket_channel.dart'; + +class FakeChannel implements WebSocketChannel { + final incoming = StreamController(); + final outgoing = []; + final readyCompleter = Completer(); + @override + Stream get stream => incoming.stream; + @override + WebSocketSink get sink => FakeSink(outgoing, incoming); + @override + Future get ready => readyCompleter.future; + @override + String? get protocol => null; + @override + int? get closeCode => null; + @override + String? get closeReason => null; + @override + noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation); +} + +class FakeSink implements WebSocketSink { + FakeSink(this.outgoing, this.incoming); + final List outgoing; + final StreamController incoming; + @override + void add(dynamic event) => outgoing.add(event); + @override + void addError(Object error, [StackTrace? stackTrace]) => throw error; + @override + Future addStream(Stream stream) async { await for (final item in stream) { add(item); } } + @override + Future close([int? closeCode, String? closeReason]) async { await incoming.close(); } + @override + Future get done async {} + @override + noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation); +} + +void main() { + test('correlates replies and broadcasts unclaimed frames', () async { + final channel = FakeChannel(); + final client = PipelinesClient(channelFactory: (_) => channel); + final frames = >[]; + client.frames.listen(frames.add); + final connecting = client.connect(Uri.parse('ws://example.test')); + channel.readyCompleter.complete(); + await connecting; + final request = client.call('ping', {'value': 1}); + await Future.delayed(Duration.zero); + final sent = jsonDecode(channel.outgoing.single as String) as Map; + channel.incoming.add(jsonEncode({'id': sent['id'], 'type': 'pong'})); + expect((await request)['type'], 'pong'); + channel.incoming.add(jsonEncode({'type': 'run_event'})); + await Future.delayed(Duration.zero); + expect(frames.single['type'], 'run_event'); + await client.dispose(); + }); + + test('disconnect fails pending requests', () async { + final channel = FakeChannel(); + final client = PipelinesClient(channelFactory: (_) => channel); + final connecting = client.connect(Uri.parse('ws://example.test')); + channel.readyCompleter.complete(); + await connecting; + final pending = client.call('ping'); + await Future.delayed(Duration.zero); + await client.disconnect(); + await expectLater(pending, throwsA(isA())); + await client.dispose(); + }); +} diff --git a/app/test/core/transport/server_url_test.dart b/app/test/core/transport/server_url_test.dart new file mode 100644 index 00000000..b7773d31 --- /dev/null +++ b/app/test/core/transport/server_url_test.dart @@ -0,0 +1,23 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/transport/server_url.dart'; + +void main() { + test('validates and normalizes endpoint with path and query', () { + final value = ServerUrl.validate(' wss://example.test:8443/?token=x '); + expect(value.wsUrl, 'wss://example.test:8443/connect?token=x'); + expect(value.httpUrl, 'https://example.test:8443/connect?token=x'); + expect(value.secure, isTrue); + }); + + test('rejects unsupported schemes and credentials', () { + expect(() => ServerUrl.validate('https://example.test'), throwsFormatException); + expect(() => ServerUrl.validate('ws://user:pass@example.test'), throwsFormatException); + }); + + test('resolves relative artifacts at the server origin', () { + expect(ServerUrl.resolveArtifactUrl('ws://example.test:8081/connect', '/artifacts/a')!.toString(), + 'http://example.test:8081/artifacts/a'); + expect(ServerUrl.resolveArtifactUrl('', '/artifacts/a'), isNull); + expect(ServerUrl.resolveArtifactUrl('', 'https://cdn.test/a')!.toString(), 'https://cdn.test/a'); + }); +} From 1e4ecea82390e043f18664fc15705726b9eafbbd Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 21 Oct 2026 13:28:59 +0100 Subject: [PATCH 2/2] fix(app): harden socket lifecycle and expand transport regressions --- app/lib/core/transport/connection_state.dart | 27 +++ app/lib/core/transport/pipelines_client.dart | 171 ++++++++++++------ app/lib/core/transport/server_url.dart | 77 ++++++-- app/notes/F1.md | 8 + .../transport/client_regression_test.dart | 144 +++++++++++++++ .../core/transport/pipelines_client_test.dart | 15 +- app/test/core/transport/server_url_test.dart | 38 +++- 7 files changed, 401 insertions(+), 79 deletions(-) create mode 100644 app/lib/core/transport/connection_state.dart create mode 100644 app/test/core/transport/client_regression_test.dart diff --git a/app/lib/core/transport/connection_state.dart b/app/lib/core/transport/connection_state.dart new file mode 100644 index 00000000..f8d6d32f --- /dev/null +++ b/app/lib/core/transport/connection_state.dart @@ -0,0 +1,27 @@ +enum ConnectionKind { idle, connecting, connected, disconnected } + +class ConnectionState { + const ConnectionState( + this.kind, { + this.attempt = 0, + this.reason = '', + this.retrying = false, + }); + final ConnectionKind kind; + final int attempt; + final String reason; + final bool retrying; +} + +class ProtocolError implements Exception { + const ProtocolError(this.message); + final String message; + @override + String toString() => message; +} + +class NotConnectedError implements Exception { + const NotConnectedError(); + @override + String toString() => 'Not connected to the Pipelines server'; +} diff --git a/app/lib/core/transport/pipelines_client.dart b/app/lib/core/transport/pipelines_client.dart index 923b66f3..dfdeacf0 100644 --- a/app/lib/core/transport/pipelines_client.dart +++ b/app/lib/core/transport/pipelines_client.dart @@ -4,39 +4,21 @@ import 'dart:convert'; import 'package:web_socket_channel/web_socket_channel.dart'; import '../api_gateway.dart'; +import 'connection_state.dart'; import 'server_url.dart'; -enum ConnectionKind { idle, connecting, connected, disconnected } - -class ConnectionState { - const ConnectionState(this.kind, {this.attempt = 0, this.reason = '', this.retrying = false}); - final ConnectionKind kind; - final int attempt; - final String reason; - final bool retrying; -} - -class ProtocolError implements Exception { - const ProtocolError(this.message); - final String message; - @override - String toString() => message; -} - -class NotConnectedError implements Exception { - const NotConnectedError(); - @override - String toString() => 'Not connected to the Pipelines server'; -} +export 'connection_state.dart'; typedef ChannelFactory = WebSocketChannel Function(Uri uri); /// One correlated websocket transport shared by all feature gateways. class PipelinesClient implements ApiGateway { - PipelinesClient({ChannelFactory? channelFactory, + PipelinesClient({ + ChannelFactory? channelFactory, this.requestTimeout = const Duration(seconds: 30), this.backoffBase = const Duration(seconds: 1), - this.backoffMax = const Duration(seconds: 30)}) : _factory = channelFactory ?? WebSocketChannel.connect; + this.backoffMax = const Duration(seconds: 30), + }) : _factory = channelFactory ?? WebSocketChannel.connect; final ChannelFactory _factory; final Duration requestTimeout, backoffBase, backoffMax; @@ -74,19 +56,26 @@ class PipelinesClient implements ApiGateway { _setState(ConnectionState(ConnectionKind.connecting, attempt: ++_attempt)); final old = _channel; _channel = null; - await _subscription?.cancel(); _failPending('Connection replaced'); if (old != null) unawaited(old.sink.close()); + final subscription = _subscription; + _subscription = null; + await subscription?.cancel(); + if (generation != _generation || _manual || _disposed) return; try { final channel = _factory(endpoint); _channel = channel; - _subscription = channel.stream.listen((data) { - if (generation == _generation) _onMessage(data); - }, onError: (Object error) { - if (generation == _generation) _closed(error.toString()); - }, onDone: () { - if (generation == _generation) _closed('Connection closed'); - }); + _subscription = channel.stream.listen( + (data) { + if (generation == _generation) _onMessage(data); + }, + onError: (Object error) { + if (generation == _generation) _closed(error.toString()); + }, + onDone: () { + if (generation == _generation) _closed('Connection closed'); + }, + ); await channel.ready; if (generation != _generation) return; _attempt = 0; @@ -96,36 +85,72 @@ class PipelinesClient implements ApiGateway { } } - void _setState(ConnectionState value) { _state = value; if (!_states.isClosed) _states.add(value); } + void _setState(ConnectionState value) { + _state = value; + if (!_states.isClosed) _states.add(value); + } @override Future call(String type, [JsonMap fields = const {}]) { final completer = Completer(); - final run = _queue.then((_) => _sendCall(type, fields, completer)); + final generation = _generation; + final snapshot = Map.of(fields); + final run = _queue.then( + (_) => _sendCall(type, snapshot, completer, generation), + ); _queue = run.catchError((_) {}); return completer.future; } - Future _sendCall(String type, JsonMap fields, Completer result) async { + Future _sendCall( + String type, + JsonMap fields, + Completer result, + int generation, + ) async { + if (generation != _generation) { + result.completeError(StateError('Connection replaced')); + return; + } final channel = _channel; - if (channel == null || _state.kind != ConnectionKind.connected) { result.completeError(const NotConnectedError()); return; } + if (channel == null || _state.kind != ConnectionKind.connected) { + result.completeError(const NotConnectedError()); + return; + } final id = 'flutter-${++_sequence}'; _pending[id] = result; final timer = Timer(requestTimeout, () { - if (_pending.remove(id) != null) result.completeError(TimeoutException('request timed out after ${requestTimeout.inMilliseconds}ms')); + if (_pending.remove(id) != null) { + result.completeError( + TimeoutException( + 'request timed out after ${requestTimeout.inMilliseconds}ms', + ), + ); + } }); - result.future.then((_) => timer.cancel(), onError: (Object error, StackTrace stack) => timer.cancel()); + result.future.then( + (_) => timer.cancel(), + onError: (Object error, StackTrace stack) => timer.cancel(), + ); try { channel.sink.add(jsonEncode({...fields, 'type': type, 'id': id})); } catch (error) { timer.cancel(); if (_pending.remove(id) != null) result.completeError(error); } + // Match the existing client's serialized request semantics, even on errors. + try { + await result.future; + } catch (_) { + /* The caller receives the error. */ + } } String sendOnly(String type, [JsonMap fields = const {}]) { final channel = _channel; - if (channel == null || _state.kind != ConnectionKind.connected) throw const NotConnectedError(); + if (channel == null || _state.kind != ConnectionKind.connected) { + throw const NotConnectedError(); + } final id = 'flutter-${++_sequence}'; channel.sink.add(jsonEncode({...fields, 'type': type, 'id': id})); return id; @@ -134,50 +159,88 @@ class PipelinesClient implements ApiGateway { void _onMessage(dynamic data) { if (data is! String) return; final Object? decoded; - try { decoded = jsonDecode(data); } on FormatException { return; } + try { + decoded = jsonDecode(data); + } on FormatException { + return; + } if (decoded is! Map) return; final message = decoded; final id = message['id']; final pending = id is String ? _pending.remove(id) : null; if (pending != null) { if (message['type'] == 'error') { - final reason = (message['error'] as String? ?? '').trim(); - pending.completeError(ProtocolError(reason.isEmpty ? 'server error' : reason)); + final reason = '${message['error'] ?? ''}'.trim(); + pending.completeError( + ProtocolError(reason.isEmpty ? 'server error' : reason), + ); } else { pending.complete(message); } - } else if (!_frames.isClosed) { _frames.add(message); } + } else if (!_frames.isClosed) { + _frames.add(message); + } } void _failPending(String reason) { - final values = _pending.values.toList(); _pending.clear(); - for (final item in values) { if (!item.isCompleted) item.completeError(StateError(reason)); } + final values = _pending.values.toList(); + _pending.clear(); + for (final item in values) { + if (!item.isCompleted) item.completeError(StateError(reason)); + } } void _closed(String reason) { _generation++; + final channel = _channel; + final subscription = _subscription; _channel = null; + _subscription = null; + if (subscription != null) unawaited(subscription.cancel()); + if (channel != null) unawaited(channel.sink.close().catchError((_) {})); _failPending(reason); - if (_manual || _disposed) { _setState(const ConnectionState(ConnectionKind.idle)); return; } - _setState(ConnectionState(ConnectionKind.disconnected, attempt: _attempt, reason: reason, retrying: true)); + if (_manual || _disposed) { + _setState(const ConnectionState(ConnectionKind.idle)); + return; + } + _setState( + ConnectionState( + ConnectionKind.disconnected, + attempt: _attempt, + reason: reason, + retrying: true, + ), + ); final shift = (_attempt - 1).clamp(0, 6); final delay = backoffBase * (1 << shift); _reconnect?.cancel(); - _reconnect = Timer(delay > backoffMax ? backoffMax : delay, () => unawaited(_open())); + _reconnect = Timer( + delay > backoffMax ? backoffMax : delay, + () => unawaited(_open()), + ); } Future disconnect() async { - _manual = true; _reconnect?.cancel(); _generation++; - final channel = _channel; _channel = null; - await _subscription?.cancel(); _subscription = null; + _manual = true; + _reconnect?.cancel(); + final generation = ++_generation; + final channel = _channel; + _channel = null; + final subscription = _subscription; + _subscription = null; _failPending('Disconnected'); + await subscription?.cancel(); if (channel != null) await channel.sink.close(); - _setState(const ConnectionState(ConnectionKind.idle)); + if (generation == _generation) { + _setState(const ConnectionState(ConnectionKind.idle)); + } } Future dispose() async { if (_disposed) return; - await disconnect(); _disposed = true; - await _frames.close(); await _states.close(); + _disposed = true; + await disconnect(); + await _frames.close(); + await _states.close(); } } diff --git a/app/lib/core/transport/server_url.dart b/app/lib/core/transport/server_url.dart index 7f2eb59b..b08a10ac 100644 --- a/app/lib/core/transport/server_url.dart +++ b/app/lib/core/transport/server_url.dart @@ -1,7 +1,12 @@ /// Validation result for a configured Pipelines websocket endpoint. class ServerUrl { - const ServerUrl._({required this.wsUrl, required this.httpUrl, - required this.host, required this.port, required this.secure}); + const ServerUrl._({ + required this.wsUrl, + required this.httpUrl, + required this.host, + required this.port, + required this.secure, + }); final String wsUrl; final String httpUrl; @@ -11,35 +16,73 @@ class ServerUrl { static ServerUrl validate(String raw) { final value = raw.trim(); - if (value.isEmpty) throw const FormatException('Enter the Pipelines server URL, for example ws://192.168.1.20:8081/connect'); + if (value.isEmpty) { + throw const FormatException( + 'Enter the Pipelines server URL, for example ws://192.168.1.20:8081/connect', + ); + } final uri = Uri.tryParse(value); - if (uri == null || !uri.hasScheme) throw const FormatException('That is not a valid URL.'); + if (uri == null || !uri.hasScheme) { + throw const FormatException('That is not a valid URL.'); + } final scheme = uri.scheme.toLowerCase(); if (scheme != 'ws' && scheme != 'wss') { - throw FormatException('Unsupported scheme "$scheme"; use ws:// (trusted LAN/VPN) or wss://'); + throw FormatException( + 'Unsupported scheme "$scheme"; use ws:// (trusted LAN/VPN) or wss://', + ); + } + if (uri.userInfo.isNotEmpty) { + throw const FormatException( + 'Credentials are not supported; the server has no authentication. Remove userinfo from the URL', + ); + } + if (uri.hasFragment) { + throw const FormatException( + 'Remove the # fragment; it is not part of the server endpoint', + ); + } + if (uri.host.isEmpty) { + throw const FormatException( + 'The URL is missing a host, for example ws://192.168.1.20:8081/connect', + ); + } + if (!uri.hasAuthority || + (uri.hasPort && (uri.port < 1 || uri.port > 65535))) { + throw const FormatException( + 'That is not a valid server authority or port.', + ); } - if (uri.userInfo.isNotEmpty) throw const FormatException('Credentials are not supported; the server has no authentication. Remove userinfo from the URL'); - if (uri.hasFragment) throw const FormatException('Remove the # fragment; it is not part of the server endpoint'); - if (uri.host.isEmpty) throw const FormatException('The URL is missing a host, for example ws://192.168.1.20:8081/connect'); final secure = scheme == 'wss'; - final port = uri.hasPort ? uri.port : secure ? 443 : 80; + final port = uri.hasPort + ? uri.port + : secure + ? 443 + : 80; final path = uri.path.isEmpty || uri.path == '/' ? '/connect' : uri.path; - final authority = uri.hasPort ? '${uri.host}:$port' : uri.host; - final suffix = uri.hasQuery ? '?${uri.query}' : ''; - return ServerUrl._(wsUrl: '$scheme://$authority$path$suffix', - httpUrl: '${secure ? 'https' : 'http'}://$authority$path$suffix', - host: uri.host, port: port, secure: secure); + final normalized = uri.replace(scheme: scheme, path: path); + return ServerUrl._( + wsUrl: normalized.toString(), + httpUrl: normalized.replace(scheme: secure ? 'https' : 'http').toString(), + host: uri.host, + port: port, + secure: secure, + ); } static Uri? resolveArtifactUrl(String configured, String artifactUrl) { final path = artifactUrl.trim(); if (path.isEmpty) return null; final parsed = Uri.tryParse(path); - if (parsed != null && (parsed.scheme == 'http' || parsed.scheme == 'https')) return parsed; + if (parsed != null && + (parsed.scheme == 'http' || parsed.scheme == 'https')) { + return parsed; + } try { final endpoint = validate(configured); - final portPart = endpoint.port != (endpoint.secure ? 443 : 80) ? ':${endpoint.port}' : ''; - return Uri.parse('${endpoint.secure ? 'https' : 'http'}://${endpoint.host}$portPart/${path.replaceFirst(RegExp(r'^/+'), '')}'); + final origin = Uri.parse( + endpoint.httpUrl, + ).replace(path: '/', query: null); + return origin.resolve(path.replaceFirst(RegExp(r'^/+'), '')); } on FormatException { return null; } diff --git a/app/notes/F1.md b/app/notes/F1.md index 269e2685..3b8504b0 100644 --- a/app/notes/F1.md +++ b/app/notes/F1.md @@ -11,3 +11,11 @@ endpoint helper: `package:pipelines_app/core/transport/server_url.dart`. The client accepts an injected `ChannelFactory` for deterministic tests. No live server was used. Browser and mobile target verification should be reported separately from these unit tests. + +## Manager verification +Expanded to 12 focused tests, including serialized requests, queue recovery +after protocol errors/timeouts, late replies, replacement of queued requests, +send-only subscriptions, concurrent connects, reconnect and disposal. Corrected +generation races and socket cleanup; URI construction now retains bracketed +IPv6 hosts and encoded artifact query strings. Analyze passes after formatting. +These are unit checks, not browser/live-server acceptance or mobile verification. diff --git a/app/test/core/transport/client_regression_test.dart b/app/test/core/transport/client_regression_test.dart new file mode 100644 index 00000000..2409ac5b --- /dev/null +++ b/app/test/core/transport/client_regression_test.dart @@ -0,0 +1,144 @@ +import 'dart:async'; +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/transport/pipelines_client.dart'; + +import 'pipelines_client_test.dart' show FakeChannel; + +Future flush() => Future.delayed(Duration.zero); +Map sent(FakeChannel channel, [int index = 0]) => + jsonDecode(channel.outgoing[index] as String) as Map; +void reply(FakeChannel channel, {int index = 0, String type = 'pong'}) => + channel.incoming.add( + jsonEncode({'id': sent(channel, index)['id'], 'type': type}), + ); + +void main() { + test( + 'requests serialize through replies, errors do not poison queue', + () async { + final channel = FakeChannel()..readyCompleter.complete(); + final client = PipelinesClient(channelFactory: (_) => channel); + await client.connect(Uri.parse('ws://example.test')); + final first = client.call('ping'); + final firstError = expectLater(first, throwsA(isA())); + final second = client.call('list_runs'); + await flush(); + expect(channel.outgoing, hasLength(1)); + channel.incoming.add( + jsonEncode({ + 'id': sent(channel)['id'], + 'type': 'error', + 'error': 'refused', + }), + ); + await firstError; + await flush(); + expect(channel.outgoing, hasLength(2)); + reply(channel, index: 1, type: 'runs'); + expect((await second)['type'], 'runs'); + await client.dispose(); + }, + ); + + test( + 'timeout releases queue and late response is an unsolicited frame', + () async { + final channel = FakeChannel()..readyCompleter.complete(); + final client = PipelinesClient( + channelFactory: (_) => channel, + requestTimeout: const Duration(milliseconds: 10), + ); + await client.connect(Uri.parse('ws://example.test')); + await expectLater(client.call('ping'), throwsA(isA())); + final late = client.frames.first; + reply(channel); + expect((await late)['type'], 'pong'); + await client.dispose(); + }, + ); + + test( + 'replacement fails queued calls rather than sending on new socket', + () async { + final channels = [ + FakeChannel()..readyCompleter.complete(), + FakeChannel()..readyCompleter.complete(), + ]; + var index = 0; + final client = PipelinesClient(channelFactory: (_) => channels[index++]); + await client.connect(Uri.parse('ws://old.test')); + final firstError = expectLater(client.call('ping'), throwsStateError); + final queuedError = expectLater( + client.call('list_runs'), + throwsStateError, + ); + await flush(); + await client.connect(Uri.parse('ws://new.test')); + await Future.wait([firstError, queuedError]); + expect(channels.last.outgoing, isEmpty); + expect(client.state.kind, ConnectionKind.connected); + await client.dispose(); + }, + ); + + test('sendOnly never blocks correlated requests', () async { + final channel = FakeChannel()..readyCompleter.complete(); + final client = PipelinesClient(channelFactory: (_) => channel); + await client.connect(Uri.parse('ws://example.test')); + client.sendOnly('subscribe', {'workspace': ''}); + final ping = client.call('ping'); + await flush(); + expect(sent(channel)['type'], 'subscribe'); + reply(channel, index: 1); + expect((await ping)['type'], 'pong'); + await client.dispose(); + }); + + test('overlapping connect cannot create a superseded socket', () async { + var factories = 0; + final channel = FakeChannel()..readyCompleter.complete(); + final client = PipelinesClient( + channelFactory: (_) { + factories++; + return channel; + }, + ); + await Future.wait([ + client.connect(Uri.parse('ws://old.test')), + client.connect(Uri.parse('ws://new.test')), + ]); + expect(factories, 1); + expect(client.state.kind, ConnectionKind.connected); + await client.dispose(); + await expectLater( + client.connect(Uri.parse('ws://new.test')), + throwsStateError, + ); + }); + + test('socket failure reconnects, disconnect cancels retry', () async { + final first = FakeChannel()..readyCompleter.complete(); + final next = FakeChannel()..readyCompleter.complete(); + var factories = 0; + final client = PipelinesClient( + channelFactory: (_) => factories++ == 0 ? first : next, + backoffBase: const Duration(milliseconds: 5), + ); + await client.connect(Uri.parse('ws://example.test')); + final connectedAgain = client.states.firstWhere( + (s) => s.kind == ConnectionKind.connected, + ); + first.incoming.addError(StateError('network drop')); + await connectedAgain.timeout(const Duration(seconds: 2)); + expect(factories, 2); + await client.disconnect(); + expect(client.state.retrying, isFalse); + expect( + () => client.sendOnly('subscribe'), + throwsA(isA()), + ); + await client.dispose(); + }); +} diff --git a/app/test/core/transport/pipelines_client_test.dart b/app/test/core/transport/pipelines_client_test.dart index 01840d05..e71b78f6 100644 --- a/app/test/core/transport/pipelines_client_test.dart +++ b/app/test/core/transport/pipelines_client_test.dart @@ -34,9 +34,17 @@ class FakeSink implements WebSocketSink { @override void addError(Object error, [StackTrace? stackTrace]) => throw error; @override - Future addStream(Stream stream) async { await for (final item in stream) { add(item); } } + Future addStream(Stream stream) async { + await for (final item in stream) { + add(item); + } + } + @override - Future close([int? closeCode, String? closeReason]) async { await incoming.close(); } + Future close([int? closeCode, String? closeReason]) async { + await incoming.close(); + } + @override Future get done async {} @override @@ -54,7 +62,8 @@ void main() { await connecting; final request = client.call('ping', {'value': 1}); await Future.delayed(Duration.zero); - final sent = jsonDecode(channel.outgoing.single as String) as Map; + final sent = + jsonDecode(channel.outgoing.single as String) as Map; channel.incoming.add(jsonEncode({'id': sent['id'], 'type': 'pong'})); expect((await request)['type'], 'pong'); channel.incoming.add(jsonEncode({'type': 'run_event'})); diff --git a/app/test/core/transport/server_url_test.dart b/app/test/core/transport/server_url_test.dart index b7773d31..e2634f99 100644 --- a/app/test/core/transport/server_url_test.dart +++ b/app/test/core/transport/server_url_test.dart @@ -2,6 +2,20 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/core/transport/server_url.dart'; void main() { + test('IPv6 authorities and encoded artifact queries stay intact', () { + expect( + ServerUrl.validate('ws://[::1]:8081').wsUrl, + 'ws://[::1]:8081/connect', + ); + expect( + ServerUrl.resolveArtifactUrl( + 'ws://[::1]:8081/connect', + '/artifacts/a%20b?download=1', + ).toString(), + 'http://[::1]:8081/artifacts/a%20b?download=1', + ); + expect(() => ServerUrl.validate('ws://host:70000'), throwsFormatException); + }); test('validates and normalizes endpoint with path and query', () { final value = ServerUrl.validate(' wss://example.test:8443/?token=x '); expect(value.wsUrl, 'wss://example.test:8443/connect?token=x'); @@ -10,14 +24,28 @@ void main() { }); test('rejects unsupported schemes and credentials', () { - expect(() => ServerUrl.validate('https://example.test'), throwsFormatException); - expect(() => ServerUrl.validate('ws://user:pass@example.test'), throwsFormatException); + expect( + () => ServerUrl.validate('https://example.test'), + throwsFormatException, + ); + expect( + () => ServerUrl.validate('ws://user:pass@example.test'), + throwsFormatException, + ); }); test('resolves relative artifacts at the server origin', () { - expect(ServerUrl.resolveArtifactUrl('ws://example.test:8081/connect', '/artifacts/a')!.toString(), - 'http://example.test:8081/artifacts/a'); + expect( + ServerUrl.resolveArtifactUrl( + 'ws://example.test:8081/connect', + '/artifacts/a', + )!.toString(), + 'http://example.test:8081/artifacts/a', + ); expect(ServerUrl.resolveArtifactUrl('', '/artifacts/a'), isNull); - expect(ServerUrl.resolveArtifactUrl('', 'https://cdn.test/a')!.toString(), 'https://cdn.test/a'); + expect( + ServerUrl.resolveArtifactUrl('', 'https://cdn.test/a')!.toString(), + 'https://cdn.test/a', + ); }); }