mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-19 23:14:25 +01:00
Some checks failed
dependency freshness / dependencies on newest stable (push) Has been cancelled
file-length / file length <= 250 lines (push) Has been cancelled
md-naming / markdown naming convention (push) Has been cancelled
pre-commit / pre-commit (${{ matrix.group }}) (mypy, mypy, ) (push) Has been cancelled
pre-commit / pre-commit (${{ matrix.group }}) (pylint, pylint, ) (push) Has been cancelled
pre-commit / pre-commit (${{ matrix.group }}) (rest, , mypy,pylint) (push) Has been cancelled
Tests / test (push) Has been cancelled
release-apk / release (APK) (push) Has been cancelled
repo-contract / repo contract (push) Has been cancelled
Every sync payload (food log, banks, budget, catering credential, Body, export keyring) now lives on diet-guard-sync/devices-e2e, sealed with the Argon2id key from the shared crdt-sync passphrase; record ids, tombstones and clocks stay clear. Old plaintext nodes are copied once and never written or deleted. Locked = no pull, no push. - PC: _sync_e2e.open_e2e over crdt-sync 0.11.0, key and copy memo in ~/.local/share/diet_guard/e2e; undecryptable peers are skipped. - Phone/desktop: sync_e2e.dart, crdt_sync_flutter 0.8.1, lock icon in Settings; pullExportKeys goes through the same open. - wake-alarm weigh-ins read from wake-alarm-sync/devices-e2e (own header), on both sides. Todo: fda71ed1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
197 lines
7.4 KiB
Dart
197 lines
7.4 KiB
Dart
/// Cross-device log sync orchestration for the diet_guard companion app.
|
|
///
|
|
/// Pulls every other device's pushed log from GitHub-backed dumb storage via
|
|
/// crdt_sync's shared transport ([GitHubClient]/[syncLog]), merges with the
|
|
/// local log via crdt_sync's shared CRDT scheme (`sync_merge.dart` adapts
|
|
/// [FoodEntry]s to/from [Record]), rebuilds the food bank, and pushes this
|
|
/// device's own merged log back up in the new Record-based wire format.
|
|
///
|
|
/// The daily budget syncs alongside the food log in the same tick (see
|
|
/// [_syncBudget]): a sibling `budget.json` per device, merged
|
|
/// last-writer-wins by edit time rather than union-of-immutable-entries,
|
|
/// since a budget (unlike a food-log entry) can be edited repeatedly.
|
|
library;
|
|
|
|
import 'dart:developer';
|
|
|
|
import 'package:crdt_sync/crdt_sync.dart';
|
|
import 'package:diet_guard_app/models/food_entry.dart';
|
|
import 'package:diet_guard_app/services/export_keyring_default.dart';
|
|
import 'package:diet_guard_app/services/export_keyring_sync.dart';
|
|
import 'package:diet_guard_app/services/foodbank_service.dart';
|
|
import 'package:diet_guard_app/services/kuchnia_credential_service.dart';
|
|
import 'package:diet_guard_app/services/log_storage_service.dart';
|
|
import 'package:diet_guard_app/services/sync_body.dart';
|
|
import 'package:diet_guard_app/services/sync_budget_local.dart';
|
|
import 'package:diet_guard_app/services/sync_device_id.dart';
|
|
import 'package:diet_guard_app/services/sync_e2e.dart';
|
|
import 'package:diet_guard_app/services/sync_merge.dart';
|
|
import 'package:diet_guard_app/services/sync_merge_kuchnia.dart';
|
|
import 'package:diet_guard_app/services/sync_state_factory.dart';
|
|
|
|
const String _devicesDir = syncDevicesDir;
|
|
|
|
/// Runs one full sync tick: pull, merge, persist, push.
|
|
///
|
|
/// [backend] is the outermost raw store (the Firebase/GitHub mirror);
|
|
/// everything goes through its end-to-end encrypted view, and a locked
|
|
/// device throws [SyncLockedException] before a single read or write.
|
|
///
|
|
/// Returns the merged log as it now sits on disk locally. Propagates any
|
|
/// [GitHubSyncError] from the client for the caller (auto-sync / the manual
|
|
/// "Sync now" action) to decide how to report.
|
|
Future<DayLog> runSync(
|
|
RemoteStore backend, {
|
|
SyncStateStore? stateStore,
|
|
}) async {
|
|
final client = await openDietGuardStore(backend);
|
|
final wakeAlarm = await openWakeAlarmStore(backend);
|
|
final logService = LogStorageService.instance;
|
|
final local = await logService.readLog();
|
|
|
|
final mergedLog = await syncLog(
|
|
client: client,
|
|
deviceId: currentSyncDeviceId,
|
|
legacyDeviceId: legacySyncDeviceId,
|
|
pathPrefix: _devicesDir,
|
|
revsPath: syncRevsDir,
|
|
localLog: dayLogToLog(local),
|
|
encode: encodeLogForPush,
|
|
decode: parseRemoteLog,
|
|
filename: 'food_log.json',
|
|
commitMessage: 'diet_guard_app sync',
|
|
// Without this every sync re-downloads every peer's whole food log --
|
|
// hundreds of KB -- whether or not anything changed, and re-pushes an
|
|
// unchanged one. That is the traffic the Firebase free tier's monthly
|
|
// budget depends on not happening.
|
|
stateStore: stateStore ?? await openSyncStateStore(),
|
|
);
|
|
|
|
final merged = logToDayLog(mergedLog);
|
|
|
|
await logService.writeLog(merged);
|
|
await FoodBankService.instance.rebuildAndPersist(merged);
|
|
await _syncBudget(client);
|
|
await _syncFoodBank(client);
|
|
await _syncManualBank(client);
|
|
await _syncKuchniaCredential(client);
|
|
await _syncExportKeys(client);
|
|
await syncBody(client, devicesDir: _devicesDir, wakeAlarm: wakeAlarm);
|
|
return merged;
|
|
}
|
|
|
|
/// Pulls, merges, persists and pushes the log-derived food bank.
|
|
///
|
|
/// Runs after the local rebuild above, so this device's records already
|
|
/// reflect the merged log; the merge then unions in whatever another device
|
|
/// knows, max-count winning per food. Mirrors `_sync._sync_food_bank`.
|
|
Future<void> _syncFoodBank(RemoteStore client) async {
|
|
final merged = await syncLog(
|
|
client: client,
|
|
deviceId: currentSyncDeviceId,
|
|
legacyDeviceId: legacySyncDeviceId,
|
|
pathPrefix: _devicesDir,
|
|
revsPath: syncRevsDir,
|
|
localLog: foodBankToLog(await FoodBankService.instance.readBank()),
|
|
encode: encodeFoodBankForPush,
|
|
decode: parseRemoteFoodBank,
|
|
filename: 'food_bank.json',
|
|
commitMessage: 'diet_guard_app sync',
|
|
);
|
|
await FoodBankService.instance.writeBank(logToFoodBank(merged));
|
|
}
|
|
|
|
/// Pulls, merges, persists and pushes the hand-curated food bank.
|
|
///
|
|
/// Curated entries are the one part of the bank that is not derivable from
|
|
/// the food log, so unlike `food_bank.json` they need a real merge:
|
|
/// last-writer-wins per food name by edit time, union across devices. Mirrors
|
|
/// `_sync._sync_manual_bank`.
|
|
Future<void> _syncManualBank(RemoteStore client) async {
|
|
final local = await FoodBankService.instance.readManualBank();
|
|
final merged = await syncLog(
|
|
client: client,
|
|
deviceId: currentSyncDeviceId,
|
|
legacyDeviceId: legacySyncDeviceId,
|
|
pathPrefix: _devicesDir,
|
|
revsPath: syncRevsDir,
|
|
localLog: manualBankToLog(local),
|
|
encode: encodeManualBankForPush,
|
|
decode: parseRemoteManualBank,
|
|
filename: 'food_bank_manual.json',
|
|
commitMessage: 'diet_guard_app sync',
|
|
);
|
|
await FoodBankService.instance.applyMergedManualBank(logToManualBank(merged));
|
|
}
|
|
|
|
/// Pulls other devices' budgets, merges, applies the winner locally, pushes.
|
|
Future<void> _syncBudget(RemoteStore client) async {
|
|
final mergedBudgetLog = await syncLog(
|
|
client: client,
|
|
deviceId: currentSyncDeviceId,
|
|
legacyDeviceId: legacySyncDeviceId,
|
|
pathPrefix: _devicesDir,
|
|
revsPath: syncRevsDir,
|
|
localLog: localBudgetLog(),
|
|
encode: encodeBudgetForPush,
|
|
decode: parseRemoteBudget,
|
|
filename: 'budget.json',
|
|
commitMessage: 'diet_guard_app sync',
|
|
);
|
|
await applyBudgetLog(mergedBudgetLog);
|
|
}
|
|
|
|
/// Syncs the export keyring; best effort, since sync must not fail on it.
|
|
Future<void> _syncExportKeys(RemoteStore client) async {
|
|
try {
|
|
await syncExportKeys(
|
|
client,
|
|
keyring: defaultKeyring(),
|
|
devicesDir: _devicesDir,
|
|
);
|
|
} on Object catch (error, stackTrace) {
|
|
log(
|
|
'export key sync failed',
|
|
level: 900,
|
|
error: error,
|
|
stackTrace: stackTrace,
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Pulls peers' catering credentials, merges, applies the winner locally.
|
|
///
|
|
/// The phone runs its own catering importer, so it cannot fetch anything until
|
|
/// the panel password reaches it -- that is the whole reason this credential
|
|
/// syncs at all. Sealed end-to-end like the rest of the synced state.
|
|
///
|
|
/// A device that has no credential contributes an empty log, so it neither
|
|
/// blocks nor clobbers a peer's real value -- it relays it. Mirrors
|
|
/// `diet_guard/_sync_kuchnia.py`.
|
|
Future<void> _syncKuchniaCredential(RemoteStore client) async {
|
|
if (!KuchniaCredentialService.isInitialized) return;
|
|
final merged = await syncLog(
|
|
client: client,
|
|
deviceId: currentSyncDeviceId,
|
|
legacyDeviceId: legacySyncDeviceId,
|
|
pathPrefix: _devicesDir,
|
|
revsPath: syncRevsDir,
|
|
localLog: credentialToLog(
|
|
KuchniaCredentialService.username,
|
|
KuchniaCredentialService.password,
|
|
KuchniaCredentialService.editedAt,
|
|
),
|
|
encode: encodeCredentialForPush,
|
|
decode: parseRemoteCredential,
|
|
filename: 'kuchnia.json',
|
|
commitMessage: 'diet_guard_app sync',
|
|
);
|
|
final credential = logToCredential(merged);
|
|
if (credential == null) return;
|
|
await KuchniaCredentialService.instance.applySynced(
|
|
credential.username,
|
|
credential.password,
|
|
credential.editedAt,
|
|
);
|
|
}
|