Bind legacy server identity and preserve pending run migrations

This commit is contained in:
2026-10-24 02:46:34 +01:00
parent 289a971b73
commit afb97c759e
7 changed files with 469 additions and 16 deletions
+21 -4
View File
@@ -2,13 +2,18 @@ import '../transport/server_url.dart';
/// One logical server; endpoints are primary first, then ordered backups.
class SavedServer {
SavedServer._(this.id, this.name, Iterable<String> endpoints)
: endpoints = List.unmodifiable(endpoints);
SavedServer._(
this.id,
this.name,
Iterable<String> endpoints,
this.legacyEndpoint,
) : endpoints = List.unmodifiable(endpoints);
factory SavedServer.validated({
required String id,
required String name,
required Iterable<String> endpoints,
String? legacyEndpoint,
}) {
final cleanId = id.trim();
final cleanName = name.trim();
@@ -22,33 +27,45 @@ class SavedServer {
if (normalized.isEmpty) {
throw const FormatException('A server needs at least one endpoint.');
}
return SavedServer._(cleanId, cleanName, normalized);
return SavedServer._(
cleanId,
cleanName,
normalized,
legacyEndpoint == null ? null : ServerUrl.validate(legacyEndpoint).wsUrl,
);
}
final String id;
final String name;
final List<String> endpoints;
/// Old local pending-run storage pointer, never a network or auth alias.
final String? legacyEndpoint;
Map<String, Object?> toJson() => {
'id': id,
'name': name,
'endpoints': endpoints.toList(),
if (legacyEndpoint != null) 'legacyEndpoint': legacyEndpoint,
};
factory SavedServer.fromJson(Map<String, dynamic> json) {
final id = json['id'];
final name = json['name'];
final endpoints = json['endpoints'];
final legacyEndpoint = json['legacyEndpoint'];
if (id is! String ||
name is! String ||
endpoints is! List ||
endpoints.any((endpoint) => endpoint is! String)) {
endpoints.any((endpoint) => endpoint is! String) ||
(legacyEndpoint != null && legacyEndpoint is! String)) {
throw const FormatException('Invalid saved server.');
}
return SavedServer.validated(
id: id,
name: name,
endpoints: endpoints.cast<String>(),
legacyEndpoint: legacyEndpoint as String?,
);
}
}
+66 -7
View File
@@ -1,30 +1,63 @@
import 'dart:convert';
import 'dart:math';
import 'package:shared_preferences/shared_preferences.dart';
import 'server_catalog.dart';
import '../transport/server_url.dart';
const String serverCatalogKey = 'pipelines.next.serverCatalog.v1';
const String serverCatalogLegacyBindingKey =
'pipelines.next.serverCatalog.legacyBinding.v1';
abstract interface class ServerCatalogStore {
Future<ServerCatalog> load({String legacyEndpoint = ''});
Future<bool> save(ServerCatalog catalog);
}
ServerCatalog _migrate(String legacyEndpoint) {
ServerCatalog _migrate(String legacyEndpoint, [List<String>? binding]) {
if (legacyEndpoint.trim().isEmpty) return ServerCatalog();
final normalized = ServerUrl.validate(legacyEndpoint).wsUrl;
final canMigrate = binding == null || binding.contains(normalized);
final random = Random.secure();
final id = canMigrate
? 'legacy-server'
: 'server-${List.generate(16, (_) => random.nextInt(256).toRadixString(16).padLeft(2, '0')).join()}';
return ServerCatalog(
servers: [
SavedServer.validated(
id: 'legacy-server',
id: id,
name: 'My server',
endpoints: [legacyEndpoint],
legacyEndpoint: canMigrate ? legacyEndpoint : null,
),
],
selectedId: 'legacy-server',
selectedId: id,
);
}
List<String>? _readBinding(SharedPreferences preferences) {
if (!preferences.containsKey(serverCatalogLegacyBindingKey)) return null;
final raw = preferences.get(serverCatalogLegacyBindingKey);
if (raw is! String) throw const FormatException('Invalid legacy binding.');
final json = jsonDecode(raw);
if (json is! Map<String, dynamic> || json['version'] != 1) {
throw const FormatException('Unsupported legacy binding format.');
}
return SavedServer.fromJson({
'id': 'legacy-server',
'name': 'Original legacy server',
'endpoints': json['endpoints'],
}).endpoints;
}
List<String>? _bindingFor(ServerCatalog catalog) {
for (final server in catalog.servers) {
if (server.id == 'legacy-server') return server.endpoints;
}
return null;
}
/// A single versioned JSON value keeps profiles and selection together.
///
/// Load is read-only, including legacy migration. The caller explicitly saves
@@ -37,8 +70,9 @@ class SharedPreferencesServerCatalogStore implements ServerCatalogStore {
@override
Future<ServerCatalog> load({String legacyEndpoint = ''}) async {
final preferences = await SharedPreferences.getInstance();
final binding = _readBinding(preferences);
if (!preferences.containsKey(serverCatalogKey)) {
return _migrate(legacyEndpoint);
return _migrate(legacyEndpoint, binding);
}
final raw = preferences.get(serverCatalogKey);
if (raw is! String) {
@@ -53,13 +87,36 @@ class SharedPreferencesServerCatalogStore implements ServerCatalogStore {
@override
Future<bool> save(ServerCatalog catalog) async {
SharedPreferences? preferences;
try {
final preferences = await SharedPreferences.getInstance();
return await preferences.setString(
preferences = await SharedPreferences.getInstance();
// A rejected platform write can still update the plugin's local cache.
// Only durable binding data may authorize reuse of the legacy identity.
await preferences.reload();
final binding = _readBinding(preferences);
final original = _bindingFor(catalog);
// Bind before publishing a migrated catalog. Retain this independently
// through profile deletion and catalog resets; never widen it on edits.
if (binding == null && original != null) {
final bound = await preferences.setString(
serverCatalogLegacyBindingKey,
jsonEncode({'version': 1, 'endpoints': original}),
);
if (!bound) {
await preferences.reload();
return false;
}
}
final saved = await preferences.setString(
serverCatalogKey,
jsonEncode({'version': 1, ...catalog.toJson()}),
);
if (!saved) await preferences.reload();
return saved;
} catch (_) {
try {
await preferences?.reload();
} catch (_) {}
return false;
}
}
@@ -70,15 +127,17 @@ class MemoryServerCatalogStore implements ServerCatalogStore {
MemoryServerCatalogStore({this.catalog});
ServerCatalog? catalog;
List<String>? _legacyBinding;
bool failSaves = false;
@override
Future<ServerCatalog> load({String legacyEndpoint = ''}) async =>
catalog ?? _migrate(legacyEndpoint);
catalog ?? _migrate(legacyEndpoint, _legacyBinding);
@override
Future<bool> save(ServerCatalog catalog) async {
if (failSaves) return false;
_legacyBinding ??= _bindingFor(catalog);
this.catalog = catalog;
return true;
}
@@ -14,8 +14,12 @@ String pendingRunStorageKey(String endpoint, int pipelineId, int version) =>
'pipelines.web.pendingRun.v1:$endpoint:$pipelineId:$version';
class SharedPreferencesPendingRunStore implements PendingRunStore {
const SharedPreferencesPendingRunStore(this.endpoint);
const SharedPreferencesPendingRunStore(
this.endpoint, {
this.legacyEndpoints = const [],
});
final String endpoint;
final List<String> legacyEndpoints;
Future<SharedPreferences?> _preferences() async {
try {
@@ -31,10 +35,37 @@ class SharedPreferencesPendingRunStore implements PendingRunStore {
@override
Future<RunPipelineIntent?> read(int pipelineId, int version) async {
try {
final raw = (await _preferences())?.getString(_key(pipelineId, version));
final preferences = await _preferences();
if (preferences == null) return null;
final stableKey = _key(pipelineId, version);
if (preferences.containsKey(stableKey)) {
return _decode(preferences.getString(stableKey), pipelineId, version);
}
for (final legacy in legacyEndpoints.toSet()) {
final value = preferences.get(
pendingRunStorageKey(legacy, pipelineId, version),
);
final raw = value is String ? value : null;
final intent = _decode(raw, pipelineId, version);
if (intent == null) continue;
// Best effort copy, never move: preserve the operation on write failure.
try {
await preferences.setString(stableKey, raw!);
} catch (_) {}
return intent;
}
return null;
} catch (_) {
return null;
}
}
RunPipelineIntent? _decode(String? raw, int pipelineId, int version) {
try {
if (raw == null) return null;
final intent = RunPipelineIntent.fromJson(jsonDecode(raw));
return intent?.matches(pipelineId, version) == true ? intent : null;
if (intent == null || intent.requestKey.trim().isEmpty) return null;
return intent.matches(pipelineId, version) ? intent : null;
} catch (_) {
return null;
}
@@ -52,9 +83,34 @@ class SharedPreferencesPendingRunStore implements PendingRunStore {
@override
Future<void> remove(int pipelineId, int version) async {
final preferences = await _preferences();
if (preferences == null) return;
// Remove legacy copies first. Keep the stable recovery copy if cleanup
// fails, rather than allowing an older legacy operation to resurrect.
for (final legacy in legacyEndpoints.toSet()) {
final key = pendingRunStorageKey(legacy, pipelineId, version);
if (key == _key(pipelineId, version)) continue;
try {
if (preferences.containsKey(key) && !await preferences.remove(key)) {
await preferences.reload();
return;
}
} catch (_) {
try {
await preferences.reload();
} catch (_) {}
return;
}
}
try {
await (await _preferences())?.remove(_key(pipelineId, version));
} catch (_) {}
if (!await preferences.remove(_key(pipelineId, version))) {
await preferences.reload();
}
} catch (_) {
try {
await preferences.reload();
} catch (_) {}
}
}
}
@@ -0,0 +1,32 @@
// The existing preferences plugin's platform seam is used only for fault tests.
// ignore: depend_on_referenced_packages
import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart';
import 'package:shared_preferences/shared_preferences.dart';
class FailingPreferences extends InMemorySharedPreferencesStore {
FailingPreferences() : super.empty();
String? failWriteKey;
String? failRemoveKey;
bool throwWrites = false;
void install() {
SharedPreferences.resetStatic();
SharedPreferencesStorePlatform.instance = this;
}
@override
Future<bool> setValue(String valueType, String key, Object value) async {
if (key == 'flutter.$failWriteKey') {
if (throwWrites) throw StateError('Injected write failure');
return false;
}
return super.setValue(valueType, key, value);
}
@override
Future<bool> remove(String key) async {
if (key == 'flutter.$failRemoveKey') return false;
return super.remove(key);
}
}
@@ -5,6 +5,8 @@ import 'package:pipelines_app/core/servers/server_catalog.dart';
import 'package:pipelines_app/core/servers/server_catalog_store.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'failing_preferences.dart';
ServerCatalog fixture() => ServerCatalog(
servers: [
SavedServer.validated(
@@ -22,6 +24,134 @@ void main() {
setUp(() => SharedPreferences.setMockInitialValues({}));
test(
'binding failure cannot publish catalog; partial save retains binding',
() async {
final disk = FailingPreferences()..install();
final migrated = await store.load(legacyEndpoint: 'ws://a.test');
disk.failWriteKey = serverCatalogLegacyBindingKey;
expect(await store.save(migrated), isFalse);
var preferences = await SharedPreferences.getInstance();
await preferences.reload();
expect(preferences.containsKey(serverCatalogKey), isFalse);
expect(preferences.containsKey(serverCatalogLegacyBindingKey), isFalse);
disk.failWriteKey = serverCatalogKey;
expect(await store.save(migrated), isFalse);
await preferences.reload();
expect(preferences.containsKey(serverCatalogKey), isFalse);
expect(preferences.containsKey(serverCatalogLegacyBindingKey), isTrue);
expect(
(await store.load(legacyEndpoint: 'ws://b.test')).active!.id,
isNot('legacy-server'),
);
disk.failWriteKey = null;
expect(await store.save(migrated), isTrue);
},
);
test(
'binding prevents legacy credentials reuse after A to B catalog reset',
() async {
final original = await store.load(legacyEndpoint: 'ws://a.test');
expect(await store.save(original), isTrue);
final preferences = await SharedPreferences.getInstance();
final binding = preferences.getString(serverCatalogLegacyBindingKey);
expect(binding, isNotNull);
await preferences.setString('pipelines.next.serverUrl.v1', 'ws://b.test');
await preferences.setString('cookie:legacy-server', 'A-cookie');
await preferences.remove(serverCatalogKey);
final recovered = await store.load(legacyEndpoint: 'ws://b.test');
expect(recovered.active!.id, isNot('legacy-server'));
expect(recovered.active!.legacyEndpoint, isNull);
expect(recovered.active!.endpoints, ['ws://b.test/connect']);
expect(preferences.containsKey(serverCatalogKey), isFalse);
expect(preferences.getString('cookie:legacy-server'), 'A-cookie');
expect(
preferences.getString('pipelines.next.serverUrl.v1'),
'ws://b.test',
);
expect(preferences.getString(serverCatalogLegacyBindingKey), binding);
final trusted = await store.load(legacyEndpoint: 'WS://A.TEST/');
expect(trusted.active!.id, 'legacy-server');
},
);
test(
'original trusted aliases stay bound through edits and removal',
() async {
final original = ServerCatalog(
servers: [
SavedServer.validated(
id: 'legacy-server',
name: 'A',
endpoints: ['ws://a.test', 'wss://a-backup.test'],
legacyEndpoint: 'ws://a.test',
),
],
selectedId: 'legacy-server',
);
expect(await store.save(original), isTrue);
final preferences = await SharedPreferences.getInstance();
final binding = preferences.getString(serverCatalogLegacyBindingKey);
expect(
await store.save(
original.upsert(
SavedServer.validated(
id: 'legacy-server',
name: 'Changed',
endpoints: ['ws://b.test'],
legacyEndpoint: original.active!.legacyEndpoint,
),
),
),
isTrue,
);
expect(await store.save(ServerCatalog()), isTrue);
expect(preferences.getString(serverCatalogLegacyBindingKey), binding);
await preferences.remove(serverCatalogKey);
expect(
(await store.load(legacyEndpoint: 'wss://a-backup.test')).active!.id,
'legacy-server',
);
expect(
(await store.load(legacyEndpoint: 'ws://b.test')).active!.id,
isNot('legacy-server'),
);
},
);
test(
'corrupt binding surfaces even with an existing valid catalog',
() async {
await store.save(fixture());
final preferences = await SharedPreferences.getInstance();
final original = preferences.getString(serverCatalogKey);
for (final corrupt in <Object>[
'bad',
1,
'{"version":2}',
'{"version":1,"endpoints":[]}',
]) {
await preferences.remove(serverCatalogLegacyBindingKey);
if (corrupt is String) {
await preferences.setString(serverCatalogLegacyBindingKey, corrupt);
} else {
await preferences.setInt(
serverCatalogLegacyBindingKey,
corrupt as int,
);
}
await expectLater(
store.load(legacyEndpoint: 'ws://b.test'),
throwsFormatException,
);
expect(await store.save(ServerCatalog()), isFalse);
expect(preferences.getString(serverCatalogKey), original);
expect(preferences.get(serverCatalogLegacyBindingKey), corrupt);
}
},
);
test('empty storage gives empty catalog and never writes on load', () async {
expect((await store.load()).servers, isEmpty);
final preferences = await SharedPreferences.getInstance();
@@ -10,6 +10,43 @@ SavedServer server(String id) => SavedServer.validated(
);
void main() {
test(
'legacy pointer survives alias reordering without becoming an alias',
() {
final original = SavedServer.validated(
id: 'legacy-server',
name: 'Home',
endpoints: ['wss://new.test', 'ws://original.test'],
legacyEndpoint: ' WS://ORIGINAL.test/ ',
);
final reordered = SavedServer.validated(
id: original.id,
name: original.name,
endpoints: original.endpoints.reversed,
legacyEndpoint: original.legacyEndpoint,
);
final restored = SavedServer.fromJson(reordered.toJson());
expect(restored.legacyEndpoint, 'ws://original.test/connect');
expect(restored.endpoints, reordered.endpoints);
final pointerOnly = SavedServer.validated(
id: 'a',
name: 'A',
endpoints: ['wss://new.test'],
legacyEndpoint: restored.legacyEndpoint,
);
expect(pointerOnly.endpoints, ['wss://new.test/connect']);
expect(
() => SavedServer.validated(
id: 'a',
name: 'A',
endpoints: ['ws://a.test'],
legacyEndpoint: 'bad',
),
throwsFormatException,
);
},
);
test('normalizes, deduplicates and retains primary/backup order', () {
final value = SavedServer.validated(
id: ' home ',
@@ -0,0 +1,122 @@
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/pipelines/pending_run_store.dart';
import 'package:pipelines_app/features/pipelines/run_pipeline_intent.dart';
import 'package:shared_preferences/shared_preferences.dart';
import '../../core/servers/failing_preferences.dart';
const intent = RunPipelineIntent(
pipelineId: 7,
version: 3,
prompt: 'unknown admission',
workspace: '/work',
notifyMode: RunNotifyMode.notify,
requestKey: 'original-operation-id',
);
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
const legacy = 'ws://original.test/connect';
final oldKey = pendingRunStorageKey(legacy, 7, 3);
final stableKey = pendingRunStorageKey('profile:legacy-server', 7, 3);
const store = SharedPreferencesPendingRunStore(
'profile:legacy-server',
legacyEndpoints: [legacy],
);
setUp(() => SharedPreferences.setMockInitialValues({}));
test(
'restores unknown admission under profile with identical operation id',
() async {
final preferences = await SharedPreferences.getInstance();
final raw = jsonEncode(intent.toJson());
await preferences.setString(oldKey, raw);
expect((await store.read(7, 3))!.requestKey, intent.requestKey);
expect(preferences.getString(stableKey), raw);
expect(preferences.getString(oldKey), raw);
expect(await store.read(7, 4), isNull);
},
);
test('stable record wins, including corrupt stable data', () async {
final preferences = await SharedPreferences.getInstance();
await preferences.setString(oldKey, jsonEncode(intent.toJson()));
await preferences.setString(stableKey, 'corrupt');
expect(await store.read(7, 3), isNull);
expect(preferences.getString(stableKey), 'corrupt');
await store.write(intent);
expect((await store.read(7, 3))!.requestKey, intent.requestKey);
});
test(
'skips nonmatching fallback and never invents an operation id',
() async {
final preferences = await SharedPreferences.getInstance();
await preferences.setString(
oldKey,
jsonEncode({...intent.toJson(), 'pipelineId': 8}),
);
expect(await store.read(7, 3), isNull);
await preferences.setString(
oldKey,
jsonEncode({...intent.toJson(), 'requestKey': ''}),
);
expect(await store.read(7, 3), isNull);
expect(preferences.containsKey(stableKey), isFalse);
},
);
test(
'successful remove clears only stable and known legacy copies',
() async {
final preferences = await SharedPreferences.getInstance();
final raw = jsonEncode(intent.toJson());
final other = pendingRunStorageKey('ws://other.test', 7, 3);
await preferences.setString(oldKey, raw);
await preferences.setString(other, raw);
await store.read(7, 3);
await store.remove(7, 3);
expect(preferences.containsKey(oldKey), isFalse);
expect(preferences.containsKey(stableKey), isFalse);
expect(preferences.getString(other), raw);
expect(await store.read(7, 3), isNull);
},
);
test(
'copy failure returns original operation and preserves source on disk',
() async {
for (final throws in [false, true]) {
final disk = FailingPreferences()..install();
final preferences = await SharedPreferences.getInstance();
final raw = jsonEncode(intent.toJson());
await preferences.setString(oldKey, raw);
disk.failWriteKey = stableKey;
disk.throwWrites = throws;
expect((await store.read(7, 3))!.requestKey, intent.requestKey);
await preferences.reload();
expect(preferences.getString(oldKey), raw);
expect(preferences.containsKey(stableKey), isFalse);
}
},
);
test('partial cleanup failure keeps stable recovery copy', () async {
final disk = FailingPreferences()..install();
final preferences = await SharedPreferences.getInstance();
final raw = jsonEncode(intent.toJson());
await preferences.setString(oldKey, raw);
await store.read(7, 3);
disk.failRemoveKey = oldKey;
await store.remove(7, 3);
await preferences.reload();
expect(preferences.getString(stableKey), raw);
expect(preferences.getString(oldKey), raw);
disk.failRemoveKey = null;
await store.remove(7, 3);
await preferences.reload();
expect(await store.read(7, 3), isNull);
});
}