Merge pull request #611 from zjs81/perf/coalesce-persistence
Batch per-frame persistence so busy meshes don't stall the UI
This commit is contained in:
10 files changed
+365
-29
No files matched your search
@@ -67,6 +67,7 @@ import 'meshcore_uuids.dart';
|
||||
import 'meshcore_protocol.dart';
|
||||
import 'pending_command_replies.dart';
|
||||
import 'raw_packet.dart';
|
||||
import '../utils/coalesced_writes.dart';
|
||||
|
||||
class DirectRepeater {
|
||||
static const int maxAgeMinutes = 30; // Max age for direct repeater info
|
||||
@@ -479,6 +480,9 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
BleDebugLogService? _bleDebugLogService;
|
||||
AppDebugLogService? _appDebugLogService;
|
||||
final ChannelMessageStore _channelMessageStore = ChannelMessageStore();
|
||||
// Per-frame persistence (channel history, conversations, contact lists) is
|
||||
// batched here; see [CoalescedWrites].
|
||||
final CoalescedWrites _coalescedWrites = CoalescedWrites();
|
||||
final MessageStore _messageStore = MessageStore();
|
||||
final ChannelOrderStore _channelOrderStore = ChannelOrderStore();
|
||||
final ChannelSettingsStore _channelSettingsStore = ChannelSettingsStore();
|
||||
@@ -988,9 +992,40 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
Future<void> _saveChannelMessages(int slot, List<ChannelMessage> messages) {
|
||||
final id = _channelIdForSlot(slot);
|
||||
if (id == null) return Future<void>.value();
|
||||
_coalescedWrites.cancel('channel:$id');
|
||||
return _channelMessageStore.saveChannelMessages(id, messages);
|
||||
}
|
||||
|
||||
/// Queues a save of [slot]'s history. The write looks the channel up again
|
||||
/// when it runs, so it persists whatever the history is by then and skips a
|
||||
/// channel that was removed in the meantime.
|
||||
void _scheduleChannelSave(int slot) {
|
||||
final id = _channelIdForSlot(slot);
|
||||
if (id == null) return;
|
||||
_coalescedWrites.schedule('channel:$id', () {
|
||||
final currentSlot = _slotForChannelId(id);
|
||||
final messages = currentSlot == null
|
||||
? null
|
||||
: _channelMessages[_canonicalSlot(currentSlot)];
|
||||
if (messages == null) return Future<void>.value();
|
||||
return _channelMessageStore.saveChannelMessages(id, messages);
|
||||
});
|
||||
}
|
||||
|
||||
/// Queues a save of the conversation with [contactKeyHex]; skipped when the
|
||||
/// conversation is gone by the time it runs.
|
||||
void _scheduleConversationSave(String contactKeyHex) {
|
||||
_coalescedWrites.schedule('conversation:$contactKeyHex', () {
|
||||
final messages = _conversations[contactKeyHex];
|
||||
if (messages == null) return Future<void>.value();
|
||||
return _messageStore.saveMessages(contactKeyHex, messages);
|
||||
});
|
||||
}
|
||||
|
||||
/// Runs queued persistence now. Called before the app is backgrounded and
|
||||
/// whenever the stores are about to switch to another radio.
|
||||
Future<void> flushPendingWrites() => _coalescedWrites.flush();
|
||||
|
||||
int getUnreadCountForContact(Contact contact) {
|
||||
if (contact.type == advTypeRepeater) return 0;
|
||||
return getUnreadCountForContactKey(contact.publicKeyHex);
|
||||
@@ -1244,6 +1279,17 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/// Queues a save of the channel list, which carries the unread counts that
|
||||
/// change on every received channel message.
|
||||
void _scheduleChannelListSave() {
|
||||
_coalescedWrites.schedule(
|
||||
'channels',
|
||||
() => _channelStore.saveChannels(
|
||||
_channels.isNotEmpty ? _channels : _cachedChannels,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
void setChannelUnreadCount(int channelIndex, int count) {
|
||||
final channel = _findChannelByIndex(channelIndex);
|
||||
if (channel != null) {
|
||||
@@ -1251,11 +1297,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
channel.unreadCount = count;
|
||||
final total = _cachedChannelsUnreadTotal + (count - previousCount);
|
||||
_cachedChannelsUnreadTotal = total < 0 ? 0 : total;
|
||||
unawaited(
|
||||
_channelStore.saveChannels(
|
||||
_channels.isNotEmpty ? _channels : _cachedChannels,
|
||||
),
|
||||
);
|
||||
_scheduleChannelListSave();
|
||||
notifyListeners();
|
||||
}
|
||||
}
|
||||
@@ -1271,11 +1313,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
'Channel ${channel.name.isNotEmpty ? channel.name : channelIndex} marked as read (was $previousCount unread)',
|
||||
tag: 'Unread',
|
||||
);
|
||||
unawaited(
|
||||
_channelStore.saveChannels(
|
||||
_channels.isNotEmpty ? _channels : _cachedChannels,
|
||||
),
|
||||
);
|
||||
_scheduleChannelListSave();
|
||||
_notificationService.clearChannelNotification(
|
||||
channelIndex,
|
||||
getTotalUnreadCount(),
|
||||
@@ -1535,6 +1573,9 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
|
||||
/// Load persisted channel messages for a specific channel
|
||||
Future<void> _loadChannelMessages(int channelIndex) async {
|
||||
// The load replaces the in-memory history, so queued writes of it must
|
||||
// reach storage (whose cache updates synchronously) first.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
final channelId = _slotChannelIds[channelIndex];
|
||||
final allMessages = channelId == null
|
||||
? <ChannelMessage>[]
|
||||
@@ -5137,7 +5178,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
),
|
||||
);
|
||||
}
|
||||
unawaited(_persistDiscoveredContacts());
|
||||
_scheduleDiscoveredContactsPersist();
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
@@ -5146,7 +5187,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
_discoveredContacts.removeWhere(
|
||||
(c) => c.publicKeyHex == contact.publicKeyHex,
|
||||
);
|
||||
unawaited(_persistDiscoveredContacts());
|
||||
_scheduleDiscoveredContactsPersist();
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
@@ -5272,7 +5313,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
),
|
||||
);
|
||||
notifyListeners();
|
||||
unawaited(_persistDiscoveredContacts());
|
||||
_scheduleDiscoveredContactsPersist();
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -5717,6 +5758,9 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
'$unconfirmed',
|
||||
);
|
||||
}
|
||||
// Queued channel writes find their channel by slot; land them before
|
||||
// the map moves, or a channel whose slot changed would never be saved.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
_slotChannelIds
|
||||
..clear()
|
||||
..addAll(next);
|
||||
@@ -5842,6 +5886,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
);
|
||||
await _loadChannelOrder();
|
||||
final saved = await _channelStore.loadSlotChannelIds();
|
||||
unawaited(_coalescedWrites.flush());
|
||||
_slotChannelIds
|
||||
..clear()
|
||||
..addAll(saved);
|
||||
@@ -5914,6 +5959,9 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
_findChannelByIndex(index)?.storageId ?? _slotChannelIds[index];
|
||||
// Delete by setting empty name and zero PSK
|
||||
await sendFrame(buildSetChannelFrame(index, '', Uint8List(16)));
|
||||
// A twin slot with the same PSK keeps this history, so queued writes of
|
||||
// it land before the list is dropped; a full delete clears them below.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
_channelMessages.remove(index);
|
||||
_processedChannelReactions.remove(index);
|
||||
try {
|
||||
@@ -5936,6 +5984,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
/// Removes everything persisted for [channelId]: messages, settings,
|
||||
/// region, images and its place in the channel order.
|
||||
Future<void> _clearChannelStorage(String channelId) async {
|
||||
_coalescedWrites.cancel('channel:$channelId');
|
||||
await _channelMessageStore.clearChannelMessages(channelId);
|
||||
await _channelSettingsStore.clearChannel(channelId);
|
||||
await _channelRegionStore.clearRegion(channelId);
|
||||
@@ -6327,6 +6376,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
return;
|
||||
}
|
||||
|
||||
unawaited(_coalescedWrites.flush());
|
||||
//set all the stores' public key so they can load the correct data
|
||||
_channelMessageStore.setPublicKeyHex = selfPublicKeyHex;
|
||||
_messageStore.setPublicKeyHex = selfPublicKeyHex;
|
||||
@@ -6953,14 +7003,27 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
}
|
||||
}
|
||||
|
||||
/// Queues a save of the contact list; adverts and contact replies arrive
|
||||
/// many times a second on a busy mesh.
|
||||
Future<void> _persistContacts() async {
|
||||
await _contactStore.saveContacts(_contacts);
|
||||
_coalescedWrites.schedule(
|
||||
'contacts',
|
||||
() => _contactStore.saveContacts(_contacts),
|
||||
);
|
||||
}
|
||||
|
||||
Future<void> _persistDiscoveredContacts() async {
|
||||
_coalescedWrites.cancel('discovered');
|
||||
await _discoveryContactStore.saveContacts(_discoveredContacts);
|
||||
}
|
||||
|
||||
void _scheduleDiscoveredContactsPersist() {
|
||||
_coalescedWrites.schedule(
|
||||
'discovered',
|
||||
() => _discoveryContactStore.saveContacts(_discoveredContacts),
|
||||
);
|
||||
}
|
||||
|
||||
int _latestContactLastmod() {
|
||||
if (_contacts.isEmpty) return 0;
|
||||
var latest = 0;
|
||||
@@ -8033,11 +8096,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
'Channel ${channel.name.isNotEmpty ? channel.name : channelIndex} unread count incremented to ${channel.unreadCount}',
|
||||
tag: 'Unread',
|
||||
);
|
||||
unawaited(
|
||||
_channelStore.saveChannels(
|
||||
_channels.isNotEmpty ? _channels : _cachedChannels,
|
||||
),
|
||||
);
|
||||
_scheduleChannelListSave();
|
||||
} else {
|
||||
_appDebugLogService?.info(
|
||||
'Channel $channelIndex not found in _channels (${_channels.length}) or _cachedChannels (${_cachedChannels.length})',
|
||||
@@ -8138,7 +8197,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
_messageStore.archive(pubKeyHex, messages.sublist(0, trimCount));
|
||||
messages.removeRange(0, trimCount);
|
||||
}
|
||||
_messageStore.saveMessages(pubKeyHex, messages);
|
||||
_scheduleConversationSave(pubKeyHex);
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
@@ -8409,7 +8468,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
if (reactionApplied) {
|
||||
appLogger.info('Adding channel reaction, id: $reactionIdentifier');
|
||||
// Save updated messages
|
||||
_saveChannelMessages(channelIndex, messages);
|
||||
_scheduleChannelSave(channelIndex);
|
||||
|
||||
// Mark as processed
|
||||
_processedChannelReactions[channelIndex]!.add(reactionIdentifier);
|
||||
@@ -8514,10 +8573,14 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
}
|
||||
} else {
|
||||
messages.add(processedMessage);
|
||||
// Storage keeps only the newest maxStoredMessages per channel, so older
|
||||
// entries are gone after the next save anyway. Without this cap a long
|
||||
// session on a busy channel grows the list, and every save, unbounded.
|
||||
final overflow = messages.length - ChannelMessageStore.maxStoredMessages;
|
||||
if (overflow > 0) messages.removeRange(0, overflow);
|
||||
}
|
||||
|
||||
// Save to persistent storage
|
||||
_saveChannelMessages(channelIndex, messages);
|
||||
_scheduleChannelSave(channelIndex);
|
||||
return isNew;
|
||||
}
|
||||
|
||||
@@ -8684,6 +8747,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
}
|
||||
|
||||
void _handleDisconnection() {
|
||||
unawaited(_coalescedWrites.flush());
|
||||
_resetLinkSessionState();
|
||||
|
||||
_notifySubscription?.cancel();
|
||||
@@ -8755,6 +8819,9 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
/// Drops the conversation and channel history held in memory, so a
|
||||
/// different radio never shows or persists another radio's messages.
|
||||
void _clearSessionMessageState() {
|
||||
// Writes start synchronously, so they still read this radio's history and
|
||||
// store keys before both change below.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
_conversations.clear();
|
||||
_loadedConversationKeys.clear();
|
||||
_channelMessages.clear();
|
||||
@@ -8897,6 +8964,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
_notificationReplySubscription?.cancel();
|
||||
_notificationService.releaseReplyPort();
|
||||
_notifyListenersTimer?.cancel();
|
||||
unawaited(_coalescedWrites.flush());
|
||||
_reconnectTimer?.cancel();
|
||||
_batteryPollTimer?.cancel();
|
||||
_gpsLocationPollTimer?.cancel();
|
||||
@@ -9378,7 +9446,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
isActive: addActive,
|
||||
);
|
||||
notifyListeners();
|
||||
unawaited(_persistDiscoveredContacts());
|
||||
_scheduleDiscoveredContactsPersist();
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -9405,7 +9473,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
}
|
||||
_discoveredContacts.add(disContact);
|
||||
|
||||
unawaited(_persistDiscoveredContacts());
|
||||
_scheduleDiscoveredContactsPersist();
|
||||
|
||||
// Show notification for new contact (advertisement)
|
||||
if (_appSettingsService != null && !noNotify) {
|
||||
@@ -9435,7 +9503,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
|
||||
void removeAllDiscoveredContacts() {
|
||||
_discoveredContacts.clear();
|
||||
unawaited(_persistDiscoveredContacts());
|
||||
_scheduleDiscoveredContactsPersist();
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
|
||||
@@ -497,8 +497,16 @@ String ackHashToHex(int ackHash) {
|
||||
}
|
||||
|
||||
// Helper to convert public key to hex string
|
||||
const String _hexDigits = '0123456789abcdef';
|
||||
|
||||
String pubKeyToHex(Uint8List pubKey) {
|
||||
return pubKey.map((b) => b.toRadixString(16).padLeft(2, '0')).join();
|
||||
final codes = Uint8List(pubKey.length * 2);
|
||||
for (var i = 0; i < pubKey.length; i++) {
|
||||
final b = pubKey[i];
|
||||
codes[i * 2] = _hexDigits.codeUnitAt(b >> 4);
|
||||
codes[i * 2 + 1] = _hexDigits.codeUnitAt(b & 0x0F);
|
||||
}
|
||||
return String.fromCharCodes(codes);
|
||||
}
|
||||
|
||||
// Helper to convert hex string to public key
|
||||
|
||||
@@ -423,6 +423,15 @@ class _MeshCoreAppState extends State<MeshCoreApp> with WidgetsBindingObserver {
|
||||
state == AppLifecycleState.hidden) {
|
||||
unawaited(widget.imageCodecService.handleMemoryPressure());
|
||||
}
|
||||
// Batched message/contact writes must land before the OS can suspend or
|
||||
// kill a backgrounded app.
|
||||
if (state == AppLifecycleState.inactive ||
|
||||
state == AppLifecycleState.paused ||
|
||||
state == AppLifecycleState.hidden ||
|
||||
state == AppLifecycleState.detached) {
|
||||
unawaited(widget.connector.flushPendingWrites());
|
||||
unawaited(widget.pathHistoryService.flushPendingWrites());
|
||||
}
|
||||
if (state == AppLifecycleState.resumed) {
|
||||
widget.connector.syncAppBadge();
|
||||
}
|
||||
|
||||
@@ -41,7 +41,9 @@ class Contact {
|
||||
this.rawPacket,
|
||||
}) : lastMessageAt = lastMessageAt ?? lastSeen;
|
||||
|
||||
String get publicKeyHex => pubKeyToHex(publicKey);
|
||||
/// Cached: it backs ==, hashCode and the per-frame contact lookups, and
|
||||
/// rebuilding it allocated a 64-char string on every access.
|
||||
late final String publicKeyHex = pubKeyToHex(publicKey);
|
||||
|
||||
/// Uppercase hex of the first [byteWidth] public-key bytes: the hash this
|
||||
/// node appears as in routing paths.
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import '../models/contact.dart';
|
||||
import '../models/path_history.dart';
|
||||
import '../models/path_selection.dart';
|
||||
import '../utils/coalesced_writes.dart';
|
||||
import 'storage_service.dart';
|
||||
|
||||
class PathHistoryService extends ChangeNotifier {
|
||||
@@ -10,6 +13,10 @@ class PathHistoryService extends ChangeNotifier {
|
||||
final Map<String, int> _autoRotationIndex = {};
|
||||
final Map<String, _FloodStats> _floodStats = {};
|
||||
final Map<String, Future<void>> _pendingLoads = {};
|
||||
// A path record lands for most received messages, so saves are batched.
|
||||
final CoalescedWrites _writes = CoalescedWrites(
|
||||
delay: const Duration(seconds: 5),
|
||||
);
|
||||
|
||||
// LRU cache eviction tracking
|
||||
static const int _maxCachedContacts = 50;
|
||||
@@ -23,6 +30,9 @@ class PathHistoryService extends ChangeNotifier {
|
||||
PathHistoryService(this._storage);
|
||||
|
||||
void setDevicePublicKey(String publicKeyHex) {
|
||||
// Queued saves use the storage key on entry, so they still land under
|
||||
// the previous radio's key.
|
||||
unawaited(_writes.flush());
|
||||
_storage.setPublicKeyHex = publicKeyHex;
|
||||
_cache.clear();
|
||||
_cacheAccessOrder.clear();
|
||||
@@ -361,7 +371,12 @@ class PathHistoryService extends ChangeNotifier {
|
||||
_cache[contactPubKeyHex] = updatedHistory;
|
||||
_trackAccess(contactPubKeyHex);
|
||||
_evictIfNeeded();
|
||||
_storage.savePathHistory(contactPubKeyHex, updatedHistory);
|
||||
// The snapshot is written, not the cache entry: the LRU may evict it
|
||||
// before the batch runs.
|
||||
_writes.schedule(
|
||||
contactPubKeyHex,
|
||||
() => _storage.savePathHistory(contactPubKeyHex, updatedHistory),
|
||||
);
|
||||
|
||||
notifyListeners();
|
||||
}
|
||||
@@ -404,6 +419,9 @@ class PathHistoryService extends ChangeNotifier {
|
||||
Future<ContactPathHistory?> _loadHistoryFromStorage(
|
||||
String contactPubKeyHex,
|
||||
) async {
|
||||
// An evicted contact may still have a queued save; it reaches the prefs
|
||||
// cache synchronously, so the load below reads it.
|
||||
unawaited(_writes.flush());
|
||||
return await _storage.loadPathHistory(contactPubKeyHex);
|
||||
}
|
||||
|
||||
@@ -445,6 +463,7 @@ class PathHistoryService extends ChangeNotifier {
|
||||
_cacheAccessOrder.remove(contactPubKeyHex);
|
||||
_autoRotationIndex.remove(contactPubKeyHex);
|
||||
_floodStats.remove(contactPubKeyHex);
|
||||
_writes.cancel(contactPubKeyHex);
|
||||
await _storage.clearPathHistory(contactPubKeyHex);
|
||||
_version++;
|
||||
notifyListeners();
|
||||
@@ -465,6 +484,7 @@ class PathHistoryService extends ChangeNotifier {
|
||||
recentPaths: updatedPaths,
|
||||
);
|
||||
|
||||
_writes.cancel(contactPubKeyHex);
|
||||
await _storage.savePathHistory(contactPubKeyHex, _cache[contactPubKeyHex]!);
|
||||
_version++;
|
||||
notifyListeners();
|
||||
@@ -588,11 +608,21 @@ class PathHistoryService extends ChangeNotifier {
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs queued saves now, e.g. before the app is backgrounded.
|
||||
Future<void> flushPendingWrites() => _writes.flush();
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
unawaited(_writes.flush());
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
void clearAllHistories() {
|
||||
_cache.clear();
|
||||
_cacheAccessOrder.clear();
|
||||
_autoRotationIndex.clear();
|
||||
_floodStats.clear();
|
||||
_writes.dispose();
|
||||
_storage.clearAllPathHistories();
|
||||
_version = 0;
|
||||
notifyListeners();
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'app_logger.dart';
|
||||
|
||||
/// Collapses repeated persistence requests for the same key into one write.
|
||||
///
|
||||
/// Busy meshes deliver many frames a second, and each one used to rewrite a
|
||||
/// whole JSON blob (a channel's history, the contact list). Every write is a
|
||||
/// full re-encode plus a SharedPreferences write: on Linux/Windows that
|
||||
/// rewrites the entire prefs file synchronously, on Android/iOS it ships the
|
||||
/// blob across the platform channel. Scheduling instead keeps only the latest
|
||||
/// writer per key and runs them all once [delay] after the first request.
|
||||
class CoalescedWrites {
|
||||
CoalescedWrites({this.delay = const Duration(milliseconds: 750)});
|
||||
|
||||
final Duration delay;
|
||||
final Map<String, Future<void> Function()> _pending = {};
|
||||
Timer? _timer;
|
||||
|
||||
bool get hasPending => _pending.isNotEmpty;
|
||||
|
||||
/// Queues [write] under [key], replacing any write already queued for it.
|
||||
/// [write] should read the current state when it runs, not a snapshot.
|
||||
void schedule(String key, Future<void> Function() write) {
|
||||
_pending[key] = write;
|
||||
_timer ??= Timer(delay, () => unawaited(flush()));
|
||||
}
|
||||
|
||||
/// Drops the queued write for [key], e.g. because an immediate write of
|
||||
/// newer state or a delete just superseded it.
|
||||
void cancel(String key) {
|
||||
_pending.remove(key);
|
||||
}
|
||||
|
||||
/// Runs every queued write now. All writes are started synchronously before
|
||||
/// the first await, so a store that reads its scoped key on entry still sees
|
||||
/// the key that was current when the write was queued.
|
||||
Future<void> flush() {
|
||||
_timer?.cancel();
|
||||
_timer = null;
|
||||
if (_pending.isEmpty) return Future<void>.value();
|
||||
final writes = _pending.values.toList();
|
||||
_pending.clear();
|
||||
// Callers fire and forget, so a failed write is logged rather than left
|
||||
// as an unhandled async error, and never stops the other writes.
|
||||
final futures = <Future<void>>[];
|
||||
for (final write in writes) {
|
||||
try {
|
||||
futures.add(write().catchError(_logFailure));
|
||||
} catch (error) {
|
||||
_logFailure(error);
|
||||
}
|
||||
}
|
||||
return Future.wait(futures).then((_) {});
|
||||
}
|
||||
|
||||
static void _logFailure(Object error) {
|
||||
appLogger.warn('Coalesced write failed: $error', tag: 'Storage');
|
||||
}
|
||||
|
||||
void dispose() {
|
||||
_timer?.cancel();
|
||||
_timer = null;
|
||||
_pending.clear();
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,7 @@ import 'package:meshcore_open/review_mode/review_script.dart';
|
||||
import 'package:meshcore_open/services/message_retry_service.dart';
|
||||
import 'package:meshcore_open/services/path_history_service.dart';
|
||||
import 'package:meshcore_open/services/storage_service.dart';
|
||||
import 'package:meshcore_open/storage/channel_message_store.dart';
|
||||
import 'package:meshcore_open/storage/prefs_manager.dart';
|
||||
import 'package:pointycastle/export.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
@@ -185,6 +186,7 @@ void main() {
|
||||
|
||||
expect(_channelAt(1).name, 'Hiking Group');
|
||||
expect(_texts(1), isNot(contains('ghost message')));
|
||||
await _connector.flushPendingWrites();
|
||||
// The old channel's history is kept under its own ID.
|
||||
expect(_storedTexts(ghostId), ['ghost message']);
|
||||
expect(_storedTexts(hikingId), contains(_queuedHikingText));
|
||||
@@ -218,6 +220,7 @@ void main() {
|
||||
.firstWhere((m) => m.text == _queuedHikingText);
|
||||
expect(restored.channelIndex, 6);
|
||||
await _connector.deleteChannelMessage(restored);
|
||||
await _connector.flushPendingWrites();
|
||||
expect(_texts(6), isNot(contains(_queuedHikingText)));
|
||||
expect(_storedTexts(hikingId), isNot(contains(_queuedHikingText)));
|
||||
});
|
||||
@@ -237,6 +240,7 @@ void main() {
|
||||
test('deleting a channel clears its stored history', () async {
|
||||
await _connect(_TestRadio());
|
||||
await _waitFor(() => _texts(1).contains(_queuedHikingText));
|
||||
await _connector.flushPendingWrites();
|
||||
expect(_storedTexts(hikingId), isNotEmpty);
|
||||
|
||||
await _connector.deleteChannel(1);
|
||||
@@ -273,6 +277,7 @@ void main() {
|
||||
await _waitFor(() => _texts(1).contains(_queuedHikingText));
|
||||
|
||||
await _connector.deleteChannel(1);
|
||||
await _connector.flushPendingWrites();
|
||||
expect(_storedTexts(hikingId), contains(_queuedHikingText));
|
||||
},
|
||||
);
|
||||
@@ -299,6 +304,7 @@ void main() {
|
||||
seed: () => _seedSlotMap({0: _id(_psk(0)), 1: ghostId, 2: _id(_psk(2))}),
|
||||
);
|
||||
await _waitFor(() => _texts(1).contains('before the map'));
|
||||
await _connector.flushPendingWrites();
|
||||
expect(_storedTexts(hikingId), contains('before the map'));
|
||||
expect(_storedTexts(ghostId), isNot(contains('before the map')));
|
||||
});
|
||||
@@ -382,6 +388,7 @@ void main() {
|
||||
);
|
||||
await _waitFor(() => _texts(1).contains('from the twin slot'));
|
||||
expect(_texts(5), contains('from the twin slot'));
|
||||
await _connector.flushPendingWrites();
|
||||
expect(
|
||||
_storedTexts(hikingId).where((t) => t == 'from the twin slot'),
|
||||
hasLength(1),
|
||||
@@ -400,7 +407,36 @@ void main() {
|
||||
),
|
||||
);
|
||||
await _waitFor(() => _texts(2).contains('heard over the air'));
|
||||
await _connector.flushPendingWrites();
|
||||
expect(_storedTexts(localId), contains('heard over the air'));
|
||||
expect(_texts(1), isNot(contains('heard over the air')));
|
||||
});
|
||||
|
||||
test('a busy channel is capped at the stored-message limit in memory and '
|
||||
'in storage', () async {
|
||||
await _connect(_TestRadio());
|
||||
await _waitFor(() => _texts(1).contains(_queuedHikingText));
|
||||
const cap = ChannelMessageStore.maxStoredMessages;
|
||||
final start = DateTime.now().millisecondsSinceEpoch ~/ 1000;
|
||||
for (var i = 0; i < cap + 50; i++) {
|
||||
_connector.handleFrameForTest(
|
||||
ReviewFrames.channelMessage(
|
||||
channelIndex: 1,
|
||||
sender: 'Sam',
|
||||
message: 'busy $i',
|
||||
timestampSecs: start + i,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
final texts = _texts(1);
|
||||
expect(texts, hasLength(cap));
|
||||
expect(texts.last, 'busy ${cap + 49}');
|
||||
// Nothing is written per frame; the batch lands on flush.
|
||||
await _connector.flushPendingWrites();
|
||||
final stored = _storedTexts(hikingId);
|
||||
expect(stored, hasLength(cap));
|
||||
expect(stored.first, 'busy 50');
|
||||
expect(stored.last, 'busy ${cap + 49}');
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
import 'dart:math';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/connector/meshcore_protocol.dart';
|
||||
import 'package:meshcore_open/models/contact.dart';
|
||||
|
||||
String _reference(Uint8List bytes) =>
|
||||
bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join();
|
||||
|
||||
void main() {
|
||||
test('pubKeyToHex is lowercase, zero-padded hex for every byte value', () {
|
||||
final all = Uint8List.fromList(List<int>.generate(256, (i) => i));
|
||||
expect(pubKeyToHex(all), _reference(all));
|
||||
expect(pubKeyToHex(Uint8List(0)), '');
|
||||
expect(pubKeyToHex(Uint8List.fromList([0x00, 0x0a, 0xff])), '000aff');
|
||||
});
|
||||
|
||||
test('pubKeyToHex round-trips random keys through hexToPubKey', () {
|
||||
final random = Random(7);
|
||||
for (var i = 0; i < 200; i++) {
|
||||
final key = Uint8List.fromList(
|
||||
List<int>.generate(32, (_) => random.nextInt(256)),
|
||||
);
|
||||
final hex = pubKeyToHex(key);
|
||||
expect(hex, _reference(key));
|
||||
expect(hexToPubKey(hex), key);
|
||||
}
|
||||
});
|
||||
|
||||
test('Contact.publicKeyHex is stable and drives equality', () {
|
||||
final key = Uint8List.fromList(List<int>.generate(32, (i) => i * 7));
|
||||
Contact make(String name) => Contact(
|
||||
publicKey: key,
|
||||
name: name,
|
||||
type: 1,
|
||||
pathLength: -1,
|
||||
path: Uint8List(0),
|
||||
lastSeen: DateTime(2026),
|
||||
);
|
||||
final a = make('a');
|
||||
expect(a.publicKeyHex, _reference(key));
|
||||
expect(identical(a.publicKeyHex, a.publicKeyHex), isTrue);
|
||||
expect(a, make('renamed'));
|
||||
expect(a.hashCode, make('renamed').hashCode);
|
||||
expect(a.copyWith(name: 'b').publicKeyHex, a.publicKeyHex);
|
||||
});
|
||||
}
|
||||
@@ -858,6 +858,8 @@ void main() {
|
||||
svc.recordPathResult(pubKey, sel, success: true, successIncrement: 0.5);
|
||||
}
|
||||
await _flush();
|
||||
// Saves are batched; a restart only follows a flush (app backgrounded).
|
||||
await svc.flushPendingWrites();
|
||||
|
||||
final fresh = PathHistoryService(storage);
|
||||
fresh.recordPathResult(pubKey, sel, success: true, successIncrement: 0.5);
|
||||
@@ -871,6 +873,7 @@ void main() {
|
||||
test('getRecentPaths load does not drop a concurrent add', () async {
|
||||
final pubKey = _hex('k004');
|
||||
await _seed(svc, pubKey, pathBytes: [0x01], weight: 1.0);
|
||||
await svc.flushPendingWrites();
|
||||
|
||||
final fresh = PathHistoryService(storage);
|
||||
fresh.getRecentPaths(pubKey);
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/utils/coalesced_writes.dart';
|
||||
|
||||
const _delay = Duration(milliseconds: 40);
|
||||
|
||||
Future<void> _wait(int ms) => Future<void>.delayed(Duration(milliseconds: ms));
|
||||
|
||||
void main() {
|
||||
test('repeated schedules for a key run only the latest write once', () async {
|
||||
final writes = CoalescedWrites(delay: _delay);
|
||||
final ran = <String>[];
|
||||
for (var i = 0; i < 100; i++) {
|
||||
writes.schedule('channel:a', () async => ran.add('a$i'));
|
||||
}
|
||||
writes.schedule('contacts', () async => ran.add('contacts'));
|
||||
|
||||
expect(ran, isEmpty);
|
||||
await _wait(120);
|
||||
expect(ran, ['a99', 'contacts']);
|
||||
expect(writes.hasPending, isFalse);
|
||||
});
|
||||
|
||||
test('a steady stream of schedules does not push the write back', () async {
|
||||
final writes = CoalescedWrites(delay: _delay);
|
||||
var count = 0;
|
||||
final stop = DateTime.now().add(const Duration(milliseconds: 300));
|
||||
while (DateTime.now().isBefore(stop)) {
|
||||
writes.schedule('k', () async => count++);
|
||||
await _wait(5);
|
||||
}
|
||||
// Persistence keeps landing while frames keep arriving.
|
||||
expect(count, greaterThanOrEqualTo(3));
|
||||
await writes.flush();
|
||||
});
|
||||
|
||||
test('flush starts every write synchronously and clears the queue', () {
|
||||
final writes = CoalescedWrites();
|
||||
final ran = <String>[];
|
||||
writes.schedule('a', () async => ran.add('a'));
|
||||
writes.schedule('b', () async => ran.add('b'));
|
||||
|
||||
final done = writes.flush();
|
||||
// Stores read their scoped key on entry, before any await.
|
||||
expect(ran, ['a', 'b']);
|
||||
expect(writes.hasPending, isFalse);
|
||||
return done;
|
||||
});
|
||||
|
||||
test('cancel drops a queued write', () async {
|
||||
final writes = CoalescedWrites(delay: _delay);
|
||||
var ran = false;
|
||||
writes.schedule('channel:a', () async => ran = true);
|
||||
writes.cancel('channel:a');
|
||||
await _wait(120);
|
||||
expect(ran, isFalse);
|
||||
});
|
||||
|
||||
test('a failing write does not stop the others', () async {
|
||||
final writes = CoalescedWrites();
|
||||
var ran = false;
|
||||
writes.schedule('bad', () => throw StateError('boom'));
|
||||
writes.schedule('good', () async => ran = true);
|
||||
await writes.flush();
|
||||
expect(ran, isTrue);
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user