mirror of
https://github.com/zarzet/SpotiFLAC-Mobile.git
synced 2026-11-21 20:00:49 +01:00
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.
106 lines
3.7 KiB
Dart
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,
|
|
);
|
|
}
|