diet-guard/diet_guard/_sync_refresh.py
Krzysztof kuhy Rudnicki dfd60d4f7b Close the open gate when a phone meal arrives
A meal logged on the phone while the gate window was up changed nothing
until Fetch was pressed: the new credit watch only fires on a local
write to the food log, and the PC never pulled on its own.

While a non-demo window is open it now pulls peer logs every 30 s, with
the Fetch button's own narrow pull on a worker thread. One pull is in
flight at a time (shared with the button), failures are logged and
retried, and the window stays up. The pull's write trips the watch,
which closes through the usual reconcile path. gatelock moves to 0.14.0
for watch_credit.

refresh_peer_logs also read the local log before the peer downloads and
wrote it after, so a meal logged during the pull was overwritten. It now
merges the peers first and reads the local log just before the write.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWWfb63jncj9Lca2jeX
2026-11-16 09:18:07 +01:00

206 lines
8.0 KiB
Python

"""The gate's narrow, pre-lock refresh: peer logs only, no push.
``_sync.run_sync`` is the *full* tick -- peer logs, the budget, both food
banks, a rebuild and a push. That is the right thing to run after a meal is
logged, and it is what :func:`~diet_guard._sync_events.publish_after_log`
still does. It is the wrong thing to run *in front of a fullscreen lock*: the
banks alone measured ~21s against the live remote (the curated bank is absent
on Firebase for every peer, so each of ~21 peers fell through to a GitHub
round trip that returned ``{}``), and the budget loop another ~2.6s.
The gate has exactly one question to answer -- *"has a peer already logged
this slot?"* -- and only the peer **logs** can answer it. So this module does
that and nothing else:
* one bulk read of the revision map (~83ms, a single request),
* a fetch of only those peers whose revision actually moved,
* merge, re-sign, write.
No budget, no banks, no ``rebuild_food_bank``, and **no push**. The full tick
still runs after the window closes, so nothing is permanently skipped -- the
exhaustive pass is merely moved off the path the user waits on.
**Accepted trade:** a budget edited on the phone is not visible in the lock
window's dashboard until that post-window tick. It cannot affect the lock
*decision*, which is why it is safe to defer, but it is user-visible and so
recorded here rather than left implicit.
"""
from __future__ import annotations
import json
import logging
from typing import TYPE_CHECKING
from crdt_sync import (
FileSyncStateStore,
Log,
RemoteSyncError,
SyncState,
merge_logs,
revision_of,
)
from diet_guard import _sync
from diet_guard._device import device_identity
from diet_guard._state_sync import read_raw_log, resign_entry, write_raw_log
from diet_guard._sync import _remote_revisions
from diet_guard._sync_client import _client_for_interactive_run
from diet_guard._sync_e2e import read_sealed
from diet_guard._sync_errors import SyncError
from diet_guard._sync_paths import _DEVICES_DIR, _device_log_path
from diet_guard.sync_merge import daylog_to_log, log_to_daylog, parse_remote_log
if TYPE_CHECKING:
from crdt_sync import RemoteStore
_logger = logging.getLogger(__name__)
def _candidate_peers(
client: RemoteStore,
remote_revs: dict[str, str],
state: SyncState,
) -> list[str]:
"""Return the device ids worth considering, without a directory listing.
``list_directory`` is the single most expensive call in a tick (~445ms,
because the mirrored GitHub half alone is ~360ms), and the revision map
already names every peer that has ever published one. Union it with the
peers we have merged before so a device that stopped publishing revisions
is still reachable.
Falls back to the real listing when the revision map is empty -- a
GitHub-only device has no ``get_string_map``, and there "no revisions"
means "no information", not "no peers".
"""
if not remote_revs:
return list(client.list_directory(_DEVICES_DIR))
return sorted(set(remote_revs) | set(state.peer_revs))
def _peer_is_current(
device_id: str,
remote_revs: dict[str, str],
state: SyncState,
) -> bool:
"""Return True when ``device_id`` holds nothing this device has not merged.
Two ways to be current, and the second is specific to this narrow pass:
* the peer publishes a revision equal to the one already merged, or
* the peer publishes **no** revision but has been merged before.
The second rule is what removes the standing ~1.25s cost of the frozen
legacy role-id directories, which can never satisfy the first. It is sound
only because this pass is *not* the authoritative one: the post-window full
tick still reads every peer exhaustively, and a union CRDT cannot lose a
record that arrives a tick later.
Membership is tested with ``in``, never ``.get(...) is not None`` --
``peer_revs`` legitimately holds explicit null values, and treating those
as "never seen" would re-download them on every single tick forever.
"""
remote_rev = remote_revs.get(device_id)
if remote_rev is None:
return device_id in state.peer_revs
return remote_rev == state.peer_revs.get(device_id)
def _merge_peer_logs(
client: RemoteStore,
peers: list[str],
remote_revs: dict[str, str],
merged: Log,
seen: dict[str, str],
) -> tuple[Log, bool]:
"""Merge each peer's pushed log into ``merged``; report whether any landed."""
changed = False
for device_id in peers:
text = read_sealed(client, _device_log_path(device_id))
if text is None:
continue
try:
merged = merge_logs(merged, parse_remote_log(text))
except TypeError, KeyError, ValueError, json.JSONDecodeError:
# A corrupt push must be retried next tick, not remembered as
# merged -- so deliberately not recorded in ``seen``.
_logger.warning("Unparsable log pushed by device %r, skipping", device_id)
continue
seen[device_id] = remote_revs.get(device_id) or revision_of(text)
changed = True
return merged, changed
def refresh_peer_logs() -> None:
"""Merge any newly-published peer log into the local one.
Raises:
SyncError: If no backend is configured.
crdt_sync.RemoteSyncError: On any transport failure.
"""
client = _client_for_interactive_run()
identity = device_identity()
# Via the module, not a direct import: the suite redirects
# ``_sync.SYNC_STATE_FILE`` to a tmp path, and a private copy of the
# constant would escape that redirect and write real user state.
state_store = FileSyncStateStore(_sync.SYNC_STATE_FILE)
state = state_store.load()
remote_revs = _remote_revisions(client)
peers = [
device_id
for device_id in _candidate_peers(client, remote_revs, state)
if not identity.is_own(device_id)
and not _peer_is_current(device_id, remote_revs, state)
]
if not peers:
return
seen: dict[str, str] = {}
# Peers merge into an empty log; the local log is read only after the slow
# network reads. A union is commutative, so the result is identical, but a
# meal logged while the peers downloaded (the open gate now pulls on a
# timer) is read here instead of being overwritten by a seconds-old snapshot.
peer_log, changed = _merge_peer_logs(client, peers, remote_revs, {}, seen)
if not changed:
return
merged = merge_logs(daylog_to_log(read_raw_log()), peer_log)
# Re-sign every entry, not just the newly arrived ones: a signature made on
# another device is not valid under this device's key, and ``load_log``
# drops unsigned entries outright -- that is how a phone-logged meal would
# vanish on the very next read.
resigned = {
day: [resign_entry(entry) for entry in entries]
for day, entries in log_to_daylog(merged).items()
}
# Log first, state second. If the state landed and this write failed, a peer
# would be recorded as merged while its records were absent -- silent loss.
write_raw_log(resigned)
# ``pushed_rev`` verbatim: this pass never pushes, and overwriting it would
# convince the next full tick it had already published, silently making this
# device invisible to every peer. ``peer_revs`` merged, not replaced: only
# changed peers were visited, so a wholesale replace would drop the ~20
# untouched entries and re-download all of them next tick.
state_store.save(
SyncState(
pushed_rev=state.pushed_rev,
peer_revs={**state.peer_revs, **seen},
)
)
def pull_peer_logs() -> str | None:
"""Run :func:`refresh_peer_logs`, failing closed instead of raising.
Mirrors :func:`diet_guard._sync.pull_shared_log`'s contract exactly --
``None`` on success, a short human-readable reason otherwise -- so the gate
keeps its own local lock decision rather than failing open on an outage.
"""
try:
refresh_peer_logs()
except (SyncError, RemoteSyncError, OSError) as exc:
return f"sync unavailable ({exc})"
return None