Files
SpotiFLAC-Mobile/test/network_smb_memory_test.dart
zarzet 419f4da67c perf(network): share SMB read sessions across listings and reads
Every SMB listing and every proxied byte range opened its own dart_smb2
pool: a worker isolate, a TCP connect, negotiate and NTLM session setup,
then a logoff, each under the app-wide native lock. A scan reads two to
four ranges per file, so playback chunks and covers queued behind one
handshake per range request.

Listings, tag and playback reads and cover downloads now lease a session
kept per connection and login. It closes 20 s after its last lease ends,
when the connection is saved or removed (reads in flight finish on it),
when a call on it fails in a way the session may have caused
(connection, timeout, logon, state, io or unknown errors; the next call
logs on again, as before), and on dispose. Errors reach callers as they
did. Concurrent first calls share one logon and a failed logon is not
kept. Uploads, folder creation and deletes keep a session of their own.

Fake transport test: a scan of four files with two tag ranges each,
eight parallel ranges, three listings and a cover took 24 logons before
and 1 after, with never more than one native call in flight.

Loopback Samba fixture (SMB 3.1.1, encryption required), a 200-file scan
with two tag ranges per file and a 64 KiB seek every 20 ms, host under
load: before 139 s per scan, 631 worker isolates, seek median 486 ms,
max 12.7 s; after 6 to 11 s per scan, one worker for three scans, seek
median 24 to 45 ms, max 0.1 to 1.9 s.
2026-10-31 01:00:05 +07:00

106 lines
3.7 KiB
Dart

import 'dart:developer' as developer;
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:mornye/services/network_library_scanner.dart';
import 'package:mornye/services/network_smb_client.dart';
import 'package:mornye/services/network_storage_service.dart';
import 'support/vm_service_probe.dart';
Future<int> _smbWorkers(Uri service) async {
final vm = await callTestVmService(service, 'getVM');
return (vm['isolates'] as List)
.where((isolate) => (isolate as Map)['name'] == 'dart_smb2 worker')
.length;
}
Future<void> main() async {
TestWidgetsFlutterBinding.ensureInitialized();
final service = (await developer.Service.getInfo()).serverUri;
final address = Platform.environment['TEST_SMB_ADDRESS'];
test(
'12 native SMB scans share one worker and release handles and streams',
() async {
final overrides = HttpOverrides.current;
HttpOverrides.global = null;
addTearDown(() => HttpOverrides.global = overrides);
final directory = await Directory.systemTemp.createTemp('smb-memory-');
addTearDown(() => directory.delete(recursive: true));
final storage = NetworkStorageService(
read: () async => null,
write: (_) async {},
);
addTearDown(storage.dispose);
await storage.save(
NetworkConnection(
id: 'fixture',
name: 'SMB fixture',
protocol: NetworkProtocol.smb,
address: address!,
username: 'test',
password: 'secret',
),
);
final client = HttpClient();
addTearDown(() => client.close(force: true));
final scanner = NetworkLibraryScanner(
storage: storage,
supportDirectory: () async => directory,
temporaryDirectory: () async => directory,
readMetadata: (source) async {
final url = await storage.resolve(source);
final request = await client.getUrl(Uri.parse(url));
request.headers.set(HttpHeaders.rangeHeader, 'bytes=0-31');
final response = await request.close();
expect(response.statusCode, 206);
final bytes = await response.fold<List<int>>(
[],
(bytes, chunk) => bytes..addAll(chunk),
);
expect(bytes, List.generate(32, (i) => i));
return {'title': 'Fixture'};
},
);
final workersBefore = await _smbWorkers(service!);
final probe = await NetworkSmbClient.connect(
Uri.parse(address),
username: 'test',
password: 'secret',
domain: '',
timeout: const Duration(seconds: 5),
);
try {
expect(await _smbWorkers(service), greaterThan(workersBefore));
} finally {
await probe.close();
}
for (var run = 0; run < 12; run++) {
final result = await scanner.scan(
NetworkStorageService.source('fixture', ''),
checkpoint: () async {},
onProgress: (_, _, _) {},
);
expect(result.expectedCount, 1);
expect(result.errorCount, 0);
await result.delete();
await collectTestGarbage(service);
// The read session stays for the next scan instead of a worker per
// listing and byte range.
expect(await _smbWorkers(service), workersBefore + 1);
}
await storage.dispose();
await collectTestGarbage(service);
expect(await _smbWorkers(service), workersBefore);
expect(
await Directory('${directory.path}/network_scans').list().toList(),
isEmpty,
);
},
timeout: const Timeout(Duration(minutes: 2)),
skip: address == null || service == null
? 'Requires TEST_SMB_ADDRESS and --enable-vmservice'
: false,
);
}