hub: review fix 1 — a box that lies about its app list cannot have the store agreed in one window unseen (D84 narrowed)

The hub's 30-day check rests on the box's own reports: a box could name an app
that never existed, or stop listing a living one, wait 30 days, and get every
snapshot agreed beside the cap, with no operator signal.

- One window agrees to at most the size of its own cap, from the hub's OWN
  count of the store; the oldest files first; the rest waits for the next
  window. A narrowing of D84, decided by CC unattended — the operator may
  reverse it (07 §8.2f holds the question, both options and their cost).
- offsite_end_claim_unseen (warning, mailed, operator-only): a box first names
  an app the hub never saw installed — once per household and app, at most 8
  per household, 30 days before anything can be agreed.
- offsite_ended_large_agreement (warning, mailed, operator-only): a request
  for more than half of the store waits one week; that window agrees to none.
- 07 §8.2f: the limit rewritten (no honest ended app is needed, only 30 days),
  what bounds it, what is still open. 08 §6.5: the two events.

Also carries the red-proof outputs of the controller's review fixes 2 and 3
(felhom-controller 3928c3d and the next commit).

Tests seen red on bb226f23; 15 mutations seen red (redproof-review-1.txt).

Claude-Session: https://claude.ai/code/session_0159rPz1ZhFKsS53msqPYxtS
This commit is contained in:
admin committed 2026-11-15 14:41:58 +01:00
1 parent 90ba98b1a0
commit 875c339cf5
13 files changed
+839 -23

No files matched your search

@@ -1881,7 +1881,8 @@ section adds one thing to that window.
5. **Local copies are unchanged.** They are deleted at once, as before. The dialog says both.
**The allowance (D84)** `[FACT — built, not released]`. The window's cap (`max_remove`, half the store, at least 5)
and its rule are not touched: the guard still refuses a policy plan above it. The ended apps' ids are BESIDE it — the
and its rule are not touched: the guard still refuses a policy plan above it. **One window's allowance is at most the
size of that cap (a narrowing of D84 by CC, below).** The ended apps' ids are BESIDE it — the
hub stores the ids it agreed to on the window's row, keeps from the box's result only those, and allows a fall of the
cap plus those. `store.WindowCreditsBetween` gives the two parts apart.
@@ -1915,6 +1916,10 @@ notification address gets no mail: the page is all it has.** A blocked household
| The guard refuses the window (a future-dated snapshot, a plan above the cap) | The ended apps wait with everything else | `TestD84_OneGuard_AndTheAllowanceIsBesideTheCap` |
| The hub does not know ended apps (an older hub), or the box does not (an older controller) | Nothing of an ended app is removed; each side is releasable alone | `TestD84_TheBoxRemovesOnlyWhatTheHubAgreedTo` |
| The app has no copy in the store at all | The due record is closed with no history line; nothing is asked of the hub | `TestD72_ARecordWithNoCopiesIsClosedQuietly` |
| A take-back or an install while the window is being prepared (the hub answers, the dry run, the guard) | The window reads the records AGAIN immediately before the forget; an id whose record is gone or changed is not removed. A take-back during the forget itself is answered „not marked, or already deleted”. **Not covered:** an install during the forget | `TestD72_ATakeBackDuringTheWindowKeepsTheCopies`, `TestD72_AnInstallDuringTheWindowKeepsTheCopies`, `TestD72_ATakeBackDuringTheForgetIsNotAnsweredKept` |
| The app is installed again by an import, or by a restore that installs from a unit | The record is deleted at the ONE point every install passes (`stacks.SaveAppConfig`) | `TestD72_AnImportDeletesTheEndRecord`, `TestD72_ARestoreIntoAnInstallDeletesTheEndRecord`, `TestD72_TheInstallWritersAreListed` |
| A box names an app the hub never saw installed | The operator is mailed at once; the hub's 30 days start then | hub `TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce` |
| A request for more than half of the store | It waits one week after a mail to the operator; then at most the cap's size per window | hub `TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize`, `TestD84_TheRestGoesInTheNextWindow` |
| A box sends invented app names in every report | The hub's app record holds at most 400 names per household; only names shaped like an app name are stored. No age limit on a row, on purpose: it would move a real app's 30 days | hub `TestD72_AppRecord_*` |
**What differs from the 2026-11-14 design, and what is not built.**
@@ -1931,10 +1936,39 @@ notification address gets no mail: the page is all it has.** A blocked household
- *The receipt does not read the household's group switches.* D84's reason is a household whose login someone else
uses; that person could switch a group off first. **The operator may reverse this.**
**A limit, said plainly.** The hub cannot read a snapshot's tags (the repository is encrypted; the password never
leaves the box — decision 68). A box that is taken over AND has one honestly ended app can name, under that app,
other snapshots that are older than the app's end. The upload-time rule bounds that to files older than 30 days; it
does not close it. The same box can already remove half the store per week inside the cap.
**A limit, said plainly (rewritten after the review of 2026-11-15).** The hub cannot read a snapshot's tags (the
repository is encrypted; the password never leaves the box — decision 68), and its record of which apps a box runs is
made from what the box reports. So **no honestly ended app is needed, only 30 days**: a box that is taken over can
name an app that never existed in a pending end record, or stop listing a living app, wait 30 days by the hub's
clock, and then name snapshots of other apps under it. What bounds that now, all on the hub:
- **A name the hub never saw installed is told to the operator at once** — a mailed warning
(`offsite_end_claim_unseen`), once per household and app, when the box first names it: 30 days before the hub could
agree to anything. It names the household, the app and the day the hub would agree. At most 8 per household.
- **A request for more than half of the store waits one week.** The first window that sees it agrees to nothing for
removed apps and mails the operator (`offsite_ended_large_agreement`); only a window at least six days later
agrees. The week belongs to those apps: another app set waits its own week.
- **One window agrees to at most the size of its own cap** — and the cap the hub's OWN count of the store gives, not
the box's `count_before`. The oldest files go first; the rest waits for the next window.
- An id is agreed only if the hub's own listing holds it, uploaded before the hub saw the app leave — so nothing
younger than 30 days can go this way.
- A box that removes more than was agreed raises the drop alarm at the close and the vanished-files alarm at 07:10.
**What is still open:** a box that stops listing a living app is NOT told at the start (it looks exactly like an
honest removal); the hub hears of it only in the window, and then only if the request is for more than half of the
store. Under that size, such a box can remove up to the cap's size per week beside the cap, without a mail — twice
what it could remove silently before this feature (R-822's accepted limit, `09` §3 decision 166). And one window can
still take the cap AND the cap's size again; after a large request that is a week after the operator was mailed.
**A narrowing of D84 — decided by CC unattended on 2026-11-15; the operator may reverse it.** *Question:* may one
window remove every snapshot the hub agreed to for removed apps, however many? *Option A (built):* no — at most the
size of the window's own cap per window, and a request for more than half of the store waits one week after a mail to
the operator. **Cost:** a household that removes a very large app has its off-site copies deleted over two or more
weekly windows, and waits one week more when the app was more than half of its store; one more operator mail per such
removal. *Option B (D84 as ruled, 309):* every agreed id in the first window. **Cost:** a box that lies about its app
list for 30 days can have the whole store removed in one window, and the first mail arrives with the deletion. *Why A:*
the ruling's own reason for the allowance was that the hub's 30-day check does the cap's job; the review showed the
30-day check rests on the box's own reports, so it cannot do that job alone.
**The texts, as built — NOT published; the operator reads them before a release.** The Hungarian date carries its own
final dot (`2026. 12. 15.`), so the Hungarian sentences have no dot after it.
@@ -472,6 +472,8 @@ own records. What that adds here:
|---|---|---|---|
| `offsite_end_scheduled` (from the box) | info | **the household** — a receipt: one mail per press to its own notification address, whatever its group switches say; never the operator (`notify.householdReceiptEvents`) | the household pressed „delete backup data” at a removal, or „delete in 30 days” on the restore page |
| `offsite_ended_app_removed` (hub) | info | operator-only, recorded, not mailed | a window removed an app's agreed snapshots — one per app, with the count |
| `offsite_end_claim_unseen` (hub; review of 2026-11-15) | warning, **mailed** | operator-only, once per household and app, at most 8 per household | a box first names, in a pending end record, an app the hub never saw in its app list — 30 days before the hub could agree to anything. The text names the household, the app and the day |
| `offsite_ended_large_agreement` (hub; review of 2026-11-15) | warning, **mailed** | operator-only, once per app set | a window was asked to remove more than half of the store's snapshots for removed apps. That window removes none of them; a window a week later does, at most the cap's size |
| `offsite_ended_app_refused` (hub) | warning | operator-only, once per app (details `subject`) | a box asked for an app the hub's records clearly do not show ended: the app is in its app list, or absent for less than 29 days. A box that asks less than a day early is refused quietly |
The count detector above and the 07:10 listing check (`offsite_snapshots_vanished`) both know the allowance: a window
@@ -0,0 +1,110 @@
FINDING 1 — a box could invent an ended app (or stop listing a living one), wait 30 days, and have the hub agree to the whole store beyond the cap, with no operator signal.
### RED: the new tests on the hub code as it was pushed (felhom.eu bb226f23), before the fix
(the first three tests had, at that point, the first shape of the rule: one window at most the cap's size; the rule then grew a week's wait — see the note below)
=== RUN TestD84_OneWindowAgreesAtMostTheCapsSize
ended_bound_test.go:55: one window agreed to 20 ended ids with a cap of 10 — the allowance must be at most the cap's size
--- FAIL: TestD84_OneWindowAgreesAtMostTheCapsSize (0.06s)
=== RUN TestD84_TheRestGoesInTheNextWindow
ended_bound_test.go:103: first window: 15 agreed, want the cap's size 10
--- FAIL: TestD84_TheRestGoesInTheNextWindow (0.05s)
=== RUN TestD84_TheAllowanceIsBoundByTheHubsOwnCount
ended_bound_test.go:143: a box that claims 1000 snapshots got 20 ended ids agreed; the hub's own listing holds 20 → at most 10
--- FAIL: TestD84_TheAllowanceIsBoundByTheHubsOwnCount (0.04s)
=== RUN TestD84_ASmallEndIsQuiet
ended_bound_test.go:159: offsite_ended_large_agreement must be operator-only
--- FAIL: TestD84_ASmallEndIsQuiet (0.04s)
FAIL
FAIL gitea.dooplex.hu/admin/felhom-hub/internal/offsitekeys 0.199s
FAIL
=== RUN TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce
d84_unseen_claim_test.go:52: want ONE warning for the app the hub never saw, got 0
--- FAIL: TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce (0.05s)
FAIL
FAIL gitea.dooplex.hu/admin/felhom-hub/internal/api 0.068s
FAIL
### After the fix: mutations
== MUTATION: a request for more than half of the store does not wait
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize (0.05s)
ended_bound_test.go:74: the window that first saw a request for the whole store agreed to 10 ids — it must agree to none and tell the operator first
--- FAIL: TestD84_ALargeRequestForOtherAppsWaitsItsOwnWeek (0.05s)
ended_bound_test.go:143: a large request for another app rode the first app's week: agreed 10, refused [{App: Reason:10 snapshot id(s) wait for the next window: one window removes at most 10 snapshots of removed apps (the size of
== MUTATION: the wait is not a week (two days later it is agreed)
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize (0.09s)
ended_bound_test.go:105: two days after the warning a window agreed to 10 ids — the operator must have a week
== MUTATION: the operator is mailed at every window of one large request
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize (0.10s)
ended_bound_test.go:125: the operator was told 2 time(s) about one large request, want once
== MUTATION: one window agrees to everything (no bound to the cap's size)
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize (0.10s)
ended_bound_test.go:110: a week later: 20 ended ids agreed with a cap of 10 — want exactly the cap's size
--- FAIL: TestD84_TheRestGoesInTheNextWindow (0.05s)
ended_bound_test.go:163: a week later: 15 agreed, want the cap's size 10
== MUTATION: the bound takes the box's own count (count_before) alone
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_TheAllowanceIsBoundByTheHubsOwnCount (0.04s)
ended_bound_test.go:206: a box that claims 1000 snapshots got 20 ended ids agreed; the hub's own listing holds 20 → at most 10
== MUTATION: the newest files go first
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize (0.11s)
ended_bound_test.go:118: the allowance did not take the oldest files first: a1b2c684 agreed
== MUTATION: „more than half” is „more than twice the store”
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize (0.05s)
ended_bound_test.go:74: the window that first saw a request for the whole store agreed to 10 ids — it must agree to none and tell the operator first
--- FAIL: TestD84_ALargeRequestForOtherAppsWaitsItsOwnWeek (0.05s)
ended_bound_test.go:143: a large request for another app rode the first app's week: agreed 10, refused [{App: Reason:10 snapshot id(s) wait for the next window: one window removes at most 10 snapshots of removed apps (the size of
== MUTATION: a large request for other apps rides an earlier request's week
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ALargeRequestForOtherAppsWaitsItsOwnWeek (0.05s)
ended_bound_test.go:143: a large request for another app rode the first app's week: agreed 10, refused [{App: Reason:10 snapshot id(s) wait for the next window: one window removes at most 10 snapshots of removed apps (the size of
8 mutations, 0 not a red-proof
== MUTATION: no limit on the never-seen warnings of one household
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce (0.06s)
d84_unseen_claim_test.go:75: 40 invented names gave 41 operator warnings — a box must not be able to flood the operator (limit 8 per household)
== MUTATION: the never-seen mark is not stored (the limit is per report)
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce (0.06s)
d84_unseen_claim_test.go:75: 40 invented names gave 9 operator warnings — a box must not be able to flood the operator (limit 8 per household)
== MUTATION: an app the hub SAW installed is told as never seen
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce (0.05s)
d84_unseen_claim_test.go:45: an app the hub saw installed raised the never-seen warning: [{ID:1 CustomerID:c1 EventType:offsite_end_claim_unseen Severity:warning Message:Off-site: the box of c1 holds an end record for the app "vik
3 mutations, 0 not a red-proof
== MUTATION: the operator is not told about a never-seen app
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce (0.05s)
d84_unseen_claim_test.go:52: want ONE warning for the app the hub never saw, got 0
== MUTATION: the message names today, not the day the hub would agree
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce (0.05s)
d84_unseen_claim_test.go:56: the warning must be a warning and name the household, the app and the day the hub would agree (2026-12-15): {ID:1 CustomerID:c1 EventType:offsite_end_claim_unseen Severity:warning Message:Off-site: the
== MUTATION: the warning has no per-app subject (two apps in an hour are one mail)
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce (0.04s)
d84_unseen_claim_test.go:59: no per-app subject in the details: {"agrees_from":"2026-12-15","app":"ghost"}
3 mutations, 0 not a red-proof
== MUTATION: the two warnings are not operator-only
RED on the mutant, GREEN on the real file
--- FAIL: TestD84_ASmallEndIsQuiet (0.04s)
ended_bound_test.go:222: offsite_ended_large_agreement must be operator-only
1 mutations, 0 not a red-proof
NOTE. The RED block above was taken with the first shape of the fix's tests (one window agrees to at most the cap's
size). While fixing, that bound alone still let one window take the cap AND the cap's size again — a store of 20
emptied in one window with the operator's mail arriving at the same moment. So the rule grew: a request for more
than half of the store waits one week after the mail. The tests were rewritten for that rule
(TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize, TestD84_TheRestGoesInTheNextWindow,
TestD84_ALargeRequestForOtherAppsWaitsItsOwnWeek); the mutations above run against the rewritten tests.
The reviewer's own reproduction (scratchpad r4/review-A/zz_ghost_test.go: "all 20 snapshots agreed for an app the hub
never saw installed; cap was 10; no alarm") is the same defect as the first RED line.
@@ -0,0 +1,52 @@
FINDING 2 — a take-back or an install during the window still deleted.
### RED: the new tests on the code as it was pushed (controller f628cb5), before the fix
=== RUN TestD72_ATakeBackDuringTheWindowKeepsTheCopies
offbox_ended_race_test.go:48: the page said „the off-site copies are kept”, no record exists, and the window removed kimai's copy ([k1-full v1-full v2-full v3-full])
--- FAIL: TestD72_ATakeBackDuringTheWindowKeepsTheCopies (0.00s)
=== RUN TestD72_AnInstallDuringTheWindowKeepsTheCopies
=== RUN TestD72_AnInstallDuringTheWindowKeepsTheCopies/the_install_deleted_the_record
offbox_ended_race_test.go:91: the window removed [k1-full] of an app that was installed again while the hub answered
=== RUN TestD72_AnInstallDuringTheWindowKeepsTheCopies/the_app_is_living_again_(the_record_is_still_there)
offbox_ended_race_test.go:91: the window removed [k1-full] of an app that was installed again while the hub answered
=== RUN TestD72_AnInstallDuringTheWindowKeepsTheCopies/removed_again:_a_NEW_record_with_a_new_time
offbox_ended_race_test.go:91: the window removed [k1-full] of an app that was installed again while the hub answered
--- FAIL: TestD72_AnInstallDuringTheWindowKeepsTheCopies (0.00s)
--- FAIL: TestD72_AnInstallDuringTheWindowKeepsTheCopies/the_install_deleted_the_record (0.00s)
--- FAIL: TestD72_AnInstallDuringTheWindowKeepsTheCopies/the_app_is_living_again_(the_record_is_still_there) (0.00s)
--- FAIL: TestD72_AnInstallDuringTheWindowKeepsTheCopies/removed_again:_a_NEW_record_with_a_new_time (0.00s)
FAIL
FAIL gitea.dooplex.hu/admin/felhom-controller/internal/backup 0.023s
FAIL
### After the fix: mutations
== MUTATION: the window does not look at the records again before the forget
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_ATakeBackDuringTheWindowKeepsTheCopies (0.00s)
offbox_ended_race_test.go:48: the page said „the off-site copies are kept”, no record exists, and the window removed kimai's copy ([k1-full v1-full v2-full v3-full])
--- FAIL: TestD72_AnInstallDuringTheWindowKeepsTheCopies (0.00s)
offbox_ended_race_test.go:91: the window removed [k1-full] of an app that was installed again while the hub answered
1 mutations, 0 not a red-proof
== MUTATION: a record written ANEW since the claim counts as the claimed one
*** NOT A RED-PROOF *** (mutant rc=1 built=False real rc=0)
FAIL gitea.dooplex.hu/admin/felhom-controller/internal/backup [build failed]
internal/backup/offbox_ended.go:281:11: declared and not used: e
== MUTATION: the ids are not checked against the records as they are now
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_ATakeBackDuringTheWindowKeepsTheCopies (0.00s)
offbox_ended_race_test.go:48: the page said „the off-site copies are kept”, no record exists, and the window removed kimai's copy ([k1-full v1-full v2-full v3-full])
--- FAIL: TestD72_AnInstallDuringTheWindowKeepsTheCopies (0.00s)
offbox_ended_race_test.go:91: the window removed [k1-full] of an app that was installed again while the hub answered
== MUTATION: a take-back during the forget is answered „kept”
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_ATakeBackDuringTheForgetIsNotAnsweredKept (0.00s)
offbox_ended_race_test.go:119: asked=true kept=true — a take-back during the forget was answered „kept” while the copies were being removed
3 mutations, 1 not a red-proof
NOTE on the mutation that is "not a red-proof": it did not compile (`e` unused). It was NOT done again, because the
changed condition cannot be reached by a test: a record written anew is never due (its 30 days have just started), so
`dueOffsiteEnds` has already dropped it before the removed_at comparison. The comparison stays in the code as a second
line and is NOT claimed as proven. The case itself ("removed again: a NEW record with a new time") is in the RED block
above and is green after the fix.
@@ -0,0 +1,65 @@
FINDING 3 — an import installed the app and the off-site end record survived.
### RED: the new tests on the code as it was (controller 3928c3d), before the fix
=== RUN TestD72_AnImportDeletesTheEndRecord
d72_every_install_path_test.go:59: import: the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:27:55Z EndsAt:2026-11-16T13:27:55Z}) — the window would delete a living app's history
--- FAIL: TestD72_AnImportDeletesTheEndRecord (0.00s)
=== RUN TestD72_ARestoreIntoAnInstallDeletesTheEndRecord
d72_every_install_path_test.go:68: unit restore: the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:27:55Z EndsAt:2026-11-16T13:27:55Z}) — the window would delete a living app's history
--- FAIL: TestD72_ARestoreIntoAnInstallDeletesTheEndRecord (0.00s)
=== RUN TestD72_ADriveFlipRecordWriteDeletesTheEndRecord
d72_every_install_path_test.go:80: drive flip: the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:27:55Z EndsAt:2026-11-16T13:27:55Z}) — the window would delete a living app's history
--- FAIL: TestD72_ADriveFlipRecordWriteDeletesTheEndRecord (0.00s)
=== RUN TestD72_SaveAppConfigIsTheOnePoint
d72_every_install_path_test.go:96: SaveAppConfig(Deployed: true): the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:27:55Z EndsAt:2026-11-16T13:27:55Z}) — the window would delete a living app's history
--- FAIL: TestD72_SaveAppConfigIsTheOnePoint (0.00s)
=== RUN TestD72_TheInstallWritersAreListed
d72_every_install_path_test.go:155: a struct literal that says Deployed: true:
d72_every_install_path_test.go:164: SaveAppConfig does not call noteAppInstalled — no install path deletes the off-site end record
--- FAIL: TestD72_TheInstallWritersAreListed (0.52s)
FAIL
FAIL gitea.dooplex.hu/admin/felhom-controller/internal/stacks 0.573s
FAIL
### After the fix: mutations
== MUTATION: SaveAppConfig is not the install point (only DeployStack deletes the record)
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_AnImportDeletesTheEndRecord (0.00s)
d72_every_install_path_test.go:59: import: the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:29:15Z EndsAt:2026-11-16T13:29:15Z}) — the window would delete a living app's history
--- FAIL: TestD72_ARestoreIntoAnInstallDeletesTheEndRecord (0.00s)
d72_every_install_path_test.go:68: unit restore: the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:29:15Z EndsAt:2026-11-16T13:29:15Z}) — the window would delete a living app's hist
== MUTATION: a „not deployed” write deletes the record too
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_SaveAppConfigIsTheOnePoint (0.00s)
d72_every_install_path_test.go:91: a „not deployed” write deleted the end record
== MUTATION: one global hook: a write in another stacks directory reaches this box
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_SaveAppConfigIsTheOnePoint (0.00s)
d72_every_install_path_test.go:96: SaveAppConfig(Deployed: true): the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:29:27Z EndsAt:2026-11-16T13:29:27Z}) — the window would delete a
== MUTATION: living: an app being installed is not living
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_IsLivingApp (0.00s)
d72_every_install_path_test.go:201: being installed (Deploying): "gapp" does not read as living
== MUTATION: living: the protected list is not read
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_IsLivingApp (0.00s)
d72_every_install_path_test.go:201: a protected stack by the config, not in the list: "traefik" does not read as living
d72_every_install_path_test.go:201: always-protected samba: "samba" does not read as living
== MUTATION: living: an installed app the manager does not list is „removed”
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_IsLivingApp (0.00s)
d72_every_install_path_test.go:220: an INSTALLED app the manager does not list reads as removed — the window could end its copies
== MUTATION: living: everything is living (no end is ever carried out)
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_IsLivingApp (0.00s)
d72_every_install_path_test.go:181: a catalog app that is NOT installed reads as living — its end could never be carried out
7 mutations, 0 not a red-proof
== MUTATION: the manager does not register the install point
RED on the mutant, GREEN on the real file
--- FAIL: TestD72_AnImportDeletesTheEndRecord (0.00s)
d72_every_install_path_test.go:59: import: the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:29:56Z EndsAt:2026-11-16T13:29:56Z}) — the window would delete a living app's history
--- FAIL: TestD72_ARestoreIntoAnInstallDeletesTheEndRecord (0.00s)
d72_every_install_path_test.go:68: unit restore: the app is installed again and its off-site end record survives ({App:gapp RemovedAt:2026-10-17T13:29:56Z EndsAt:2026-11-16T13:29:56Z}) — the window would delete a living app's hist
1 mutations, 0 not a red-proof
+19
View File
@@ -1,5 +1,24 @@
## Unreleased (after v0.182.0)
- **Review fix 1 (2026-11-15): a box that lies about its app list can no longer have the whole store agreed in one
window with no signal.** The hub's 30-day check rests on what the box reports, so a box could name an app that
never existed (or stop listing a living one), wait 30 days, and get every snapshot agreed beside the cap. Now:
(a) **one window agrees to at most the size of its own cap**, taken from the hub's OWN count of the store
(`endedCap`, `boundEndedToCap`), oldest files first; the rest waits for the next window. *A narrowing of D84,
decided by CC unattended — the operator may reverse it (`07` §8.2f).* (b) **`offsite_end_claim_unseen`** (warning,
mailed, operator-only): the moment a box first names, in `offsite.ended_apps`, an app the hub never saw in its app
list — once per household and app, at most 8 per household (`store.NoteAppListClaims`, column `claim_born`).
(c) **`offsite_ended_large_agreement`** (warning, mailed, operator-only): a request for more than half of the store
**waits one week** — the window that first sees it agrees to nothing for removed apps; a window at least six days
later agrees. Neither event is in `allowedEventTypes`: a box cannot POST one. **Still open, said in `07`:** a box
that stops listing a living app is not told at the start, and under half of the store it can remove up to the cap's
size per week beside the cap without a mail. **Not done:** catching, at the close, a box that names agreed ids and
removed others — it needs the hub to list the repository inside the box-facing close (a new provider call there and
a second writer of the listing baseline); it is caught at 07:10, as before.
Tests `TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize`, `TestD84_TheRestGoesInTheNextWindow`,
`TestD84_TheAllowanceIsBoundByTheHubsOwnCount`, `TestD84_ALargeRequestForOtherAppsWaitsItsOwnWeek`,
`TestD84_ASmallEndIsQuiet`, `TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce` — seen red on the pushed code; 15
mutations seen red (`documentation/audits/build-release-4-2026-11-15/A/redproof-review-1.txt`).
- **The off-site copies of a removed app end after 30 days — the hub's half (R-1374 part 1; D72, D84; `09` §3
decisions 292 and 309; `07-backup-architecture.md` §8.2f). Built, NOT deployed; no box has run it.**
(1) **The hub's own app record.** `store.NoteAppList` (new table `offsite_app_presence`, fed by every controller
+100
View File
@@ -0,0 +1,100 @@
package api
import (
"fmt"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"gitea.dooplex.hu/admin/felhom-hub/internal/notify"
"gitea.dooplex.hu/admin/felhom-hub/internal/offsitekeys"
"gitea.dooplex.hu/admin/felhom-hub/internal/store"
)
// Review of 2026-11-15, finding 1(b): the moment a box FIRST names, in a pending end record, an app the hub never saw
// in its app list, the operator is warned — once per (household, app), 30 days before the hub could agree to
// anything. An app the hub saw installed and then saw leave is the ordinary case and raises nothing.
// RED-PROOF: documentation/audits/build-release-4-2026-11-15/A/redproof-review-1.txt.
func TestD84_AnAppTheHubNeverSawIsToldToTheOperatorOnce(t *testing.T) {
h, st, _ := newTestHandler(t)
st.SaveCustomerConfig(&store.CustomerConfig{CustomerID: "c1", APIKey: "ckey", RetrievalPassword: "pp"})
post := func(body string) {
t.Helper()
req := httptest.NewRequest(http.MethodPost, "/api/v1/report", strings.NewReader(body))
req.Header.Set("Authorization", "Bearer ckey")
rr := httptest.NewRecorder()
h.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("report → %d (%s)", rr.Code, rr.Body.String())
}
}
told := func() []store.Event {
t.Helper()
evs, err := st.GetEventsByType("c1", offsitekeys.EventEndedClaimUnseen, time.Now().Add(-time.Hour))
if err != nil {
t.Fatal(err)
}
return evs
}
post(`{"customer_id":"c1","stacks":{"deployed":["vikunja","immich"]}}`)
// vikunja is removed with „delete backup data”: the hub SAW it installed — the ordinary case, no warning.
post(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[{"app":"vikunja"}]}}`)
if e := told(); len(e) != 0 {
t.Fatalf("an app the hub saw installed raised the never-seen warning: %+v", e)
}
// „ghost” was never in the app list.
body := `{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[{"app":"vikunja"},{"app":"ghost","removed_at":"2024-01-01T00:00:00Z","ends_at":"2024-01-31T00:00:00Z"}]}}`
post(body)
e := told()
if len(e) != 1 {
t.Fatalf("want ONE warning for the app the hub never saw, got %d", len(e))
}
day := time.Now().UTC().Add(offsitekeys.EndedAppAfter).Format("2006-01-02")
if e[0].Severity != "warning" || !strings.Contains(e[0].Message, "c1") || !strings.Contains(e[0].Message, `"ghost"`) || !strings.Contains(e[0].Message, day) {
t.Fatalf("the warning must be a warning and name the household, the app and the day the hub would agree (%s): %+v", day, e[0])
}
if !strings.Contains(e[0].DetailsJSON, `"subject":"ghost"`) {
t.Fatalf("no per-app subject in the details: %s", e[0].DetailsJSON)
}
// the same record in every later report: told ONCE
for i := 0; i < 5; i++ {
post(body)
}
if e := told(); len(e) != 1 {
t.Fatalf("the warning was repeated: %d", len(e))
}
// a box that invents many names: the marks are capped per household
var many []string
for i := 0; i < 40; i++ {
many = append(many, fmt.Sprintf(`{"app":"inv-%d"}`, i))
}
post(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[` + strings.Join(many, ",") + `]}}`)
if n := len(told()); n > 8 {
t.Fatalf("40 invented names gave %d operator warnings — a box must not be able to flood the operator (limit 8 per household)", n)
}
// … and in the NEXT report 40 more new names: the limit is the household's, not one report's
many = many[:0]
for i := 0; i < 40; i++ {
many = append(many, fmt.Sprintf(`{"app":"more-%d"}`, i))
}
post(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[` + strings.Join(many, ",") + `]}}`)
if n := len(told()); n != 8 {
t.Fatalf("80 invented names over two reports gave %d operator warnings, want exactly the household's limit 8", n)
}
// a name that is not an app name is never told (and never stored)
post(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[{"app":"<b>x</b>"},{"app":"_shares"},{"app":"traefik"}]}}`)
for _, ev := range told() {
if strings.Contains(ev.Message, "<b>") || strings.Contains(ev.Message, "_shares") || strings.Contains(ev.Message, "traefik") {
t.Fatalf("an invalid or reserved name reached an operator message: %s", ev.Message)
}
}
// hub-made: no box can POST it, the household never gets it, and each app is its own mail
if allowedEventTypes[offsitekeys.EventEndedClaimUnseen] || allowedEventTypes[offsitekeys.EventEndedLargeAgreement] {
t.Fatal("a box must not be able to POST the hub's own warnings")
}
if !notify.IsOperatorOnly(offsitekeys.EventEndedClaimUnseen) {
t.Fatal("offsite_end_claim_unseen must be operator-only")
}
}
+24 -1
View File
@@ -27,6 +27,7 @@ import (
"gitea.dooplex.hu/admin/felhom-hub/internal/mailhold"
"gitea.dooplex.hu/admin/felhom-hub/internal/mailrelay"
"gitea.dooplex.hu/admin/felhom-hub/internal/notify"
"gitea.dooplex.hu/admin/felhom-hub/internal/offsitekeys"
"gitea.dooplex.hu/admin/felhom-hub/internal/store"
)
@@ -3699,7 +3700,29 @@ func (h *Handler) noteAppList(customerID string, body []byte) {
claimed = append(claimed, e.App)
}
}
if err := h.store.NoteAppList(customerID, p.Stacks.Deployed, claimed, time.Now()); err != nil {
unseen, err := h.store.NoteAppListClaims(customerID, p.Stacks.Deployed, claimed, time.Now())
if err != nil {
h.logger.Printf("[WARN] [api] report from %s: the hub's own app record could not be updated: %v", customerID, err)
return
}
// Review of 2026-11-15: an app the hub NEVER saw in this box's app list, named in an end record for the first
// time. It is the honest shape of „removed before the hub kept this record” — and the shape of a box that invents
// an app to have its copies agreed. The operator hears it now, 30 days before the hub could agree to anything.
// The store returns each app once and at most a few per household; the name has the shape of an app name.
for _, u := range unseen {
day := u.AbsentSince.Add(offsitekeys.EndedAppAfter).UTC().Format("2006-01-02")
msg := fmt.Sprintf("Off-site: the box of %s holds an end record for the app %q (its off-site copies are to be deleted 30 days after „delete backup data”), "+
"and the hub never saw that app in this box's app list. The hub's own 30 days start now: from %s it would agree, in a clean-up window, "+
"to remove that app's off-site snapshots — at most the window's cap per week. If the household did not remove an app of that name, "+
"look at the box before that day and switch the weekly windows off for it.", customerID, u.App, day)
details, _ := json.Marshal(map[string]any{"subject": u.App, "app": u.App, "agrees_from": day})
h.logger.Printf("[WARN] [api] report from %s: an end record names %q, an app the hub never saw installed — operator told; the hub would agree from %s", customerID, u.App, day)
if _, eerr := h.store.SaveEvent(customerID, offsitekeys.EventEndedClaimUnseen, "warning", msg, string(details), "hub"); eerr != nil {
h.logger.Printf("[WARN] [api] %s event save FAILED for %s: %v", offsitekeys.EventEndedClaimUnseen, customerID, eerr)
continue // the audit row first: a mail without its event row lies
}
if h.dispatcher != nil {
go h.dispatcher.ProcessEvent(customerID, offsitekeys.EventEndedClaimUnseen, "warning", msg, string(details), "hub")
}
}
}
+7
View File
@@ -642,6 +642,9 @@ var perSubjectCooldownEvents = map[string]bool{
"proxmox_trust_problem": true,
// D72/D84: one refusal per app (details `subject` = the app) — two apps refused in one window are two mails.
"offsite_ended_app_refused": true,
// one never-seen app is one mail (subject = the app); one window's large request is one mail (subject = the window)
"offsite_end_claim_unseen": true,
"offsite_ended_large_agreement": true,
}
// cooldownSubjectSuffix returns ":"+subject for an allow-listed type whose details carry a non-empty `subject`.
@@ -906,6 +909,10 @@ var operatorOnlyEvents = map[string]bool{
// an end the hub's own records do not show (warning). Hub-origin only: NOT in api.allowedEventTypes.
"offsite_ended_app_removed": true,
"offsite_ended_app_refused": true,
// Review of 2026-11-15: a box named an app the hub never saw installed (told once per household and app, 30 days
// before the hub could agree), and a window was asked for more than half of the store. Hub-origin only.
"offsite_end_claim_unseen": true,
"offsite_ended_large_agreement": true,
// OS updates (hub v0.130.0, `11` §8 step 2): run failures, rings, switches and approvals are operator facts.
// os_update_applied is deliberately NOT here — it is the household's one line (info: recorded, never mailed).
"os_update_failed": true,
+104 -1
View File
@@ -3,6 +3,7 @@ package offsitekeys
import (
"fmt"
"sort"
"strings"
"time"
"gitea.dooplex.hu/admin/felhom-hub/internal/store"
@@ -33,6 +34,14 @@ const EndedAppAfter = 30 * 24 * time.Hour
const (
EventEndedAppRemoved = "offsite_ended_app_removed" // info: the off-site copies of a removed app are gone (per app)
EventEndedAppRefused = "offsite_ended_app_refused" // warning: a box claimed an end the hub's records do not show
// Review of 2026-11-15 — two more operator warnings, both mailed, both hub-made (no box can POST one):
EventEndedClaimUnseen = "offsite_end_claim_unseen" // a box first names an app the hub never saw installed
EventEndedLargeAgreement = "offsite_ended_large_agreement" // one window was asked for more than half of the store
// A request for more than half of the store waits largeEndedWait after the window that first saw it; that first
// sight is remembered for largeEndedMemory (a new large request after that waits again).
largeEndedWait = 6 * 24 * time.Hour
largeEndedMemory = 30 * 24 * time.Hour
maxEndedClaims = 50 // apps in one request
maxEndedClaimIDs = 5000 // snapshot ids in one request, all apps together
@@ -190,7 +199,7 @@ func clearDisagreement(now time.Time, presence map[string]store.AppPresence, r s
// agreeEndedFor runs the decision for one household against the store, and tells the operator about a clear
// disagreement. It never fails a window: with a store that cannot answer, nothing is agreed.
func (s *Service) agreeEndedFor(customerID string, claims []EndedClaim) (ids []string, byApp map[string][]string, refused []store.EndedRefusal) {
func (s *Service) agreeEndedFor(customerID string, windowID int64, maxRemove int, claims []EndedClaim) (ids []string, byApp map[string][]string, refused []store.EndedRefusal) {
if len(claims) == 0 {
return nil, nil, nil
}
@@ -205,6 +214,40 @@ func (s *Service) agreeEndedFor(customerID string, claims []EndedClaim) (ids []s
}
listing, have := s.Store.GetOffsiteSnapshotListing(customerID)
ids, byApp, refused = agreeEnded(now, presence, listing, have, claims)
// Review of 2026-11-15 — what bounds a box that invents an ended app, or stops listing a living one, and 30 days
// later names much of the store under it:
//
// (c) A request for more than HALF of the store's snapshots WAITS ONE WEEK: the first window that sees it agrees
// to nothing for removed apps and tells the operator (a mail); a window at least largeEndedWait later agrees.
// So the operator always has a week between the mail and the first removal. An honest household that
// removed its one big app looks the same and loses one week.
// (a) ONE window agrees to at most the cap's own size (boundEndedToCap); the rest waits for the next window.
if total := len(listing.Entries); have && len(ids)*2 > total {
// The week belongs to THESE apps: a large request for other apps waits its own week and gets its own mail.
mark := store.LargeEndedRefusalMark + " (apps: " + appNames(byApp) + ")"
first := s.Store.FirstLargeEndedRefusal(customerID, mark, now.Add(-largeEndedMemory))
if first.IsZero() || now.Sub(first) < largeEndedWait {
if first.IsZero() {
s.event(customerID, EventEndedLargeAgreement, "warning",
fmt.Sprintf("Off-site clean-up window %d: the box of %s asked to remove %d of %d off-site snapshot(s) as copies of removed apps (%s) — more than half of the store. "+
"NOTHING of them is removed in this window. The hub's own records agree to each app, so from %s a window removes them, at most %d per window. "+
"If the household did not remove these apps, switch the weekly windows off for it before that day and look at the box.",
windowID, customerID, len(ids), total, appNames(byApp), now.Add(largeEndedWait).UTC().Format("2006-01-02"), endedCap(maxRemove, total)),
map[string]any{"subject": "large:" + appNames(byApp), "window_id": windowID, "asked": len(ids), "listed": total})
}
refused = append(refused, store.EndedRefusal{Reason: fmt.Sprintf("the request is for %d of %d snapshots — %s: it waits one week, and the operator is told",
len(ids), total, mark)})
ids, byApp = nil, nil
}
}
if have && len(ids) > 0 {
var waits int
ids, byApp, waits = boundEndedToCap(ids, byApp, listing, endedCap(maxRemove, len(listing.Entries)))
if waits > 0 {
refused = append(refused, store.EndedRefusal{Reason: fmt.Sprintf("%d snapshot id(s) wait for the next window: one window removes at most %d snapshots of removed apps (the size of its own cap)",
waits, endedCap(maxRemove, len(listing.Entries)))})
}
}
s.logf("[INFO] offsitekeys: ended apps %s: %d app(s) claimed, %d app(s) with agreed snapshots, %d snapshot id(s) agreed, %d refusal(s)",
customerID, len(claims), len(byApp), len(ids), len(refused))
for _, r := range refused {
@@ -235,3 +278,63 @@ func endedRemovedByApp(claims map[string][]string, removed []string) map[string]
}
return out
}
// endedCap is the most ended-app snapshots ONE window may agree to: the size of the window's own cap, and never more
// than the cap the hub's OWN count of the store would give (the window's cap comes from the box's count_before, which
// is the box's word). Decided by CC unattended on 2026-11-15, a narrowing of D84 — the operator may reverse it
// (`07-backup-architecture.md` §8.2f).
func endedCap(maxRemove, listed int) int {
c := MaxRemove(listed)
if maxRemove > 0 && maxRemove < c {
c = maxRemove
}
return c
}
// boundEndedToCap keeps at most limit of the agreed ids — the OLDEST uploads first (the newest copies of a removed
// app are the last to go) — and returns how many wait.
func boundEndedToCap(ids []string, byApp map[string][]string, listing store.OffsiteSnapshotListing, limit int) ([]string, map[string][]string, int) {
if len(ids) <= limit {
return ids, byApp, 0
}
sorted := append([]string(nil), ids...)
sort.Slice(sorted, func(i, j int) bool {
ti, tj := listing.Entries[sorted[i]], listing.Entries[sorted[j]]
if !ti.Equal(tj) {
return ti.Before(tj)
}
return sorted[i] < sorted[j]
})
keep := make(map[string]bool, limit)
for _, id := range sorted[:limit] {
keep[id] = true
}
var out []string
for _, id := range ids {
if keep[id] {
out = append(out, id)
}
}
apps := map[string][]string{}
for app, list := range byApp {
for _, id := range list {
if keep[id] {
apps[app] = append(apps[app], id)
}
}
}
return out, apps, len(ids) - limit
}
// appNames lists the agreed apps for a message (names already checked: store.ValidPresenceApp).
func appNames(byApp map[string][]string) string {
names := make([]string, 0, len(byApp))
for app := range byApp {
names = append(names, app)
}
sort.Strings(names)
if len(names) > 10 {
return strings.Join(names[:10], ", ") + fmt.Sprintf(" and %d more", len(names)-10)
}
return strings.Join(names, ", ")
}
@@ -0,0 +1,225 @@
package offsitekeys
import (
"context"
"strings"
"testing"
"time"
"gitea.dooplex.hu/admin/felhom-hub/internal/notify"
"gitea.dooplex.hu/admin/felhom-hub/internal/store"
)
// Review of 2026-11-15, finding 1: a box could invent an ended app (or stop listing a living one), wait 30 days, and
// have the hub agree to snapshots of the WHOLE store beyond the cap, with no operator signal. Three things now hold:
// the ended allowance of ONE window is at most the cap's own size (the rest waits for the next window); the operator
// is warned when a window is asked for more than half of the store; and (api, store) the operator is warned the
// moment a box first names an app the hub never saw installed — 30 days before anything can go.
// RED-PROOF: documentation/audits/build-release-4-2026-11-15/A/redproof-review-1.txt.
// ghostFixture: 20 snapshot files (40 days old) and a box that has only ever NAMED „ghost” in an end record, 31 days
// ago; immich is installed all along.
func ghostFixture(t *testing.T) (*Service, *[]evt, []string) {
t.Helper()
s, _, events := watchFixture(t)
now := time.Now().UTC()
l := store.OffsiteSnapshotListing{ListedAt: now.Add(-20 * time.Hour), Entries: map[string]time.Time{}}
var all []string
for i := 0; i < 20; i++ {
l.Entries[eid(i)] = now.Add(-time.Duration(40*24+i) * time.Hour) // eid(19) is the oldest
all = append(all, eid(i))
}
if err := s.Store.SetOffsiteSnapshotListing("c1", l); err != nil {
t.Fatal(err)
}
if err := s.Store.NoteAppList("c1", []string{"immich"}, []string{"ghost"}, now.Add(-31*24*time.Hour)); err != nil {
t.Fatal(err)
}
if err := s.Store.NoteAppList("c1", []string{"immich"}, []string{"ghost"}, now.Add(-time.Hour)); err != nil {
t.Fatal(err)
}
*events = nil
return s, events, all
}
// aWeekLater moves every window of the household eight days into the past (the ledger is stamped by SQLite's clock).
func aWeekLater(t *testing.T, s *Service, ids ...int64) {
t.Helper()
for _, id := range ids {
if err := s.Store.BackdateOffsiteWindowForTest(id, 8*24*time.Hour); err != nil {
t.Fatal(err)
}
}
}
func hasReason(refused []store.EndedRefusal, frag string) bool {
for _, r := range refused {
if strings.Contains(r.Reason, frag) {
return true
}
}
return false
}
// THE WORST CASE: the box names EVERY snapshot under the ghost. The first window agrees to NOTHING and the operator
// is mailed; if the box removes the store anyway, the drop alarm and the 07:10 audit both fire. A week later a window
// agrees — to at most the cap's own size, the oldest files first — and says that the rest waits.
func TestD84_ALargeRequestWaitsAWeekAndOneWindowAgreesAtMostTheCapsSize(t *testing.T) {
s, events, all := ghostFixture(t)
g := openGranted(t, s, 20, EndedClaim{App: "ghost", SnapshotIDs: all})
if g.MaxRemove != MaxRemove(20) {
t.Fatalf("the cap's own rule moved: %d, want %d", g.MaxRemove, MaxRemove(20))
}
if len(g.EndedAllowed) != 0 {
t.Fatalf("the window that first saw a request for the whole store agreed to %d ids — it must agree to none and tell the operator first", len(g.EndedAllowed))
}
if !hasReason(g.EndedRefused, "waits one week") {
t.Fatalf("the window does not say that the request waits: %+v", g.EndedRefused)
}
big := ofType(*events, EventEndedLargeAgreement)
if len(big) != 1 || big[0].sev != "warning" || !strings.Contains(big[0].msg, "c1") || !strings.Contains(big[0].msg, "20 of 20") || !strings.Contains(big[0].msg, "ghost") {
t.Fatalf("want ONE operator warning naming the household, the app and „20 of 20”: %+v", *events)
}
// the box removes the WHOLE store anyway and names all 20: nothing was agreed, so both alarms fire
*events = nil
if err := s.CloseWindowFor(context.Background(), "c1", WindowResult{WindowID: g.WindowID, CountBefore: 20, CountAfter: 0, Removed: 20, Outcome: "pruned", RemovedForEndedApps: all}); err != nil {
t.Fatal(err)
}
if len(ofType(*events, EventWindowDrop)) != 1 {
t.Fatalf("no drop alarm for a store emptied with nothing agreed: %+v", *events)
}
if v, _ := s.CheckSnapshotListing("c1", SnapshotListing{Entries: map[string]time.Time{}}, time.Now().UTC().Add(time.Minute)); v == 0 {
t.Fatal("the audit explained a store emptied beyond what the hub agreed to")
}
// A second household state, where the box waits: two days later still nothing; a week later the cap's size.
s2, events2, all2 := ghostFixture(t)
g1 := openGranted(t, s2, 20, EndedClaim{App: "ghost", SnapshotIDs: all2})
_ = s2.CloseWindowFor(context.Background(), "c1", WindowResult{WindowID: g1.WindowID, CountBefore: 20, CountAfter: 20, Outcome: "nothing"})
if err := s2.Store.BackdateOffsiteWindowForTest(g1.WindowID, 2*24*time.Hour); err != nil {
t.Fatal(err)
}
gEarly := openGranted(t, s2, 20, EndedClaim{App: "ghost", SnapshotIDs: all2})
_ = s2.CloseWindowFor(context.Background(), "c1", WindowResult{WindowID: gEarly.WindowID, CountBefore: 20, CountAfter: 20, Outcome: "nothing"})
if len(gEarly.EndedAllowed) != 0 {
t.Fatalf("two days after the warning a window agreed to %d ids — the operator must have a week", len(gEarly.EndedAllowed))
}
aWeekLater(t, s2, g1.WindowID, gEarly.WindowID)
g2 := openGranted(t, s2, 20, EndedClaim{App: "ghost", SnapshotIDs: all2})
if len(g2.EndedAllowed) != g2.MaxRemove || g2.MaxRemove != 10 {
t.Fatalf("a week later: %d ended ids agreed with a cap of %d — want exactly the cap's size", len(g2.EndedAllowed), g2.MaxRemove)
}
for _, id := range g2.EndedAllowed { // the OLDEST go first: eid(10)..eid(19)
ok := false
for i := 10; i < 20; i++ {
ok = ok || id == eid(i)
}
if !ok {
t.Fatalf("the allowance did not take the oldest files first: %s agreed", shortID(id))
}
}
if !hasReason(g2.EndedRefused, "wait for the next window") {
t.Fatalf("the window does not say that the rest waits: %+v", g2.EndedRefused)
}
if n := len(ofType(*events2, EventEndedLargeAgreement)); n != 1 {
t.Fatalf("the operator was told %d time(s) about one large request, want once", n)
}
if w, _ := s2.Store.GetOffsiteWindow(g2.WindowID); len(w.EndedAgreed) != 10 {
t.Fatalf("the window's row holds %d agreed ids", len(w.EndedAgreed))
}
}
// The week belongs to the apps that were told: a large request for ANOTHER app, a week after the first one's warning,
// waits its own week and gets its own mail.
func TestD84_ALargeRequestForOtherAppsWaitsItsOwnWeek(t *testing.T) {
s, events, all := ghostFixture(t)
now := time.Now().UTC()
_ = s.Store.NoteAppList("c1", []string{"immich"}, []string{"ghost", "second"}, now.Add(-31*24*time.Hour-time.Minute))
g0 := openGranted(t, s, 20, EndedClaim{App: "ghost", SnapshotIDs: all})
_ = s.CloseWindowFor(context.Background(), "c1", WindowResult{WindowID: g0.WindowID, CountBefore: 20, CountAfter: 20, Outcome: "nothing"})
aWeekLater(t, s, g0.WindowID)
g1 := openGranted(t, s, 20, EndedClaim{App: "second", SnapshotIDs: all})
if len(g1.EndedAllowed) != 0 || !hasReason(g1.EndedRefused, "waits one week") {
t.Fatalf("a large request for another app rode the first app's week: agreed %d, refused %+v", len(g1.EndedAllowed), g1.EndedRefused)
}
if n := len(ofType(*events, EventEndedLargeAgreement)); n != 2 {
t.Fatalf("two large requests for different apps gave %d operator warning(s), want 2", n)
}
}
// AN HONEST LARGE END IS NOT LOST: it waits a week, then goes — the cap's size per window, the rest in the next one.
func TestD84_TheRestGoesInTheNextWindow(t *testing.T) {
s, _, all := ghostFixture(t)
ctx := context.Background()
big := all[5:] // 15 ids of a big removed app
g0 := openGranted(t, s, 20, EndedClaim{App: "ghost", SnapshotIDs: big})
if len(g0.EndedAllowed) != 0 {
t.Fatalf("the first window agreed to %d", len(g0.EndedAllowed))
}
_ = s.CloseWindowFor(ctx, "c1", WindowResult{WindowID: g0.WindowID, CountBefore: 20, CountAfter: 20, Outcome: "nothing"})
aWeekLater(t, s, g0.WindowID)
g1 := openGranted(t, s, 20, EndedClaim{App: "ghost", SnapshotIDs: big})
if len(g1.EndedAllowed) != 10 {
t.Fatalf("a week later: %d agreed, want the cap's size 10", len(g1.EndedAllowed))
}
if err := s.CloseWindowFor(ctx, "c1", WindowResult{WindowID: g1.WindowID, CountBefore: 20, CountAfter: 10, Removed: 10, Outcome: "pruned", RemovedForEndedApps: g1.EndedAllowed}); err != nil {
t.Fatal(err)
}
gone := map[string]bool{}
for _, id := range g1.EndedAllowed {
gone[id] = true
}
var rest []string
for _, id := range big {
if !gone[id] {
rest = append(rest, id)
}
}
// the next day's audit: the hub's own listing now holds the 10 that are left, and raises nothing
left := SnapshotListing{Entries: map[string]time.Time{}}
for _, id := range all {
if !gone[id] {
left.Entries[id] = time.Now().UTC().Add(-40 * 24 * time.Hour)
}
}
if v, _ := s.CheckSnapshotListing("c1", left, time.Now().UTC().Add(time.Minute)); v != 0 {
t.Fatalf("the agreed removals were judged as vanished (%d)", v)
}
g2 := openGranted(t, s, 10, EndedClaim{App: "ghost", SnapshotIDs: rest})
if len(rest) != 5 || strings.Join(g2.EndedAllowed, ",") != strings.Join(rest, ",") {
t.Fatalf("the next window: agreed %v, want the 5 that waited %v (refused: %+v)", shortIDs(g2.EndedAllowed), shortIDs(rest), g2.EndedRefused)
}
}
// The bound uses the hub's OWN count of the store, not only the box's word: a box that says „1000 snapshots” gets a
// large cap for its policy, and still no larger ended allowance than half of what the hub's listing holds.
func TestD84_TheAllowanceIsBoundByTheHubsOwnCount(t *testing.T) {
s, _, all := ghostFixture(t)
g0 := openGranted(t, s, 1000, EndedClaim{App: "ghost", SnapshotIDs: all})
_ = s.CloseWindowFor(context.Background(), "c1", WindowResult{WindowID: g0.WindowID, CountBefore: 1000, CountAfter: 1000, Outcome: "nothing"})
aWeekLater(t, s, g0.WindowID)
g := openGranted(t, s, 1000, EndedClaim{App: "ghost", SnapshotIDs: all})
if g.MaxRemove != MaxRemove(1000) {
t.Fatalf("cap = %d", g.MaxRemove)
}
if len(g.EndedAllowed) != MaxRemove(20) {
t.Fatalf("a box that claims 1000 snapshots got %d ended ids agreed; the hub's own listing holds 20 → at most %d", len(g.EndedAllowed), MaxRemove(20))
}
}
// A normal end (3 of 20) raises no warning and waits for nothing.
func TestD84_ASmallEndIsQuiet(t *testing.T) {
s, events, all := ghostFixture(t)
g := openGranted(t, s, 20, EndedClaim{App: "ghost", SnapshotIDs: all[:3]})
if len(g.EndedAllowed) != 3 || len(g.EndedRefused) != 0 {
t.Fatalf("agreed=%d refused=%+v", len(g.EndedAllowed), g.EndedRefused)
}
if e := ofType(*events, EventEndedLargeAgreement); len(e) != 0 {
t.Fatalf("a small end raised the large-agreement warning: %+v", e)
}
for _, typ := range []string{EventEndedLargeAgreement, EventEndedClaimUnseen} {
if !notify.IsOperatorOnly(typ) {
t.Fatalf("%s must be operator-only", typ)
}
}
}
+1 -1
View File
@@ -378,7 +378,7 @@ func (s *Service) OpenWindowFor(ctx context.Context, customerID string, countBef
g := WindowGrant{Granted: true, WindowID: id, NewestAllowed: now.UTC(), MaxRemove: maxRemove}
// D84: the ended apps. Decided AFTER the window exists and only for a granted window, so a refused or not-due
// window agrees to nothing; a ledger write that fails agrees to nothing either (the box then removes none).
if agreed, byApp, refused := s.agreeEndedFor(customerID, ended); len(agreed) > 0 || len(refused) > 0 {
if agreed, byApp, refused := s.agreeEndedFor(customerID, id, maxRemove, ended); len(agreed) > 0 || len(refused) > 0 {
if werr := s.Store.SetOffsiteWindowEnded(id, agreed, byApp, refused); werr != nil {
s.logf("[WARN] offsitekeys: window %d: the ended apps' agreement could not be recorded (%v) — nothing agreed", id, werr)
g.EndedRefused = []store.EndedRefusal{{Reason: "the hub could not record its agreement"}}
+91 -15
View File
@@ -36,6 +36,8 @@ func (s *Store) migrateOffsiteEnded() error {
s.db.Exec("ALTER TABLE offsite_windows ADD COLUMN ended_agreed TEXT")
s.db.Exec("ALTER TABLE offsite_windows ADD COLUMN ended_refused TEXT")
s.db.Exec("ALTER TABLE offsite_windows ADD COLUMN ended_removed TEXT")
// 1 on a row that exists ONLY because the box named the app in an end record (the hub never saw it installed).
s.db.Exec("ALTER TABLE offsite_app_presence ADD COLUMN claim_born INTEGER NOT NULL DEFAULT 0")
s.db.Exec("ALTER TABLE offsite_windows ADD COLUMN ended_apps TEXT") // agreed app → its agreed ids (the per-app record)
return nil
}
@@ -46,6 +48,9 @@ type AppPresence struct {
Present bool
// AbsentSince is the hub's time of the first report without the app (zero while Present).
AbsentSince time.Time
// ClaimBorn: the hub never saw this app in the box's app list — the row exists only because the box named the
// app in a pending end record. The operator was warned when it appeared (NoteAppListClaims).
ClaimBorn bool
}
// A box's lists are the box's own word, so the record is bounded three ways (security review of 2026-11-15):
@@ -68,8 +73,18 @@ const (
maxPresenceApps = 300
maxPresenceRows = 400
maxPresenceName = 64
// maxUnseenClaimsTold: how many never-seen apps of ONE household the operator is warned about (one mail each).
// A box that invents more names is already eight warnings loud; the rest are stored and not mailed.
maxUnseenClaimsTold = 8
)
// UnseenClaim is an app a box named in a pending end record that the hub never saw in the box's app list — told to
// the operator once, at the moment the row is made.
type UnseenClaim struct {
App string
AbsentSince time.Time // the hub's clock starts here; it could agree EndedAppAfter later
}
// ValidPresenceApp: the shape of an app (stack) name — 1..64 of letters, digits, `.`, `_`, `-`, starting with a
// letter or a digit. Anything else a box sends is not stored and can never be agreed.
func ValidPresenceApp(app string) bool {
@@ -109,8 +124,16 @@ func ReservedPresenceApp(app string) bool { return reservedPresenceApps[strings.
//
// It writes only when something changes, so a steady box costs one read per report.
func (s *Store) NoteAppList(customerID string, deployed, claimed []string, now time.Time) error {
_, err := s.NoteAppListClaims(customerID, deployed, claimed, now)
return err
}
// NoteAppListClaims is NoteAppList, and returns the never-seen apps this report named for the FIRST time (review of
// 2026-11-15): the caller warns the operator about each, 30 days before the hub could agree to anything for it. An
// app is returned once — when its row is made — and at most maxUnseenClaimsTold such rows per household are told.
func (s *Store) NoteAppListClaims(customerID string, deployed, claimed []string, now time.Time) (unseen []UnseenClaim, err error) {
if customerID == "" {
return fmt.Errorf("NoteAppList: empty customer_id")
return nil, fmt.Errorf("NoteAppList: empty customer_id")
}
if len(deployed) > maxPresenceApps {
deployed = deployed[:maxPresenceApps]
@@ -120,7 +143,7 @@ func (s *Store) NoteAppList(customerID string, deployed, claimed []string, now t
}
cur, err := s.AppPresences(customerID)
if err != nil {
return err
return nil, err
}
stamp := now.UTC().Format(time.RFC3339)
in := make(map[string]bool, len(deployed))
@@ -129,8 +152,9 @@ func (s *Store) NoteAppList(customerID string, deployed, claimed []string, now t
isClaimed[app] = true
}
type change struct {
app string
absent sql.NullString
app string
absent sql.NullString
claimBorn bool
}
var changes, added []change // changes touch a row that exists; added need a NEW row (rule 3)
for _, app := range deployed {
@@ -156,7 +180,7 @@ func (s *Store) NoteAppList(customerID string, deployed, claimed []string, now t
}
seen[app] = true
if _, ok := cur[app]; !ok {
added = append(added, change{app: app, absent: sql.NullString{String: stamp, Valid: true}})
added = append(added, change{app: app, absent: sql.NullString{String: stamp, Valid: true}, claimBorn: true})
}
}
// Rule 3: the household's row limit. Room is made only from absent rows this report does not claim, oldest first.
@@ -188,27 +212,54 @@ func (s *Store) NoteAppList(customerID string, deployed, claimed []string, now t
}
}
s.notePresenceFull(customerID, refusedNew, len(evict))
// The never-seen apps to tell: the rows made now for a claim, while the household holds fewer than the limit.
bornBefore := 0
evicted := make(map[string]bool, len(evict))
for _, app := range evict {
evicted[app] = true
}
for app, p := range cur {
if p.ClaimBorn && !evicted[app] {
bornBefore++
}
}
for _, c := range added {
if c.claimBorn && bornBefore+len(unseen) < maxUnseenClaimsTold {
unseen = append(unseen, UnseenClaim{App: c.app, AbsentSince: now.UTC()})
}
}
changes = append(changes, added...)
if len(changes) == 0 && len(evict) == 0 {
return nil
return nil, nil
}
tx, err := s.db.Begin()
if err != nil {
return err
return nil, err
}
defer tx.Rollback()
for _, app := range evict {
if _, err := tx.Exec(`DELETE FROM offsite_app_presence WHERE customer_id = ? AND app = ?`, customerID, app); err != nil {
return fmt.Errorf("NoteAppList %s/%s: %w", customerID, app, err)
return nil, fmt.Errorf("NoteAppList %s/%s: %w", customerID, app, err)
}
}
for _, c := range changes {
if _, err := tx.Exec(`INSERT INTO offsite_app_presence (customer_id, app, absent_since) VALUES (?, ?, ?)
ON CONFLICT(customer_id, app) DO UPDATE SET absent_since = excluded.absent_since`, customerID, c.app, c.absent); err != nil {
return fmt.Errorf("NoteAppList %s/%s: %w", customerID, c.app, err)
// claim_born is set only on a row made for a claim, and cleared the moment a report lists the app: an app
// the hub has seen installed is an ordinary app from then on.
born := 0
if c.claimBorn {
born = 1
} else if p, ok := cur[c.app]; ok && p.ClaimBorn && c.absent.Valid {
born = 1
}
if _, err := tx.Exec(`INSERT INTO offsite_app_presence (customer_id, app, absent_since, claim_born) VALUES (?, ?, ?, ?)
ON CONFLICT(customer_id, app) DO UPDATE SET absent_since = excluded.absent_since, claim_born = excluded.claim_born`, customerID, c.app, c.absent, born); err != nil {
return nil, fmt.Errorf("NoteAppList %s/%s: %w", customerID, c.app, err)
}
}
return tx.Commit()
if err := tx.Commit(); err != nil {
return nil, err
}
return unseen, nil
}
// presenceFull remembers, per household, that the row limit was said in the log — so a box that sends new names in
@@ -237,7 +288,7 @@ func (s *Store) notePresenceFull(customerID string, refusedNew, evicted int) {
// AppPresences returns the hub's record for one household, by app.
func (s *Store) AppPresences(customerID string) (map[string]AppPresence, error) {
rows, err := s.db.Query(`SELECT app, absent_since FROM offsite_app_presence WHERE customer_id = ?`, customerID)
rows, err := s.db.Query(`SELECT app, absent_since, claim_born FROM offsite_app_presence WHERE customer_id = ?`, customerID)
if err != nil {
return nil, err
}
@@ -246,10 +297,11 @@ func (s *Store) AppPresences(customerID string) (map[string]AppPresence, error)
for rows.Next() {
var app string
var absent sql.NullString
if err := rows.Scan(&app, &absent); err != nil {
var born sql.NullInt64
if err := rows.Scan(&app, &absent, &born); err != nil {
return nil, err
}
p := AppPresence{Present: !absent.Valid || absent.String == ""}
p := AppPresence{Present: !absent.Valid || absent.String == "", ClaimBorn: born.Int64 == 1}
if !p.Present {
// A date that cannot be read stays the zero time, and the caller REFUSES an absent app with a zero
// AbsentSince: an unreadable date is never "absent long ago".
@@ -329,3 +381,27 @@ func jsonStrings(v sql.NullString) []string {
}
return out
}
// LargeEndedRefusalMark is the text a window's refusal carries when the request was for more than half of the store
// (offsitekeys). FirstLargeEndedRefusal finds it on the window rows — the ledger is the memory, so it goes with the
// household and needs no second store.
const LargeEndedRefusalMark = "more than half of the store"
// FirstLargeEndedRefusal returns when the household's EARLIEST window since `since` refused a request for more than
// half of the store FOR THE SAME APPS (`needle` is the refusal's own text for them; zero time: none). A store that
// cannot answer reads as none — and then the request waits again.
func (s *Store) FirstLargeEndedRefusal(customerID, needle string, since time.Time) time.Time {
var v sql.NullString
err := s.db.QueryRow(`SELECT MIN(opened_at) FROM offsite_windows WHERE customer_id = ? AND opened_at >= ? AND instr(COALESCE(ended_refused, ''), ?) > 0`,
customerID, since.UTC().Format("2006-01-02 15:04:05"), needle).Scan(&v)
if err != nil || !v.Valid || v.String == "" {
return time.Time{}
}
return parseSQLiteTime(v.String)
}
// BackdateOffsiteWindowForTest moves a window's opened_at into the past. TEST-ONLY.
func (s *Store) BackdateOffsiteWindowForTest(id int64, by time.Duration) error {
_, err := s.db.Exec(`UPDATE offsite_windows SET opened_at = ? WHERE id = ?`, time.Now().UTC().Add(-by).Format("2006-01-02 15:04:05"), id)
return err
}