From 42ef25c23bf7cd422e127b26b798b06aa42200af Mon Sep 17 00:00:00 2001 From: kisfenyo Date: Sun, 15 Nov 2026 16:17:44 +0100 Subject: [PATCH] =?UTF-8?q?hub=20(unreleased):=20the=20notice=20lock=20?= =?UTF-8?q?=E2=80=94=20no=20notice,=20no=20deletion;=20the=20hub=20sends?= =?UTF-8?q?=20the=20household's=20notice=20itself=20(decision=20315,=20R-1?= =?UTF-8?q?374)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The hub agrees to remove a removed app's off-site copies only when its OWN record (offsite_end_notices) says the household was told at least 30 days ago, by the hub's clock — beside the 30 days of absence. The notice is sent from the box's report, at every report until the mail service accepts it; the box's event mails nobody. No address or a blocked household: the operator is mailed in its place and that mail starts the 30 days. A notice that cannot go out: no agreement, the window's answer names the reason, one line to the operator after 3 days. This commit also supplies the files that handler.go (c3fa43a4) already calls (store.NoteEndNotices, api.kickEndNotices) and the tests that replace TestD84_Receipt_* (their files left the tree in b8cf6c24). Claude-Session: https://claude.ai/code/session_0159rPz1ZhFKsS53msqPYxtS --- REUSE.md | 6 +- .../A/redproof-notice-agree.txt | 40 ++ .../A/redproof-notice-hub.txt | 54 ++ .../A/redproof-notice-mail.txt | 45 ++ .../A/redproof-notice-store.txt | 47 ++ hub/CHANGELOG.md | 20 + hub/internal/api/end_notice.go | 196 +++++++ hub/internal/api/end_notice_test.go | 509 ++++++++++++++++++ hub/internal/notify/dispatcher.go | 178 +----- hub/internal/notify/end_notice.go | 162 ++++++ hub/internal/notify/end_notice_test.go | 262 +++++++++ hub/internal/notify/mail_golden_test.go | 10 +- hub/internal/notify/templates.go | 2 +- ...er_shape_offsite_end_scheduled_receipt.txt | 2 +- ...er_shape_offsite_end_scheduled_receipt.txt | 2 +- hub/internal/offsitekeys/ended.go | 57 +- hub/internal/offsitekeys/ended_bound_test.go | 2 + .../offsitekeys/ended_large_marker_test.go | 1 + hub/internal/offsitekeys/ended_test.go | 21 +- hub/internal/offsitekeys/notice_lock_test.go | 149 +++++ hub/internal/store/customer_delete.go | 5 +- hub/internal/store/offsite_end_notice.go | 300 +++++++++++ hub/internal/store/offsite_end_notice_test.go | 186 +++++++ hub/internal/store/orphan_rows.go | 1 + hub/internal/store/store.go | 4 + 25 files changed, 2077 insertions(+), 184 deletions(-) create mode 100644 documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-agree.txt create mode 100644 documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-hub.txt create mode 100644 documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-mail.txt create mode 100644 documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-store.txt create mode 100644 hub/internal/api/end_notice.go create mode 100644 hub/internal/api/end_notice_test.go create mode 100644 hub/internal/notify/end_notice.go create mode 100644 hub/internal/notify/end_notice_test.go create mode 100644 hub/internal/offsitekeys/notice_lock_test.go create mode 100644 hub/internal/store/offsite_end_notice.go create mode 100644 hub/internal/store/offsite_end_notice_test.go diff --git a/REUSE.md b/REUSE.md index ad20a0c9..239c4ff9 100644 --- a/REUSE.md +++ b/REUSE.md @@ -77,8 +77,10 @@ | `offsitekeys.Registrar` (`Install` / `Confirm` / `Audit` / `OpenWindow` / `CloseWindow` / `MoveAside`) | hub/internal/offsitekeys/offsitekeys.go | `(ctx, Target, password, …)` | EVERY write to a sub-account's `.ssh/authorized_keys` and every repo move-aside | **The only writer of that file, and the only deleter on a sub-account (`DeleteSetAside`: `.orphaned-*` only, decision 74).** `read()` is read-only (R-827). Uses the provider's port-23 restricted shell (`dd of=` takes stdin, `mv` overwrites, `test` does NOT exist — measured); an unpinned line is a deletion route and is dropped on every install; the window line goes FIRST (first match wins). Never `rm`. | | `offsitekeys.Service` (`RegisterKey`, `ConfirmKey`, `AuditAll`, `OpenWindowFor`, `CloseWindowFor`, `SweepExpiredWindows`) | hub/internal/offsitekeys/service.go | — | Binding the registrar to the store, descriptor and operator events | The box-facing API (`/api/v1/offsite/register-key…`) answers with NO credential — pinned by `TestOffsiteKeyEndpoints_AuthAndNoPasswordInAnyResponse`. | | `offsitekeys` snapshot watch + `store.Get/SetOffsiteSnapshotListing` / `OffsiteRunTimesSince` (v0.158.0, R-895 slice 2) | hub/internal/offsitekeys/snapshot_watch.go, hub/internal/store/offsite_snapshots.go | — | Judging the 07:10 `snapshots/` listing against yesterday's (baseline in `hub_settings`) and the box's reported runs | Raises `offsite_snapshots_vanished` / `_unexplained` — operator-only and hub-origin (NOT in `allowedEventTypes`). The first listing is a baseline; a move-aside or RESET drops it. | -| `store.NoteAppList` / `AppPresences` + `offsitekeys.agreeEnded` (D72/D84, `07` §8.2f) | hub/internal/store/offsite_ended.go, hub/internal/offsitekeys/ended.go | `NoteAppList(customerID, deployed, claimed, now)`; `agreeEnded(now, presence, listing, haveListing, claims)` | The hub's OWN record of when an app left a box's app list (fed by `handleReport`), and the decision which snapshot ids of ended apps a window may remove outside its cap | **The box's dates decide nothing.** An id is agreed only when its app has been absent 30 days by the hub's clock AND the hub's own listing shows the file older than that absence. `WindowCredit.CapExplains` is the cap's part, `EndedIDs` the agreed ids — a reader that explains ids by name must not also spend `Explains`. **After the review of 2026-11-15:** one window agrees to at most the cap's size from the hub's OWN count (`endedCap`/`boundEndedToCap`); a request for more than half of the store waits a week — its first sight is the hub's own row (`store.NoteLargeEndedRequest`, key `largeSetKey` = a hash of the whole app set), never a search of text a box could write; `store.NoteAppListClaims` returns never-seen apps once for the operator's warning; a claimed name that is not an app name is written nowhere (`ledgerName`). | -| `notify.householdReceiptEvents` (D84) | hub/internal/notify/dispatcher.go | register | A mail that confirms the household's own press (one type: `offsite_end_scheduled`) | Bypasses the household's group switches and is keyed per press (details `subject`); the operator is not mailed. **Every new entry needs its own ruling** — pinned by `TestD84_Receipt_OpensNothingElse`. A receipt goes through `Dispatcher.processReceipt`, never `processCustomer`: the hub writes it from checked details (`parseReceipt`, `FormatReceiptEmail`), at most `receiptsPerDay` per household in 24 h (`store.CountCustomerSentSince`). | +| `store.NoteAppList` / `AppPresences` + `offsitekeys.agreeEnded` (D72/D84, `07` §8.2f) | hub/internal/store/offsite_ended.go, hub/internal/offsitekeys/ended.go | `NoteAppList(customerID, deployed, claimed, now)`; `agreeEnded(now, presence, notices, listing, haveListing, claims)` | The hub's OWN record of when an app left a box's app list (fed by `handleReport`), and the decision which snapshot ids of ended apps a window may remove outside its cap | **The box's dates decide nothing.** An id is agreed only when its app has been absent 30 days by the hub's clock AND the hub's own listing shows the file older than that absence. `WindowCredit.CapExplains` is the cap's part, `EndedIDs` the agreed ids — a reader that explains ids by name must not also spend `Explains`. **After the review of 2026-11-15:** one window agrees to at most the cap's size from the hub's OWN count (`endedCap`/`boundEndedToCap`); a request for more than half of the store waits a week — its first sight is the hub's own row (`store.NoteLargeEndedRequest`, key `largeSetKey` = a hash of the whole app set), never a search of text a box could write; `store.NoteAppListClaims` returns never-seen apps once for the operator's warning; a claimed name that is not an app name is written nowhere (`ledgerName`). | +| `notify.householdReceiptEvents` + `Dispatcher.SendEndNotice` (D84; the notice lock, `09` §3 decision 315) | hub/internal/notify/end_notice.go | register; `SendEndNotice(customerID, app, ends) (EndNoticeOutcome, why)` | The mail that tells the household about its own press (one type: `offsite_end_scheduled`). **The box's event mails nobody**: the hub sends the notice from its own state (`api.endNotices`, at every report, until the mail service accepts it) | Bypasses the household's group switches; the hub writes it from a checked app name and its OWN day. `SendEndNotice` keeps no state and tries once: only `EndNoticeSent` tells the household; the daily limit (5 per household, counted in the sent log) answers `EndNoticeLimit` — the caller tries again, it never drops. **Every new entry needs its own ruling** — pinned by `TestD84_Receipt_OpensNothingElse`, `TestNotice_*`. | +| `store.NoteEndNotices` / `EndNotices` / `MarkEndNoticeTold` + `api.endNotices` (the notice lock, `07` §8.2f) | hub/internal/store/offsite_end_notice.go, hub/internal/api/end_notice.go | `NoteEndNotices(customerID, deployed, claims, tierOn, now)`; `EndNotices(customerID)`; `MarkEndNoticeTold(customerID, app, press, to, now)` | The hub's OWN record that a household (or the operator in its place) was told that an app's off-site copies will be deleted. `offsitekeys.agreeEnded` agrees only when it says „told” 30 days ago | **Written only by the hub, only after the mail service accepted the mail; never derived from the sent log or from a box's date.** `press` (the box's `removed_at`) is a key only: another value VOIDS the notice. An install, a take-back (a report that shows the tier ON and no record) and a household delete remove the row. A new condition of a deletion goes HERE, not into `notification_log`. | +| `Dispatcher.SendOperatorNow` | hub/internal/notify/end_notice.go | `SendOperatorNow(customerID, eventType, severity, message, detailsJSON) error` | An operator mail whose DELIVERY is a condition of something else: it answers only when the mail service has (nil = accepted) | Operator-only types only; no cooldown and no background retry — the caller keeps its own „told once” record and tries again. For every other operator mail use `ProcessEvent`. | | `accesslog.New` / `Middleware` / `Mark` (v0.158.0, R-1140) | hub/internal/accesslog/accesslog.go | `Mark(ctx, kind)` | The hub's own access log (`/access-log/`, 90 days) and marking the identity KIND an auth check established | Never log a value: the path only (no query; `/bind/` and 32+-char segments redacted). A new auth path calls `Mark` with its kind. A logging failure never fails a request. | | the timed SQLite driver `sqlite-timed` + `SetSlowStatementThreshold` (v0.178.0, R-1346) | hub/internal/store/timeddriver.go | `store.New` opens it — nothing to call | Names a statement over 1 s: `[WARN] slow statement: (over 1s): ` | The SQL text only, never a bound value. Put a heavy statement's SQL in a const and pin its plan (`r1346_speed.go`, `TestR1346_HeavyStatementsUseTheirIndex`): on the hub's network disk a whole-table read is seconds to minutes. | | `(*Store).SaveOneTimeSecret` / `OffsitePassword` / `SealLegacyOffsiteSecrets` | hub/internal/store/offsite_seal.go | — | Storing / reading the sub-account password | **Sealed AES-256-GCM; no key → refused (fail-closed).** Under `go test` every store gets a fixed key (`testing.Testing()`); production needs `OFFSITE_SECRET_KEY`. Never serve the value to a box. | diff --git a/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-agree.txt b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-agree.txt new file mode 100644 index 00000000..6d96d04f --- /dev/null +++ b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-agree.txt @@ -0,0 +1,40 @@ +== MUTATION: no notice lock: the absence alone decides (the first build) + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AgreeEnded_NoNoticeNoDeletion (0.00s) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) +== MUTATION: a record that nobody was told about is enough + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AgreeEnded_NoNoticeNoDeletion (0.00s) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) +== MUTATION: told, however recently, is enough + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AgreeEnded_NoNoticeNoDeletion (0.00s) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) +== MUTATION: the told time counts 29 days + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AgreeEnded_NoNoticeNoDeletion (0.00s) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + --- FAIL: TestNotice_Window_TheNoticeRecordDecides (0.14s) + notice_lock_test.go:114: told 29 days ago: agreed [a1b2c684 a1b2c685], refused [] +== MUTATION: an app with no notice record at all is agreed + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AgreeEnded_NoNoticeNoDeletion (0.00s) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + notice_lock_test.go:59: agreed ids = [a1b2c685 a1b2c686], want [a1b2c685] (refused: []) + --- FAIL: TestNotice_Window_TheNoticeRecordDecides (0.05s) +== MUTATION: a box that asks for an app it never named in a report is refused quietly + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Window_TheNoticeRecordDecides (0.05s) + notice_lock_test.go:86: the operator must hear of a box that asks for an app it never named in a report: [] +== MUTATION: the notice is read IN PLACE of the absence + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AgreeEnded_NoNoticeNoDeletion (0.00s) + notice_lock_test.go:59: agreed ids = [a1b2c685], want [] (refused: []) + +7 mutations, 0 not a red-proof diff --git a/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-hub.txt b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-hub.txt new file mode 100644 index 00000000..07ffcf09 --- /dev/null +++ b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-hub.txt @@ -0,0 +1,54 @@ +== MUTATION: a report never starts the walk + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AReportNamesAnApp_TheHubMailsTheHouseholdOncePerPress (0.05s) + end_notice_test.go:162: the household got 0 notice(s) after the first report that names the app, want 1: [] + --- FAIL: TestNotice_TwoAppsInOneMinute_TwoNotices (0.05s) + end_notice_test.go:196: two apps: [] +== MUTATION: the next try does not wait + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AFailedSendIsTriedAgainUntilItHasGone (0.05s) + end_notice_test.go:266: a second try ten minutes after a failed one: 1 mail(s) +== MUTATION: a failed notice is never tried again + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AFailedSendIsTriedAgainUntilItHasGone (0.07s) + end_notice_test.go:272: the try an hour later must send and set the told time to THAT try (2026-11-15T16:10:54Z): mails=0 {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:09:54 +0000 UTC ToldAt:0001-01-01 00:00:00 + --- FAIL: TestNotice_TheMailHoldTellsNobody (0.04s) + end_notice_test.go:295: after the release: {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:09:54 +0000 UTC ToldAt:0001-01-01 00:00:00 +0000 UTC ToldTo: Tries:1 LastTry:2026-11-15 15:09:54 +0000 UTC LastReason:the +== MUTATION: the operator is not told in place of a household with no address + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_NoAddress_TheOperatorIsToldInItsPlace_AndAnAddressLaterRestarts (0.05s) + end_notice_test.go:346: the operator must be told once, naming the household, the app and why: [] + --- FAIL: TestNotice_NoAddress_AndTheOperatorsMailFails_NobodyWasTold (0.05s) + end_notice_test.go:392: no address and the operator's mail failed: {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:09:59 +0000 UTC ToldAt:0001-01-01 00:00:00 +0000 UTC ToldTo: Tries:0 LastTry:0001-01-01 00:00:00 + +== MUTATION: the operator's notice counts although its mail failed + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_NoAddress_AndTheOperatorsMailFails_NobodyWasTold (0.05s) + end_notice_test.go:392: no address and the operator's mail failed: {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:10:03 +0000 UTC ToldAt:2026-11-15 15:10:03 +0000 UTC ToldTo:operator Tries:1 LastTry:2026-11-15 15 +== MUTATION: an address added later changes nothing (the operator's notice stays the one that counts) + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_NoAddress_TheOperatorIsToldInItsPlace_AndAnAddressLaterRestarts (0.06s) + end_notice_test.go:372: an address added after the press: the household must be told and the 30 days start again: mails=[{to:operator@felhom.eu subject:[Felhom] ⚠️ c1: offsite_end_notice_operator body:Customer: c1 +== MUTATION: the operator's stuck line is filed at once + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_StuckForThreeDays_TheOperatorGetsOneLine (0.05s) + end_notice_test.go:409: told the operator after two days: [{ID:1 CustomerID:c1 EventType:offsite_end_notice_stuck Severity:warning Message:Off-site: the household c1 removed the app "vikunja" with „delete backup data” 0 days ago, +== MUTATION: the operator's stuck line is never filed + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_StuckForThreeDays_TheOperatorGetsOneLine (0.05s) + end_notice_test.go:425: want ONE warning naming the app and the reason: [] +== MUTATION: the operator's stuck line is repeated + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_StuckForThreeDays_TheOperatorGetsOneLine (0.05s) + end_notice_test.go:431: the line was repeated: 6 +== MUTATION: the stuck line is filed while the mail hold is on + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_StuckForThreeDays_TheOperatorGetsOneLine (0.05s) + end_notice_test.go:419: the line was filed while the hold is on: [{ID:1 CustomerID:c1 EventType:offsite_end_notice_stuck Severity:warning Message:Off-site: the household c1 removed the app "vikunja" with „delete backup data” 3 day +== MUTATION: the told time is the box's press, not the hub's clock + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AReportNamesAnApp_TheHubMailsTheHouseholdOncePerPress (0.05s) + end_notice_test.go:173: the hub's own record does not say the household was told now: {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:10:23 +0000 UTC ToldAt:2026-11-15 10:00:00 +0000 UTC ToldTo:household Tries:1 L + --- FAIL: TestNotice_AFailedSendIsTriedAgainUntilItHasGone (0.06s) + end_notice_test.go:272: the try an hour later must send and set the told time to THAT try (2026-11-15T16:11:23Z): mails=1 {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:10:23 +0000 UTC ToldAt:2026-11-15 10:00:00 + +11 mutations, 0 not a red-proof diff --git a/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-mail.txt b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-mail.txt new file mode 100644 index 00000000..18dbcb30 --- /dev/null +++ b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-mail.txt @@ -0,0 +1,45 @@ +# Two mutants of the first run did not compile (an unused variable) and proved nothing; they were rewritten and the whole file was run again. This is the second run. +== MUTATION: a failed send is reported as sent + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_AFailedSendIsTriedAgainUntilItHasGone (0.04s) + end_notice_test.go:260: after a failed send: {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:11:08 +0000 UTC ToldAt:2026-11-15 15:11:08 +0000 UTC ToldTo:household Tries:1 LastTry:2026-11-15 15:11:08 +0000 UTC Last + --- FAIL: TestNotice_StuckForThreeDays_TheOperatorGetsOneLine (0.05s) + end_notice_test.go:425: want ONE warning naming the app and the reason: [] +== MUTATION: a held mail is reported as sent + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_TheMailHoldTellsNobody (0.04s) + end_notice_test.go:288: under the hold: {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:11:12 +0000 UTC ToldAt:2026-11-15 15:11:12 +0000 UTC ToldTo:household Tries:1 LastTry:2026-11-15 15:11:12 +0000 UTC LastReaso + --- FAIL: TestNotice_StuckForThreeDays_TheOperatorGetsOneLine (0.06s) + end_notice_test.go:425: want ONE warning naming the app and the reason: [] +== MUTATION: the daily limit is not read + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_TheDailyLimitDelaysAndNeverDrops (0.08s) + end_notice_test.go:309: seven presses: 7 notices today, want the daily limit 5 + --- FAIL: TestNotice_TheDailyLimitDelaysAndSurvivesARestart (0.05s) + end_notice_test.go:157: the sixth notice: outcome sent (""), want limit +== MUTATION: a blocked household is mailed + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_NoAddress_TheOperatorIsToldInItsPlace_AndAnAddressLaterRestarts (0.12s) + end_notice_test.go:381: a blocked household: record {App:vikunja Press:2026-11-15T10:00:00Z FirstNamed:2026-11-15 15:11:22 +0000 UTC ToldAt:2026-11-15 15:11:22 +0000 UTC ToldTo:household Tries:1 LastTry:2026-11-15 15:11:22 +0000 U + --- FAIL: TestNotice_NoAddressOrBlocked_SaysSoAndMailsNobody (0.08s) + end_notice_test.go:137: blocked: outcome sent, 1 mail(s) +== MUTATION: any name is mailed + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_OnlyAnAppNameIsMailed (0.06s) + end_notice_test.go:212: "": outcome sent, 1 mail(s) +== MUTATION: SendOperatorNow takes any type + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_SendOperatorNow (0.05s) + end_notice_test.go:246: a type that is not operator-only was accepted +== MUTATION: SendOperatorNow answers nil for a failed send + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_SendOperatorNow (0.05s) + end_notice_test.go:250: a failed send answered nil — the caller would start the 30 days on a mail that never went + +7 mutations, 0 not a red-proof +== MUTATION: the box's event is routed like any other event again + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_TheBoxesEventMailsNobody (0.06s) + end_notice_test.go:113: the box's event caused 1 mail(s); first: {to:operator@felhom.eu subject:[Felhom] ⚠️ c1: offsite_end_scheduled body:Customer: c1 + +1 mutations, 0 not a red-proof diff --git a/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-store.txt b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-store.txt new file mode 100644 index 00000000..de153b66 --- /dev/null +++ b/documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-store.txt @@ -0,0 +1,47 @@ +== MUTATION: an install does not void the notice + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_WhatVoidsIt (0.35s) + offsite_end_notice_test.go:113: the notice is told, want gone +== MUTATION: another press keeps the old notice + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_WhatVoidsIt (0.35s) + offsite_end_notice_test.go:113: the notice is told, want fresh + offsite_end_notice_test.go:113: the notice is told, want fresh +== MUTATION: a take-back does not void the notice + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_WhatVoidsIt (0.35s) + offsite_end_notice_test.go:113: the notice is told, want gone +== MUTATION: a report that does not show the tier voids the notice (its silence read as a take-back) + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_WhatVoidsIt (0.35s) + offsite_end_notice_test.go:113: the notice is gone, want told +== MUTATION: a told mark is written whatever the press + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_OnePressOneRow (0.05s) + offsite_end_notice_test.go:47: a told mark for ANOTHER press was written (ok=true err=) +== MUTATION: a recipient the hub never writes counts as told + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_IsBoundedAndFailsClosed (0.05s) + offsite_end_notice_test.go:160: an unreadable record counts as told: {App:app-00 Press: FirstNamed:2026-11-15 10:00:00 +0000 UTC ToldAt:2020-01-01 00:00:00 +0000 UTC ToldTo:box Tries:0 LastTry:0001-01-01 00:00:00 +0000 UTC LastRea +== MUTATION: no row limit per household + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_IsBoundedAndFailsClosed (0.05s) + offsite_end_notice_test.go:136: rows = 80, want the limit 50 +== MUTATION: a name that is not an app name is stored + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_IsBoundedAndFailsClosed (0.05s) + offsite_end_notice_test.go:140: a name that is not an app name was stored: "x" + +8 mutations, 0 not a red-proof +== MUTATION: the notice record is not purged with the household + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_GoesWithTheHousehold (0.05s) + offsite_end_notice_test.go:172: the residue count does not see the notice record: &{Reports:0 AppTelemetry:0 AppLogTails:0 LogTailRequests:0 NotificationPrefs:0 SelfBindTokens:0 ApplianceRegistrations:0 AppLogIssueRefs:0 OffsiteKe + +1 mutations, 0 not a red-proof +== MUTATION: the notice record is not in the orphan sweep + RED on the mutant, GREEN on the real file + --- FAIL: TestNotice_Record_GoesWithTheHousehold (0.05s) + offsite_end_notice_test.go:184: orphan sweep: map[] + +1 mutations, 0 not a red-proof diff --git a/hub/CHANGELOG.md b/hub/CHANGELOG.md index a4ff078d..36ba2caa 100644 --- a/hub/CHANGELOG.md +++ b/hub/CHANGELOG.md @@ -1,5 +1,25 @@ ## Unreleased (after v0.182.0) +- **The notice lock (2026-11-15 evening, `09` §3 decision 315, R-1374; `07` §8.2f): no notice, no deletion.** The + household's mail about „delete backup data” was sent once, from the box's event — a lost event, a failed send or + the daily limit, and the hub still agreed 30 days later. Now **the hub sends the notice itself, from its own + state**: every controller report feeds a new table, `offsite_end_notices` (`store.NoteEndNotices` — one row per app + the report names in a pending end record), and `api.endNotices` mails each row's household + (`notify.SendEndNotice`) at every report until the mail service accepts the mail; only then does the row say + „told”, by the hub's clock. **`offsitekeys.agreeEnded` agrees to an app only when that row says „told” at least 30 + days ago — beside the 30 days of absence.** The box's event `offsite_end_scheduled` is recorded and mails nobody. + The day in the mail is the hub's own (its clock + 30 days). A household with no address, or a blocked one: the + operator is mailed in its place, once per app (`offsite_end_notice_operator`, sent with `SendOperatorNow`, which + answers only when the mail service has), and that mail starts the 30 days; an address added later gives the + household its own mail and starts them again *(decided by CC unattended — the operator may reverse it)*. An + install, a take-back (a report that shows the tier on and no record) and another press void the notice; a + database put back from a copy that lacks the row tells again and waits again. The daily limit (5) delays a notice + and never drops one. The mail hold or a failed send: nobody is told, the window's answer names the reason, the + next try is an hour later, and after **3 days** the operator gets one line (`offsite_end_notice_stuck`). A box + that asks a window for an app it never named in a report is refused and told to the operator + (`offsite_ended_app_refused`). No controller change: an older controller sends no end records and nothing of it is + removed, as before. Tests `TestNotice_*` (store 4, offsitekeys 2, api 13, notify 8); 36 mutations seen red (two + redone: they did not compile). `TestD84_Receipt_*` (the event-driven mail) are replaced by them. - **D83, the hub's half (2026-11-15 evening, R-1398 part 2; `16` §14.5): the hub shows which boxes were accepted on a small system disk.** `POST /host-enroll` reads `small_disk` (only the JSON `true`) and, when a later installer sends it, `system_disk_bytes`; `store.NoteSmallDisk` / `SmallDiskOf` keep it as one of the marks that name the box diff --git a/hub/internal/api/end_notice.go b/hub/internal/api/end_notice.go new file mode 100644 index 00000000..8b88b9a5 --- /dev/null +++ b/hub/internal/api/end_notice.go @@ -0,0 +1,196 @@ +package api + +import ( + "encoding/json" + "fmt" + "sort" + "sync" + "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" +) + +// THE NOTICE LOCK (`09` §3 decision 315; `07-backup-architecture.md` §8.2f „No notice, no deletion”) — the hub sends +// the household's notice ITSELF, from its own state, until it has gone. +// +// Every controller report feeds the hub's record (store.NoteEndNotices: which apps the box names in a pending end +// record). After that, endNotices walks the household's rows and, for each one whose household has not been told: +// +// - tries the household's mail (notify.SendEndNotice). Sent → the record says „told” at the hub's time, and the +// hub agrees to remove that app's copies no earlier than 30 days after it (offsitekeys.agreeEnded). +// - no address, or a blocked household → the OPERATOR is mailed in its place, once per app +// (`offsite_end_notice_operator`), and that mail starts the 30 days. When an address appears later, the household +// gets its own mail and the 30 days start again from it. +// - the daily limit, the mail hold, a send that fails → nothing is told; the reason is written on the row (the +// window's answer names it) and the next try is at a report at least endNoticeRetryGap later. +// - a row that has not been told for EndNoticeStuckAfter → one line to the operator (`offsite_end_notice_stuck`). +// +// Nothing here reads a date a box sent, and no event of a box starts or stops anything. + +const ( + // endNoticeRetryGap: after a try that told nobody, the next try waits this long (a report comes every 15 minutes; + // a mail service that is down is not asked 96 times a day per app). + endNoticeRetryGap = time.Hour + + // EndNoticeStuckAfter: how long a notice may stay unsent before the operator gets one line. THREE DAYS: longer + // than any outage of the mail service the hub has had and than the hold on a restored copy is meant to last, and + // longer than the daily limit delays an honest household (5 notices a day: a household that removes up to 15 + // apps at once is told about all of them inside it) — so the line means „this will not heal by itself”. Short + // enough that a deletion the household asked for has lost three days, not a month, when the operator hears. + EndNoticeStuckAfter = 3 * 24 * time.Hour +) + +// endNoticeSpawn runs the sends off the report's request (a send can wait 10 s on the mail service). A seam: tests +// run it in line. +var endNoticeSpawn = func(f func()) { go f() } + +// endNoticeBusy: one walk per household at a time — a second report that arrives while a walk is still sending does +// not send the same notice again; its rows are picked up by the next report. +var endNoticeBusy sync.Map // customerID → *sync.Mutex + +// kickEndNotices starts a walk when the household has a row that still needs one. +func (h *Handler) kickEndNotices(customerID string) { + ns, err := h.store.EndNotices(customerID) + if err != nil { + h.logger.Printf("[WARN] [end-notice] %s: the hub's own notice record could not be read: %v", customerID, err) + return + } + work := false + for _, n := range ns { + if n.ToldTo != store.EndNoticeHousehold { + work = true + } + } + if work { + endNoticeSpawn(func() { h.endNotices(customerID, time.Now()) }) + } +} + +// endNotices is one walk over a household's rows (see the header). now is the HUB's clock. +func (h *Handler) endNotices(customerID string, now time.Time) { + mu, _ := endNoticeBusy.LoadOrStore(customerID, &sync.Mutex{}) + if !mu.(*sync.Mutex).TryLock() { + return + } + defer mu.(*sync.Mutex).Unlock() + ns, err := h.store.EndNotices(customerID) + if err != nil { + h.logger.Printf("[WARN] [end-notice] %s: the hub's own notice record could not be read: %v", customerID, err) + return + } + apps := make([]string, 0, len(ns)) + for app := range ns { + apps = append(apps, app) + } + sort.Strings(apps) + for _, app := range apps { + n := ns[app] + if n.ToldTo == store.EndNoticeHousehold { + continue + } + if n.LastReason != "" && !n.LastTry.IsZero() && now.Sub(n.LastTry) < endNoticeRetryGap { + h.endNoticeStuck(customerID, n, now) + continue + } + outcome, why := notify.EndNoticeFailed, "the hub has no mail service configured" + if h.dispatcher != nil { + // The day in the mail is the hub's own: its clock now + 30 days. Never the box's date. + outcome, why = h.dispatcher.SendEndNotice(customerID, app, now.Add(offsitekeys.EndedAppAfter)) + } + switch outcome { + case notify.EndNoticeSent: + ok, merr := h.store.MarkEndNoticeTold(customerID, app, n.Press, store.EndNoticeHousehold, now) + if merr != nil || !ok { + // The mail went and the record does not say so: the household is mailed again at a later report and + // the 30 days start then. The safe direction (no deletion on a notice the hub cannot show). + h.logger.Printf("[WARN] [end-notice] %s/%s: the household's notice was sent, but the hub's record was NOT written (matched=%v, err=%v) — it will be sent again", customerID, app, ok, merr) + continue + } + n.ToldAt, n.ToldTo = now, store.EndNoticeHousehold + h.logger.Printf("[INFO] [end-notice] %s/%s: the household was told; the hub agrees to remove this app's off-site copies no earlier than %s", + customerID, app, now.Add(offsitekeys.EndedAppAfter).UTC().Format("2006-01-02")) + case notify.EndNoticeNoAddress: + if n.Told() { + continue // the operator was told in its place; the household still has no address + } + if terr := h.endNoticeToOperator(customerID, n, why, now); terr != nil { + why = why + "; and the operator could not be told in its place (" + terr.Error() + ")" + h.endNoticeTried(customerID, &n, why, now) + } else { + n.ToldAt, n.ToldTo = now, store.EndNoticeOperator + } + default: // the daily limit, the hold, a failed send + h.endNoticeTried(customerID, &n, why, now) + } + h.endNoticeStuck(customerID, n, now) + } +} + +func (h *Handler) endNoticeTried(customerID string, n *store.EndNotice, why string, now time.Time) { + if err := h.store.MarkEndNoticeTried(customerID, n.App, n.Press, why, now); err != nil { + h.logger.Printf("[WARN] [end-notice] %s/%s: the try could not be recorded: %v", customerID, n.App, err) + } + n.LastReason, n.LastTry = why, now + h.logger.Printf("[WARN] [end-notice] %s/%s: nobody was told (%s) — nothing of this app is removed; tried again at a later report", customerID, n.App, why) +} + +// endNoticeToOperator mails the operator in place of a household the hub cannot mail, and only when the mail service +// accepted that mail does the record say „told” (to the operator): that mail starts the app's 30 days. +// DECIDED BY CC UNATTENDED 2026-11-15 (the brief's A.3) — the operator may reverse it: `07` §8.2f. +func (h *Handler) endNoticeToOperator(customerID string, n store.EndNotice, why string, now time.Time) error { + if h.dispatcher == nil { + return fmt.Errorf("the hub has no mail service configured") + } + day := now.Add(offsitekeys.EndedAppAfter).UTC().Format("2006-01-02") + msg := fmt.Sprintf("Off-site: the household %s removed the app %q with „delete backup data”, and the hub could not tell the household: %s. "+ + "This mail is the notice in its place. The hub counts the 30 days from now: from %s a clean-up window may remove that app's off-site copies. "+ + "Tell the household. If the household did not ask for this, it can take it back on its Backups page (“Keep it after all”) and must change its password. "+ + "When the household gets a notification address, the hub mails the household itself and the 30 days start again from that mail.", + customerID, n.App, why, day) + details, _ := json.Marshal(map[string]any{"subject": n.App, "app": n.App, "agrees_from": day}) + if err := h.dispatcher.SendOperatorNow(customerID, offsitekeys.EventEndNoticeOperator, "warning", msg, string(details)); err != nil { + return err + } + if _, err := h.store.SaveEvent(customerID, offsitekeys.EventEndNoticeOperator, "warning", msg, string(details), "hub"); err != nil { + h.logger.Printf("[WARN] [end-notice] %s event save FAILED for %s (the mail went): %v", offsitekeys.EventEndNoticeOperator, customerID, err) + } + ok, err := h.store.MarkEndNoticeTold(customerID, n.App, n.Press, store.EndNoticeOperator, now) + if err != nil || !ok { + return fmt.Errorf("the operator's mail went, but the hub's record was not written (matched=%v, err=%v)", ok, err) + } + h.logger.Printf("[WARN] [end-notice] %s/%s: the household could not be told (%s) — the OPERATOR was told in its place; the hub agrees no earlier than %s", customerID, n.App, why, day) + return nil +} + +// endNoticeStuck files the operator's one line for a notice that has told nobody for EndNoticeStuckAfter. Not while +// the mail hold is on (a held hub mails nobody; the line is filed at the first report after the release). +func (h *Handler) endNoticeStuck(customerID string, n store.EndNotice, now time.Time) { + if n.Told() || !n.StuckTold.IsZero() || n.FirstNamed.IsZero() || now.Sub(n.FirstNamed) < EndNoticeStuckAfter { + return + } + if h.dispatcher != nil && h.dispatcher.MailHeld() { + return + } + why := n.LastReason + if why == "" { + why = "no try has been recorded" + } + msg := fmt.Sprintf("Off-site: the household %s removed the app %q with „delete backup data” %d days ago, and the notice about it has not gone out: %s. "+ + "NOTHING of that app's off-site copies is removed until the notice has gone and 30 days have passed after it. "+ + "The household asked for this deletion and it is waiting: look at why the mail does not go. This line is sent once per app.", + customerID, n.App, int(now.Sub(n.FirstNamed).Hours()/24), why) + details, _ := json.Marshal(map[string]any{"subject": n.App, "app": n.App, "reason": why}) + if _, err := h.store.SaveEvent(customerID, offsitekeys.EventEndNoticeStuck, "warning", msg, string(details), "hub"); err != nil { + h.logger.Printf("[WARN] [end-notice] %s event save FAILED for %s: %v", offsitekeys.EventEndNoticeStuck, customerID, err) + return // the audit row first: a mail without its event row lies + } + if err := h.store.MarkEndNoticeStuckTold(customerID, n.App, n.Press, now); err != nil { + h.logger.Printf("[WARN] [end-notice] %s/%s: the operator's line could not be marked as filed: %v", customerID, n.App, err) + } + h.logger.Printf("[WARN] [end-notice] %s/%s: the notice has told nobody for %d days (%s) — operator told once", customerID, n.App, int(now.Sub(n.FirstNamed).Hours()/24), why) + if h.dispatcher != nil { + h.dispatcher.ProcessEvent(customerID, offsitekeys.EventEndNoticeStuck, "warning", msg, string(details), "hub") + } +} diff --git a/hub/internal/api/end_notice_test.go b/hub/internal/api/end_notice_test.go new file mode 100644 index 00000000..c364d661 --- /dev/null +++ b/hub/internal/api/end_notice_test.go @@ -0,0 +1,509 @@ +package api + +import ( + "errors" + "fmt" + "io" + "log" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + "gitea.dooplex.hu/admin/felhom-hub/internal/mailhold" + "gitea.dooplex.hu/admin/felhom-hub/internal/notify" + "gitea.dooplex.hu/admin/felhom-hub/internal/offsitekeys" + "gitea.dooplex.hu/admin/felhom-hub/internal/store" +) + +// THE NOTICE LOCK (`09` §3 decision 315; `07-backup-architecture.md` §8.2f „No notice, no deletion”): the hub sends +// the household's notice itself, from the box's REPORT, until it has gone — and its own record says „told” only when +// the mail service accepted the mail. Every test here drives the real report endpoint; no test posts the box's event. +// RED-PROOFS: documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-hub.txt. + +type noticeMail struct{ to, subject, body string } + +type noticeRig struct { + t *testing.T + h *Handler + st *store.Store + d *notify.Dispatcher + mu sync.Mutex + mails []noticeMail + fail error // when set, every send fails with it +} + +// newNoticeRig: a household c1 with a notification address (email "" = none), a dispatcher whose sends are recorded, +// and the sends run in line with the report. +func newNoticeRig(t *testing.T, email string) *noticeRig { + t.Helper() + h, st, _ := newTestHandler(t) + if err := st.SaveCustomerConfig(&store.CustomerConfig{CustomerID: "c1", APIKey: "ckey", RetrievalPassword: "pp"}); err != nil { + t.Fatal(err) + } + if email != "" { + if err := st.SaveNotificationPrefs("c1", email, []string{}, 6); err != nil { // every switch off + t.Fatal(err) + } + } + r := ¬iceRig{t: t, h: h, st: st} + r.d = notify.NewDispatcher(st, "test-key-not-used", "from@felhom.eu", "operator@felhom.eu", true, log.New(io.Discard, "", 0)) + r.d.SetSendFnForTest(func(to, subject, body string, _ map[string]string) error { + r.mu.Lock() + defer r.mu.Unlock() + if r.fail != nil { + return r.fail + } + r.mails = append(r.mails, noticeMail{to, subject, body}) + return nil + }) + h.SetDispatcher(r.d) + old := endNoticeSpawn + endNoticeSpawn = func(f func()) { f() } + t.Cleanup(func() { endNoticeSpawn = old }) + // vikunja and kimai were seen installed: the never-seen warning (offsite_end_claim_unseen) is not this file's subject + r.report(`{"customer_id":"c1","stacks":{"deployed":["immich","vikunja","kimai"]},"offsite":{"enabled":true}}`) + return r +} + +// all is a copy of every mail so far (the never-seen warning of another feature is sent off the request). +func (r *noticeRig) all() []noticeMail { + r.mu.Lock() + defer r.mu.Unlock() + return append([]noticeMail(nil), r.mails...) +} + +// opNotice: the operator's mails of one event type. +func (r *noticeRig) opNotice(typ string) []noticeMail { + var out []noticeMail + for _, m := range r.to(operator) { + if strings.Contains(m.subject, typ) { + out = append(out, m) + } + } + return out +} + +func (r *noticeRig) report(body string) { + r.t.Helper() + req := httptest.NewRequest(http.MethodPost, "/api/v1/report", strings.NewReader(body)) + req.Header.Set("Authorization", "Bearer ckey") + rr := httptest.NewRecorder() + r.h.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + r.t.Fatalf("report → %d (%s)", rr.Code, rr.Body.String()) + } +} + +// to counts the mails that went to one address. +func (r *noticeRig) to(addr string) []noticeMail { + r.mu.Lock() + defer r.mu.Unlock() + var out []noticeMail + for _, m := range r.mails { + if m.to == addr { + out = append(out, m) + } + } + return out +} + +func (r *noticeRig) notice(app string) (store.EndNotice, bool) { + r.t.Helper() + ns, err := r.st.EndNotices("c1") + if err != nil { + r.t.Fatal(err) + } + n, ok := ns[app] + return n, ok +} + +func (r *noticeRig) events(typ string) []store.Event { + r.t.Helper() + evs, err := r.st.GetEventsByType("c1", typ, time.Now().Add(-time.Hour)) + if err != nil { + r.t.Fatal(err) + } + return evs +} + +const ( + household = "customer@example.com" + operator = "operator@felhom.eu" + // installed: immich runs; nothing is pending + repInstalled = `{"customer_id":"c1","stacks":{"deployed":["immich","vikunja"]},"offsite":{"enabled":true}}` + // the household removed vikunja with „delete backup data” + repPressed = `{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[{"app":"vikunja","removed_at":"2026-11-15T10:00:00Z","ends_at":"1999-01-31T10:00:00Z"}]}}` + // the tier is on and no record is pending: a take-back (or the window has run) + repKept = `{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true}}` +) + +func pressed(app, removedAt string) string { + return fmt.Sprintf(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[{"app":%q,"removed_at":%q,"ends_at":"2026-12-15T10:00:00Z"}]}}`, app, removedAt) +} + +// 1. THE HUB SENDS THE NOTICE ITSELF — the box's event never arrives in this test. One press is one notice, however +// many reports name it; the record says „told” at the hub's time; the mail's day is the HUB's (its clock + 30 days), +// not the box's `ends_at` (a day in 1999 here). +func TestNotice_AReportNamesAnApp_TheHubMailsTheHouseholdOncePerPress(t *testing.T) { + r := newNoticeRig(t, household) + r.report(repInstalled) + if len(r.all()) != 0 { + t.Fatalf("an installed app caused %d mail(s)", len(r.all())) + } + before := time.Now().Add(-time.Second) + r.report(repPressed) + got := r.to(household) + if len(got) != 1 { + t.Fatalf("the household got %d notice(s) after the first report that names the app, want 1: %+v", len(got), r.all()) + } + hubDay := time.Now().Add(offsitekeys.EndedAppAfter) + if !strings.Contains(got[0].subject, "vikunja: ") || strings.Contains(got[0].subject+got[0].body, "1999") { + t.Fatalf("the notice must name the app and the HUB's day, never the box's ends_at:\n%s\n%s", got[0].subject, got[0].body) + } + if y := fmt.Sprintf("Törlésük napja: %d.", hubDay.Year()); !strings.Contains(got[0].body, y) { + t.Fatalf("the mail's day is not the hub's clock + 30 days (%s): %s", y, got[0].body) + } + n, ok := r.notice("vikunja") + if !ok || n.ToldTo != store.EndNoticeHousehold || n.ToldAt.Before(before) || n.ToldAt.After(time.Now().Add(time.Second)) { + t.Fatalf("the hub's own record does not say the household was told now: %+v (found=%v)", n, ok) + } + if len(r.to(operator)) != 0 { + t.Fatalf("the operator was mailed for a household that has an address: %+v", r.to(operator)) + } + for i := 0; i < 6; i++ { + r.report(repPressed) + } + if got := r.to(household); len(got) != 1 { + t.Fatalf("one press, seven reports: %d notices, want 1", len(got)) + } + if n2, _ := r.notice("vikunja"); !n2.ToldAt.Equal(n.ToldAt) { + t.Fatalf("a later report moved the told time: %s → %s", n.ToldAt, n2.ToldAt) + } +} + +// 2. Two apps pressed in one minute: two notices, two records. +func TestNotice_TwoAppsInOneMinute_TwoNotices(t *testing.T) { + r := newNoticeRig(t, household) + r.report(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[ + {"app":"vikunja","removed_at":"2026-11-15T10:00:00Z"},{"app":"kimai","removed_at":"2026-11-15T10:00:30Z"}]}}`) + got := r.to(household) + if len(got) != 2 || !strings.Contains(got[0].subject+got[1].subject, "kimai") || !strings.Contains(got[0].subject+got[1].subject, "vikunja") { + t.Fatalf("two apps: %+v", got) + } + for _, app := range []string{"vikunja", "kimai"} { + if n, ok := r.notice(app); !ok || !n.Told() { + t.Fatalf("%s is not recorded as told: %+v", app, n) + } + } +} + +// 3. A TAKE-BACK OR AN INSTALL VOIDS THE NOTICE. Press, take-back and press again within one day: the second press +// gets its own notice and its own told time — the first one's is gone. The same after an install. +func TestNotice_ATakeBackOrAnInstallVoidsTheNotice(t *testing.T) { + r := newNoticeRig(t, household) + r.report(pressed("vikunja", "2026-11-15T10:00:00Z")) + // the first notice is 40 days old in the hub's record: it would be old enough + old := time.Now().UTC().Add(-40 * 24 * time.Hour) + if err := r.st.SetEndNoticeForTest("c1", "vikunja", "2026-11-15T10:00:00Z", old, old, store.EndNoticeHousehold); err != nil { + t.Fatal(err) + } + r.report(repKept) // „keep it after all” + if n, ok := r.notice("vikunja"); ok { + t.Fatalf("after the take-back the hub still holds a notice: %+v", n) + } + r.report(pressed("vikunja", "2026-11-15T16:00:00Z")) // pressed again, the same day + if got := r.to(household); len(got) != 2 { + t.Fatalf("press, take-back, press: %d notices, want 2 (a new press needs a new notice)", len(got)) + } + n, _ := r.notice("vikunja") + if !n.Told() || time.Since(n.ToldAt) > time.Minute { + t.Fatalf("the second press must have its OWN told time (now), not the first one's (40 days ago): %+v", n) + } + // an install: the app is in the app list again + if err := r.st.SetEndNoticeForTest("c1", "vikunja", "2026-11-15T16:00:00Z", old, old, store.EndNoticeHousehold); err != nil { + t.Fatal(err) + } + r.report(repInstalled) + if n, ok := r.notice("vikunja"); ok { + t.Fatalf("after an install the hub still holds a notice: %+v", n) + } + // another press that the hub never saw taken back (the tier was off in between): the press's key differs + r.report(pressed("vikunja", "2026-11-16T09:00:00Z")) + if err := r.st.SetEndNoticeForTest("c1", "vikunja", "2026-11-16T09:00:00Z", old, old, store.EndNoticeHousehold); err != nil { + t.Fatal(err) + } + r.report(`{"customer_id":"c1","stacks":{"deployed":["immich"]}}`) // the tier is off: silence is NOT a take-back + if n, ok := r.notice("vikunja"); !ok || !n.Told() { + t.Fatalf("a report that does not show the tier voided the notice: %+v", n) + } + sent := len(r.to(household)) + r.report(pressed("vikunja", "2026-11-20T09:00:00Z")) + n, _ = r.notice("vikunja") + if len(r.to(household)) != sent+1 || time.Since(n.ToldAt) > time.Minute { + t.Fatalf("another press (another removed_at) must be told again and wait again: mails %d→%d, %+v", sent, len(r.to(household)), n) + } +} + +// 5a. A NOTICE THAT CANNOT GO OUT tells nobody: the record stays „not told” with the reason, the next try waits an +// hour, and the first try that the mail service accepts sets the told time — then, not earlier. +func TestNotice_AFailedSendIsTriedAgainUntilItHasGone(t *testing.T) { + r := newNoticeRig(t, household) + r.fail = errors.New("resend: 503") + r.report(repPressed) + n, ok := r.notice("vikunja") + if !ok || n.Told() || !strings.Contains(n.LastReason, "did not accept") || n.Tries != 1 { + t.Fatalf("after a failed send: %+v (found=%v) — want not told, with the reason", n, ok) + } + r.fail = nil + now := time.Now() + r.h.endNotices("c1", now.Add(10*time.Minute)) + if len(r.all()) != 0 { + t.Fatalf("a second try ten minutes after a failed one: %d mail(s)", len(r.all())) + } + at := now.Add(61 * time.Minute) + r.h.endNotices("c1", at) + n, _ = r.notice("vikunja") + if len(r.to(household)) != 1 || !n.Told() || n.ToldAt.Unix() != at.Unix() { + t.Fatalf("the try an hour later must send and set the told time to THAT try (%s): mails=%d %+v", at.UTC().Format(time.RFC3339), len(r.all()), n) + } +} + +// 5b. The mail hold: nobody is told, the reason names the hold, and after the release the notice goes. +func TestNotice_TheMailHoldTellsNobody(t *testing.T) { + r := newNoticeRig(t, household) + dir := t.TempDir() + marker := filepath.Join(dir, mailhold.FileName) + if err := os.WriteFile(marker, nil, 0o644); err != nil { + t.Fatal(err) + } + r.d.SetMailHold(mailhold.New(dir, nil)) + r.report(repPressed) + n, _ := r.notice("vikunja") + if n.Told() || !strings.Contains(n.LastReason, "MAIL-HOLD") || len(r.all()) != 0 { + t.Fatalf("under the hold: %+v, %d mail(s)", n, len(r.all())) + } + if err := os.Remove(marker); err != nil { + t.Fatal(err) + } + r.h.endNotices("c1", time.Now().Add(2*time.Hour)) + if n, _ := r.notice("vikunja"); !n.Told() || len(r.to(household)) != 1 { + t.Fatalf("after the release: %+v, %d mail(s)", n, len(r.all())) + } +} + +// 1b. THE DAILY LIMIT DELAYS A NOTICE; IT NEVER DROPS ONE. Seven apps in one report: five are told today, two stay +// „not told” with the reason — and are told a day later. +func TestNotice_TheDailyLimitDelaysAndNeverDrops(t *testing.T) { + r := newNoticeRig(t, household) + var recs []string + for i := 0; i < 7; i++ { + recs = append(recs, fmt.Sprintf(`{"app":"app-%d","removed_at":"2026-11-15T10:00:00Z"}`, i)) + } + r.report(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[` + strings.Join(recs, ",") + `]}}`) + if got := r.to(household); len(got) != 5 { + t.Fatalf("seven presses: %d notices today, want the daily limit 5", len(got)) + } + untold := 0 + for i := 0; i < 7; i++ { + if n, ok := r.notice(fmt.Sprintf("app-%d", i)); !ok { + t.Fatalf("app-%d has no record — a notice was DROPPED", i) + } else if !n.Told() { + untold++ + if !strings.Contains(n.LastReason, "daily limit") { + t.Fatalf("app-%d: not told, and the reason is %q", i, n.LastReason) + } + } + } + if untold != 2 { + t.Fatalf("%d of 7 are not told, want 2", untold) + } + if err := r.st.BackdateNotificationLogForTest("c1", 25*time.Hour); err != nil { + t.Fatal(err) + } + r.h.endNotices("c1", time.Now().Add(25*time.Hour)) + if got := r.to(household); len(got) != 7 { + t.Fatalf("a day later: %d notices in all, want 7 — the limit must only delay", len(got)) + } + for i := 0; i < 7; i++ { + if n, _ := r.notice(fmt.Sprintf("app-%d", i)); !n.Told() { + t.Fatalf("app-%d is still not told", i) + } + } +} + +// 3 (A.3). A HOUSEHOLD WITH NO ADDRESS: the operator is told once per app, operator-only, and THAT mail starts the +// 30 days. The address is added after the press: the household gets its own notice and the 30 days start again. +func TestNotice_NoAddress_TheOperatorIsToldInItsPlace_AndAnAddressLaterRestarts(t *testing.T) { + r := newNoticeRig(t, "") + r.report(repPressed) + op := r.opNotice(offsitekeys.EventEndNoticeOperator) + if len(op) != 1 || !strings.Contains(op[0].body, `"vikunja"`) || !strings.Contains(op[0].body, "c1") || !strings.Contains(op[0].body, "no notification address") { + t.Fatalf("the operator must be told once, naming the household, the app and why: %+v", r.all()) + } + n, _ := r.notice("vikunja") + if n.ToldTo != store.EndNoticeOperator || !n.Told() { + t.Fatalf("the record must say the OPERATOR was told: %+v", n) + } + if e := r.events(offsitekeys.EventEndNoticeOperator); len(e) != 1 || e[0].Severity != "warning" || !strings.Contains(e[0].DetailsJSON, `"subject":"vikunja"`) { + t.Fatalf("the operator's event row: %+v", e) + } + for i := 0; i < 5; i++ { + r.report(repPressed) + } + if got := r.opNotice(offsitekeys.EventEndNoticeOperator); len(got) != 1 { + t.Fatalf("told once per app: %d mails after six reports", len(got)) + } + // the operator's notice is 40 days old; the household gets an address now + old := time.Now().UTC().Add(-40 * 24 * time.Hour) + if err := r.st.SetEndNoticeForTest("c1", "vikunja", "2026-11-15T10:00:00Z", old, old, store.EndNoticeOperator); err != nil { + t.Fatal(err) + } + if err := r.st.SaveNotificationPrefs("c1", household, []string{}, 6); err != nil { + t.Fatal(err) + } + r.report(repPressed) + n, _ = r.notice("vikunja") + if len(r.to(household)) != 1 || n.ToldTo != store.EndNoticeHousehold || time.Since(n.ToldAt) > time.Minute { + t.Fatalf("an address added after the press: the household must be told and the 30 days start again: mails=%+v record=%+v", r.mails, n) + } + // a blocked household is the same case + r2 := newNoticeRig(t, household) + if err := r2.st.SetCustomerConfigStatus("c1", "blocked"); err != nil { + t.Fatal(err) + } + r2.report(repPressed) + if n, _ := r2.notice("vikunja"); n.ToldTo != store.EndNoticeOperator || len(r2.to(household)) != 0 || len(r2.opNotice(offsitekeys.EventEndNoticeOperator)) != 1 { + t.Fatalf("a blocked household: record %+v, mails %+v", n, r2.all()) + } +} + +// 3b. The operator cannot be told either: NOBODY was told, so nothing starts. +func TestNotice_NoAddress_AndTheOperatorsMailFails_NobodyWasTold(t *testing.T) { + r := newNoticeRig(t, "") + r.fail = errors.New("resend: 503") + r.report(repPressed) + n, ok := r.notice("vikunja") + if !ok || n.Told() || !strings.Contains(n.LastReason, "operator could not be told") { + t.Fatalf("no address and the operator's mail failed: %+v", n) + } + if e := r.events(offsitekeys.EventEndNoticeOperator); len(e) != 0 { + t.Fatalf("an event row says the operator was told, and no mail went: %+v", e) + } +} + +// 5c. A notice that has told nobody for three days: the operator gets ONE line. Not at two days; not twice; not +// while the hold is on. +func TestNotice_StuckForThreeDays_TheOperatorGetsOneLine(t *testing.T) { + r := newNoticeRig(t, household) + r.fail = errors.New("resend: 503") + r.report(repPressed) + now := time.Now() + stuck := func() []store.Event { return r.events(offsitekeys.EventEndNoticeStuck) } + r.h.endNotices("c1", now.Add(2*24*time.Hour)) + if e := stuck(); len(e) != 0 { + t.Fatalf("told the operator after two days: %+v", e) + } + dir := t.TempDir() + marker := filepath.Join(dir, mailhold.FileName) + if err := os.WriteFile(marker, nil, 0o644); err != nil { + t.Fatal(err) + } + r.d.SetMailHold(mailhold.New(dir, nil)) + r.h.endNotices("c1", now.Add(EndNoticeStuckAfter+time.Hour)) + if e := stuck(); len(e) != 0 { + t.Fatalf("the line was filed while the hold is on: %+v", e) + } + _ = os.Remove(marker) + r.h.endNotices("c1", now.Add(EndNoticeStuckAfter+3*time.Hour)) + e := stuck() + if len(e) != 1 || e[0].Severity != "warning" || !strings.Contains(e[0].Message, `"vikunja"`) || !strings.Contains(e[0].Message, "did not accept") || !strings.Contains(e[0].DetailsJSON, `"subject":"vikunja"`) { + t.Fatalf("want ONE warning naming the app and the reason: %+v", e) + } + for i := 5; i < 10; i++ { + r.h.endNotices("c1", now.Add(EndNoticeStuckAfter+time.Duration(i)*time.Hour)) + } + if e := stuck(); len(e) != 1 { + t.Fatalf("the line was repeated: %d", len(e)) + } + if n, _ := r.notice("vikunja"); n.Told() { + t.Fatalf("the operator's line must not count as the notice: %+v", n) + } +} + +// 7. THE DATABASE IS PUT BACK FROM A COPY THAT LACKS THE NOTICE: the hub has no record, so it tells again and the +// told time is new — it waits again. +func TestNotice_ADatabaseWithoutTheNoticeTellsAgain(t *testing.T) { + r := newNoticeRig(t, household) + r.report(repPressed) + if len(r.to(household)) != 1 { + t.Fatal("fixture: no first notice") + } + restored := newNoticeRig(t, household) // the copy: the household and its address, no notice row + if _, ok := restored.notice("vikunja"); ok { + t.Fatal("fixture: the copy holds a notice") + } + restored.report(repPressed) + n, ok := restored.notice("vikunja") + if !ok || !n.Told() || time.Since(n.ToldAt) > time.Minute || len(restored.to(household)) != 1 { + t.Fatalf("on the copy the household must be told again, with a told time of now: %+v mails=%d", n, len(restored.all())) + } +} + +// 7. A household deleted between the notice and the window: its notice rows go with it, and nothing is mailed after. +func TestNotice_ADeletedHouseholdHasNoNotice(t *testing.T) { + r := newNoticeRig(t, household) + r.fail = errors.New("resend: 503") + r.report(repPressed) + if err := r.st.PurgeCustomerResidue("c1"); err != nil { + t.Fatal(err) + } + if ns, _ := r.st.EndNotices("c1"); len(ns) != 0 { + t.Fatalf("the notice outlived the household: %+v", ns) + } + r.fail = nil + r.h.endNotices("c1", time.Now().Add(2*time.Hour)) + if len(r.all()) != 0 { + t.Fatalf("a deleted household was mailed: %+v", r.all()) + } +} + +// A box's names are the box's word: a name that is not an app name, a reserved name and an installed app get no +// notice; and no box can POST the hub's own two warnings. +func TestNotice_OnlyRealRemovedAppsAreTold(t *testing.T) { + r := newNoticeRig(t, household) + r.report(`{"customer_id":"c1","stacks":{"deployed":["immich"]},"offsite":{"enabled":true,"ended_apps":[ + {"app":"x"},{"app":"_shares"},{"app":"traefik"},{"app":"immich"},{"app":"pay now at evil.example"}]}}`) + if len(r.all()) != 0 { + t.Fatalf("mails: %+v", r.all()) + } + if ns, _ := r.st.EndNotices("c1"); len(ns) != 0 { + t.Fatalf("rows: %+v", ns) + } + for _, typ := range []string{offsitekeys.EventEndNoticeOperator, offsitekeys.EventEndNoticeStuck} { + if allowedEventTypes[typ] { + t.Fatalf("a box must not be able to POST %s", typ) + } + } +} + +// THE SEAM IS WIRED: with the real spawn (off the request) a report still causes the notice. +func TestNotice_TheReportStartsTheWalkOffTheRequest(t *testing.T) { + r := newNoticeRig(t, household) + endNoticeSpawn = func(f func()) { go f() } // newNoticeRig's cleanup restores the original + r.report(repPressed) + deadline := time.Now().Add(3 * time.Second) + for time.Now().Before(deadline) { + if len(r.to(household)) == 1 { + if n, _ := r.notice("vikunja"); n.Told() { + return + } + } + time.Sleep(10 * time.Millisecond) + } + t.Fatalf("no notice within 3 s of the report: %+v", r.all()) +} diff --git a/hub/internal/notify/dispatcher.go b/hub/internal/notify/dispatcher.go index ca7cfe0c..55de44c4 100644 --- a/hub/internal/notify/dispatcher.go +++ b/hub/internal/notify/dispatcher.go @@ -32,9 +32,6 @@ type Dispatcher struct { mu sync.Mutex opCooldowns map[string]time.Time // "customerID:eventType" → last operator notify custCooldowns map[string]time.Time // "customerID:eventType" → last customer notify - // receiptDropDay: per household, the UTC day on which a dropped receipt was last said in the log (once a day). - receiptDropDay map[string]string - // sendEmailFn is the email sender, seam-injected so tests exercise routing without real HTTP. // Defaults to (*Dispatcher).sendEmail (Resend) in NewDispatcher. headers (nil = none) become // Resend custom headers — used for the high-priority nudge on error/critical mails (v0.71.0, @@ -246,11 +243,11 @@ func (d *Dispatcher) processEvent(customerID, eventType, severity, message, mess return } - // D84 (`09` §3 decision 309): a household RECEIPT — the mail that tells the household what it has just pressed. - // Before the severity gate (the event is `info`: nothing is wrong) and with no operator mail: the event row is - // the operator's record. + // D84 + the notice lock (`09` §3 decisions 309 and 315): the household's RECEIPT is NOT sent from the box's + // event. The hub sends it itself, from its own record of the box's reports (api.endNotices → SendEndNotice), + // until it has gone — a lost, repeated or invented event changes nothing. The event row is the operator's record. if householdReceiptEvents[eventType] { - d.processReceipt(customerID, eventType, severity, detailsJSON) + d.logger.Printf("[DEBUG] %s from the box of %s is recorded, not mailed — the hub sends this notice itself from the box's report", eventType, customerID) return } @@ -649,6 +646,8 @@ var perSubjectCooldownEvents = map[string]bool{ // 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, + // the notice lock: one line per app whose notice cannot go out (subject = the app) + "offsite_end_notice_stuck": true, } // cooldownSubjectSuffix returns ":"+subject for an allow-listed type whose details carry a non-empty `subject`. @@ -775,166 +774,6 @@ var recordOnlyEvents = map[string]bool{ "recovery_unit_capture_failed": true, } -// householdReceiptEvents (D84, `09` §3 decision 309) are mails that confirm the household's OWN press of a button -// whose effect comes later and cannot be undone after it. One type today: `offsite_end_scheduled` — the household -// pressed „delete backup data” (or „delete in 30 days”), and the mail names the app, the day the off-site copies are -// deleted and how to take it back. The reviewer's reason, accepted by the operator: the page alone does not warn a -// household whose login someone else uses. -// -// A receipt bypasses the household's group switches (whoever holds the login could switch a group off first) — so it -// is the one household mail a BOX can cause whatever the household chose, and it is built so a box can do nothing -// else with it (review of 2026-11-15; processReceipt): -// - THE HUB WRITES IT. Subject and body come only from the hub's own bundle, with an app name the hub checked -// (the shape of an app name, not reserved) and dates the hub parsed. The box's `message` is never mailed. -// - ONE PER PRESS. The cooldown key is the checked app + the parsed time of the press — not the box's free -// `subject` — so one press delivered twice is one mail, and two apps removed in one hour are two. -// - AT MOST receiptsPerDay PER HOUSEHOLD IN 24 HOURS, counted in the hub's own sent log (it survives a restart). -// The rest are dropped; the hub says so once a day per household. -// - to the household's own notification address by the customer leg's own delivery; never to the operator. -// -// A household with NO address gets no mail — the page is all it has (`07` §8.2f). A blocked household gets none. -// Pinned by TestD84_Receipt*. -var householdReceiptEvents = map[string]bool{ - "offsite_end_scheduled": true, -} - -// receiptsPerDay is the most receipts ONE household is mailed in 24 hours (review of 2026-11-15). -const receiptsPerDay = 5 - -// receiptCooldown: the same press is never mailed twice within this time. -const receiptCooldown = 24 * time.Hour - -// receipt is what the hub accepts of a receipt's details. -type receipt struct { - App string - Removed time.Time - Ends time.Time -} - -// parseReceipt checks a receipt's details. ok=false → nothing is mailed. The app must have the shape of an app name -// and not be reserved (store.ValidPresenceApp / ReservedPresenceApp — the same check the hub's app record uses); the -// two dates must be times, and the end must be after the press and at most 40 days after it. -func parseReceipt(detailsJSON string) (receipt, bool) { - var d struct { - StackName string `json:"stack_name"` - RemovedAt string `json:"removed_at"` - EndsAt string `json:"ends_at"` - } - if detailsJSON == "" || json.Unmarshal([]byte(detailsJSON), &d) != nil { - return receipt{}, false - } - if !store.ValidPresenceApp(d.StackName) || store.ReservedPresenceApp(d.StackName) { - return receipt{}, false - } - removed, err1 := time.Parse(time.RFC3339, d.RemovedAt) - ends, err2 := time.Parse(time.RFC3339, d.EndsAt) - if err1 != nil || err2 != nil || !ends.After(removed) || ends.Sub(removed) > 40*24*time.Hour { - return receipt{}, false - } - return receipt{App: d.StackName, Removed: removed.UTC(), Ends: ends.UTC()}, true -} - -// receiptDate writes a day in the household's date form (the controller's i18n.FormatDate), in Budapest time. -func receiptDate(lang string, t time.Time) string { - if budapest != nil { - t = t.In(budapest) - } - if i18n.Normalize(lang) == "en" { - return t.Format("2006-01-02") - } - return t.Format("2006. 01. 02.") -} - -// FormatReceiptEmail is the receipt's whole text — the hub's own words and the checked details, nothing of the box's. -func FormatReceiptEmail(lang, customerID, eventType, severity string, rc receipt) (string, string) { - b := i18n.Shared() - lang = i18n.Normalize(lang) - sentence := b.Msgf(lang, "mail.receipt."+eventType, rc.App, receiptDate(lang, rc.Ends)) - // The details the frame reads (the app for the headline) are rebuilt from the CHECKED values. - det, _ := json.Marshal(map[string]string{"stack_name": rc.App}) - return FormatCustomerEmail(lang, customerID, eventType, severity, sentence, "", string(det)) -} - -// processReceipt mails ONE receipt to the household, or drops it — see householdReceiptEvents. -func (d *Dispatcher) processReceipt(customerID, eventType, severity, detailsJSON string) { - rc, ok := parseReceipt(detailsJSON) - if !ok { - d.receiptDropped(customerID, eventType, "its details do not name an app and two dates the hub accepts") - return - } - if d.store.IsCustomerBlocked(customerID) { - return - } - prefs, err := d.store.GetNotificationPrefs(customerID) - if err != nil || prefs == nil || prefs.Email == "" { - return // no address: the page is all the household has - } - key := customerID + ":" + eventType + ":" + rc.App + "|" + rc.Removed.Format(time.RFC3339) - now := time.Now() - sentToday, cerr := d.store.CountCustomerSentSince(customerID, eventType, now.Add(-24*time.Hour)) - if cerr != nil { - sentToday = receiptsPerDay // a log that cannot be read is not „nothing sent”: no receipt goes - } - d.mu.Lock() - // The map holds only presses of the last day: older keys of this household's receipts go now. - prefix, inFlight := customerID+":"+eventType+":", 0 - for k, at := range d.custCooldowns { - if strings.HasPrefix(k, prefix) { - if now.Sub(at) >= receiptCooldown { - delete(d.custCooldowns, k) - } else { - inFlight++ - } - } - } - if _, dup := d.custCooldowns[key]; dup { - d.mu.Unlock() - d.logger.Printf("[INFO] Receipt %s for %s/%s skipped — this press was mailed already", eventType, customerID, rc.App) - return - } - // The limit counts what the log says was sent AND what is reserved in memory (a burst is processed faster than - // the log is written). - if sentToday >= receiptsPerDay || inFlight >= receiptsPerDay { - d.mu.Unlock() - d.receiptDropped(customerID, eventType, fmt.Sprintf("the household already got %d receipt(s) in the last 24 hours (the limit)", receiptsPerDay)) - return - } - d.custCooldowns[key] = now - d.mu.Unlock() - - subject, body := FormatReceiptEmail(d.store.CustomerLanguage(customerID), customerID, eventType, severity, rc) - logMsg := eventType + " " + rc.App - if err := d.deliver("customer receipt "+eventType, customerID, prefs.Email, subject, body, priorityHeaders(severity)); isHeld(err) { - d.forgetCustomerCooldown(key) - d.store.LogNotification(customerID, eventType, severity, logMsg, "held", "MAIL-HOLD marker present — dropped", "customer") - return - } else if err != nil { - d.logger.Printf("[ERROR] Receipt %s failed for %s: %v", eventType, customerID, err) - d.store.LogNotification(customerID, eventType, severity, logMsg, "failed", err.Error(), "customer") - return - } - d.logger.Printf("[INFO] Receipt %s sent for %s/%s", eventType, customerID, rc.App) // never the address (R-922) - d.store.LogNotification(customerID, eventType, severity, logMsg, "sent", "", "customer") -} - -// receiptDropped says ONCE per household and day that receipts are being dropped, and why — in the hub's log and as -// one `skipped` row. A box that posts a thousand of them gets one line, not a thousand. -func (d *Dispatcher) receiptDropped(customerID, eventType, why string) { - day := time.Now().UTC().Format("2006-01-02") - d.mu.Lock() - if d.receiptDropDay == nil { - d.receiptDropDay = map[string]string{} - } - already := d.receiptDropDay[customerID] == day - d.receiptDropDay[customerID] = day - d.mu.Unlock() - if already { - return - } - d.logger.Printf("[WARN] Receipt %s from the box of %s was NOT mailed: %s. Further drops for this household are not logged today.", eventType, customerID, why) - d.store.LogNotification(customerID, eventType, "info", eventType, "skipped", "receipt dropped: "+why, "customer") -} - // operatorOnlyEvents are event types that must NEVER reach a customer, whatever their preferences say. // // R-97c. This register exists because the guarantee it provides was previously ASSERTED IN A COMMENT @@ -1044,6 +883,11 @@ var operatorOnlyEvents = map[string]bool{ // 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, + // The notice lock (`09` §3 decision 315): the operator is told IN PLACE of a household that has no usable + // address (that mail starts the app's 30 days), and told once when a notice could not go out for days. + // Hub-origin only: NOT in api.allowedEventTypes. + "offsite_end_notice_operator": true, + "offsite_end_notice_stuck": 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, diff --git a/hub/internal/notify/end_notice.go b/hub/internal/notify/end_notice.go new file mode 100644 index 00000000..180457f6 --- /dev/null +++ b/hub/internal/notify/end_notice.go @@ -0,0 +1,162 @@ +package notify + +import ( + "encoding/json" + "fmt" + "strings" + "time" + + "gitea.dooplex.hu/admin/felhom-hub/internal/i18n" + "gitea.dooplex.hu/admin/felhom-hub/internal/store" +) + +// householdReceiptEvents (D84, `09` §3 decision 309) are mails that tell the household about its OWN press of a button +// whose effect comes later and cannot be undone after it. One type today: `offsite_end_scheduled` — the household +// pressed „delete backup data” (or „delete in 30 days”), and the mail names the app, the day from which the off-site +// copies are deleted, how to take it back, and what to do if somebody else pressed it. The reviewer's reason, +// accepted by the operator: the page alone does not warn a household whose login someone else uses. +// +// THE NOTICE LOCK (`09` §3 decision 315; `07-backup-architecture.md` §8.2f): the mail is a CONDITION of the deletion, +// so it is not sent from the box's event (an event is lost when the hub is away for nine seconds — R-1361 — and a +// failed send was never tried again). The hub sends it from its own state: api.endNotices calls SendEndNotice for +// every app its record (store.offsite_end_notices) says is named in a report and not told, at every report, until the +// mail service accepts it; only then does the record say „told”, and only 30 days after that does the hub agree. +// +// A receipt bypasses the household's group switches (whoever holds the login could switch a group off first), so it +// is built so that a box can do nothing else with it: +// - THE HUB WRITES IT. Subject and body come only from the hub's own bundle, with an app name the hub checked +// (the shape of an app name, not reserved) and a day the hub computed from its own clock. Nothing of the box's. +// - AT MOST receiptsPerDay PER HOUSEHOLD IN 24 HOURS, counted in the hub's own sent log (it survives a restart). +// The limit DELAYS a notice — the record stays „not told” and the next report tries again — it never drops one. +// - to the household's own notification address; never to the operator. +// +// A household with no address, or a blocked one, gets no mail: the caller then tells the operator in its place +// (`offsite_end_notice_operator`), and sends the household's mail when an address appears. Pinned by TestNotice_*. +var householdReceiptEvents = map[string]bool{ + "offsite_end_scheduled": true, +} + +// EndNoticeEvent is the type the household's notice is logged and counted under. +const EndNoticeEvent = "offsite_end_scheduled" + +// receiptsPerDay is the most receipts ONE household is mailed in 24 hours (review of 2026-11-15). +const receiptsPerDay = 5 + +// EndNoticeOutcome is what one try of the household's notice came to. Only EndNoticeSent tells the household. +type EndNoticeOutcome string + +const ( + EndNoticeSent EndNoticeOutcome = "sent" + EndNoticeNoAddress EndNoticeOutcome = "no-address" // no notification address, or the household is blocked + EndNoticeLimit EndNoticeOutcome = "limit" // the household's daily limit: later + EndNoticeHeld EndNoticeOutcome = "held" // the MAIL-HOLD marker + EndNoticeFailed EndNoticeOutcome = "failed" // the mail service did not accept it, or is not configured +) + +// receiptDate writes a day in the household's date form (the controller's i18n.FormatDate), in Budapest time. +func receiptDate(lang string, t time.Time) string { + if budapest != nil { + t = t.In(budapest) + } + if i18n.Normalize(lang) == "en" { + return t.Format("2006-01-02") + } + return t.Format("2006. 01. 02.") +} + +// FormatReceiptEmail is the receipt's whole text — the hub's own words, a checked app name and the hub's own day. +// The household mail frame with the hub's sentence as the message line (FormatCustomerEmail). +func FormatReceiptEmail(lang, customerID, eventType, severity, app string, ends time.Time) (string, string) { + b := i18n.Shared() + lang = i18n.Normalize(lang) + day := receiptDate(lang, ends) + sentence := b.Msgf(lang, "mail.receipt."+eventType, app, day) + // The details the frame reads (the app for the headline) are rebuilt from the CHECKED value. + det, _ := json.Marshal(map[string]string{"stack_name": app}) + return FormatCustomerEmail(lang, customerID, eventType, severity, sentence, "", string(det)) +} + +// MailHeld reports whether the hub-wide mail hold is on (no mail of any kind goes out). +func (d *Dispatcher) MailHeld() bool { return d.mailHold.Held() } + +// SendEndNotice tries ONCE to mail the household that the off-site copies of `app` are deleted from the day `ends` +// (the hub's own day: the caller passes its clock + 30 days). It returns what the try came to and, when nobody was +// told, the hub's own words for why. It keeps no state: the caller's record decides whether there is a next try. +// app must have passed store.ValidPresenceApp; a name that has not is refused here again. +func (d *Dispatcher) SendEndNotice(customerID, app string, ends time.Time) (EndNoticeOutcome, string) { + if !store.ValidPresenceApp(app) || store.ReservedPresenceApp(app) { + return EndNoticeFailed, "not an app name" + } + if d.resendAPIKey == "" { + return EndNoticeFailed, "the hub has no mail service configured" + } + if d.store.IsCustomerBlocked(customerID) { + return EndNoticeNoAddress, "the household is blocked" + } + prefs, err := d.store.GetNotificationPrefs(customerID) + if err != nil { + return EndNoticeFailed, "the household's notification address could not be read" + } + if prefs == nil || strings.TrimSpace(prefs.Email) == "" { + return EndNoticeNoAddress, "the household has no notification address" + } + now := time.Now() + sentToday, cerr := d.store.CountCustomerSentSince(customerID, EndNoticeEvent, now.Add(-24*time.Hour)) + if cerr != nil { + // A log that cannot be read is not „nothing sent”: no receipt goes, and the notice stays to be tried again. + return EndNoticeLimit, "the hub's sent log could not be read" + } + if sentToday >= receiptsPerDay { + return EndNoticeLimit, fmt.Sprintf("the household already got %d of these notices in the last 24 hours (the daily limit) — this one goes later", receiptsPerDay) + } + subject, body := FormatReceiptEmail(d.store.CustomerLanguage(customerID), customerID, EndNoticeEvent, "info", app, ends) + logMsg := EndNoticeEvent + " " + app + if err := d.deliver("customer receipt "+EndNoticeEvent, customerID, strings.TrimSpace(prefs.Email), subject, body, nil); isHeld(err) { + d.store.LogNotification(customerID, EndNoticeEvent, "info", logMsg, "held", "MAIL-HOLD marker present — not sent; the notice stays to be sent", "customer") + return EndNoticeHeld, "the hub is not sending mail (the MAIL-HOLD marker is present)" + } else if err != nil { + d.logger.Printf("[ERROR] Notice %s failed for %s/%s: %v — it stays to be sent", EndNoticeEvent, customerID, app, err) + d.store.LogNotification(customerID, EndNoticeEvent, "info", logMsg, "failed", err.Error(), "customer") + return EndNoticeFailed, "the mail service did not accept the mail" + } + d.logger.Printf("[INFO] Notice %s sent for %s/%s", EndNoticeEvent, customerID, app) // never the address (R-922) + if lerr := d.store.LogNotification(customerID, EndNoticeEvent, "info", logMsg, "sent", "", "customer"); lerr != nil { + d.logger.Printf("[WARN] Notice %s for %s/%s was sent, but the sent log could not be written: %v", EndNoticeEvent, customerID, app, lerr) + } + return EndNoticeSent, "" +} + +// SendOperatorNow mails the operator ONE hub-made event and returns only when the mail service has answered: nil +// means it accepted the mail. For an operator mail whose DELIVERY is a condition of something else (the notice that +// starts an app's 30 days when the household has no address) — the ordinary operator path (processOperator) answers +// at once and retries in the background, so its caller cannot know. No cooldown: the caller's own record tells each +// thing once. The event type must be operator-only. +func (d *Dispatcher) SendOperatorNow(customerID, eventType, severity, message, detailsJSON string) error { + if !operatorOnlyEvents[eventType] { + return fmt.Errorf("notify: %s is not an operator-only type", eventType) + } + if d.resendAPIKey == "" { + return fmt.Errorf("the hub has no mail service configured") + } + if !d.operatorOn || d.operatorEmail == "" { + return fmt.Errorf("the operator's mail is switched off") + } + subject, body := FormatOperatorEmail(customerID, eventType, severity, message, detailsJSON) + if err := d.deliver("operator mail "+eventType, "operator", d.operatorEmail, subject, body, priorityHeaders(severity)); isHeld(err) { + d.store.LogNotification(customerID, eventType, severity, message, "held", "MAIL-HOLD marker present — not sent", "operator") + return err + } else if err != nil { + d.logger.Printf("[ERROR] Operator email failed for %s/%s: %v", customerID, eventType, err) + d.store.LogNotification(customerID, eventType, severity, message, "failed", err.Error(), "operator") + return err + } + d.logger.Printf("[INFO] Operator email sent for %s/%s", customerID, eventType) + d.store.LogNotification(customerID, eventType, severity, message, "sent", "", "operator") + return nil +} + +// SetSendFnForTest replaces the function that hands a mail to the mail service. TEST-ONLY: it lets a test in another +// package (api.endNotices) see every mail and fail a send, with no call to the real service. +func (d *Dispatcher) SetSendFnForTest(fn func(to, subject, body string, headers map[string]string) error) { + d.sendEmailFn = fn +} diff --git a/hub/internal/notify/end_notice_test.go b/hub/internal/notify/end_notice_test.go new file mode 100644 index 00000000..e5bc3556 --- /dev/null +++ b/hub/internal/notify/end_notice_test.go @@ -0,0 +1,262 @@ +package notify + +import ( + "errors" + "fmt" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "gitea.dooplex.hu/admin/felhom-hub/internal/mailhold" +) + +// THE NOTICE LOCK, the mail's half (`09` §3 decisions 315 and 316; `07-backup-architecture.md` §8.2f). The household's +// notice is sent by the hub from its own state (SendEndNotice, called by api.endNotices) — never from the box's event. +// These tests replace TestD84_Receipt_* of the first build, whose mail left from the event. +// RED-PROOFS: documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-mail.txt. + +type receiptMail struct{ to, subject, body string } + +func receiptDispatcher(t *testing.T, prefsEmail string, enabled []string) (*Dispatcher, *[]receiptMail) { + t.Helper() + st := opOnlyStore(t) + if prefsEmail != "" || enabled != nil { + if err := st.SaveNotificationPrefs("c1", prefsEmail, enabled, 6); err != nil { + t.Fatal(err) + } + } + d := opOnlyDispatcher(t, st, &sentTo{}) + var mails []receiptMail + d.sendEmailFn = func(to, subject, body string, _ map[string]string) error { + mails = append(mails, receiptMail{to, subject, body}) + return nil + } + return d, &mails +} + +// noticeDay: 2026-12-15 12:00 UTC — the same calendar day in Budapest. +var noticeDay = time.Date(2026, 12, 15, 12, 0, 0, 0, time.UTC) + +const receiptDetails = `{"stack_name":"vikunja","removed_at":"2026-11-15T10:00:00Z","ends_at":"2026-12-15T10:00:00Z","subject":"vikunja|2026-11-15T10:00:00Z"}` + +// The notice reaches the household's own address although EVERY group switch is off. Its subject names the deletion +// and its day (not „Information”); its body names the day, the way back, and what to do if the household did not ask +// for this. The operator is not mailed, and no raw details are in it. +func TestNotice_ReachesTheHouseholdWhateverItsSwitches(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", []string{}) + if out, why := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeSent { + t.Fatalf("outcome = %s (%s), want sent", out, why) + } + if len(*mails) != 1 { + t.Fatalf("mails = %d, want exactly one (to the household): %+v", len(*mails), *mails) + } + m := (*mails)[0] + if m.to != "customer@example.com" { + t.Fatalf("the notice went to %q, not to the household's own address", m.to) + } + if !strings.Contains(m.subject, "vikunja: a távoli másolatok törlésre kijelölve") { + t.Fatalf("the subject does not name the app: %q", m.subject) + } + for _, want := range []string{"Törlésük napja: 2026. 12. 15. Addig", "Mégis megtartom", "Mentések oldalon"} { + if !strings.Contains(m.body, want) { + t.Fatalf("the body lacks %q:\n%s", want, m.body) + } + } + if strings.Contains(m.body, "removed_at") || strings.Contains(m.body, "{") { + t.Fatalf("the body carries raw details:\n%s", m.body) + } + // the hub's own sent log holds it (the daily limit counts there) + if n, err := d.store.CountCustomerSentSince("c1", EndNoticeEvent, time.Now().Add(-time.Hour)); err != nil || n != 1 { + t.Fatalf("sent log rows = %d (%v), want 1", n, err) + } +} + +// An English household reads it in English, with the English date form. +func TestNotice_FollowsTheHouseholdsLanguage(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", nil) + if err := d.store.SaveReport("c1", []byte(`{"customer_id":"c1","language":"en"}`)); err != nil { + t.Fatal(err) + } + if out, _ := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeSent || len(*mails) != 1 { + t.Fatalf("outcome %s, mails %d", out, len(*mails)) + } + m := (*mails)[0] + if !strings.Contains(m.subject, "vikunja: the off-site copies are marked for deletion") { + t.Fatalf("not the English subject: %q", m.subject) + } + for _, want := range []string{"They are deleted on: 2026-12-15.", "Keep it after all"} { + if !strings.Contains(m.body, want) { + t.Fatalf("the English body lacks %q:\n%s", want, m.body) + } + } + if strings.Contains(m.body, "Mégis megtartom") { + t.Fatalf("Hungarian in an English household's mail:\n%s", m.body) + } +} + +// THE BOX'S EVENT MAILS NOBODY — whether it arrives once, twice, with invented words or never. (The wrong cases „the +// event never arrives” and „it arrives twice”: the notice does not depend on it.) +func TestNotice_TheBoxesEventMailsNobody(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", []string{}) + evil := "ANY WORDS THE BOX CHOOSES: pay at http://evil.example" + d.ProcessBoxEvent("c1", "offsite_end_scheduled", "info", "x", "", receiptDetails, "controller") + d.ProcessBoxEvent("c1", "offsite_end_scheduled", "info", "x", "", receiptDetails, "controller") + for i := 0; i < 50; i++ { + d.ProcessBoxEvent("c1", "offsite_end_scheduled", "warning", evil, evil, + fmt.Sprintf(`{"stack_name":"app-%d","removed_at":"2026-11-15T10:00:00Z","ends_at":"2026-12-15T10:00:00Z"}`, i), "controller") + } + if len(*mails) != 0 { + t.Fatalf("the box's event caused %d mail(s); first: %+v", len(*mails), (*mails)[0]) + } + // positive control: the same dispatcher does mail an ordinary event of the box + if err := d.store.SaveNotificationPrefs("c1", "customer@example.com", []string{"app_stopped_unhealthy"}, 6); err != nil { + t.Fatal(err) + } + d.ProcessBoxEvent("c1", "app_stopped_unhealthy", "error", "x", "", `{"stack_name":"vikunja"}`, "controller") + if len(*mails) == 0 { + t.Fatal("control: the dispatcher mails nothing at all — the test above proves nothing") + } +} + +// A household with no address, and a blocked one: nobody is mailed here, and the outcome says „no address” so that +// the caller tells the operator in its place. +func TestNotice_NoAddressOrBlocked_SaysSoAndMailsNobody(t *testing.T) { + d, mails := receiptDispatcher(t, "", nil) + if out, _ := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeNoAddress || len(*mails) != 0 { + t.Fatalf("no address: outcome %s, %d mail(s)", out, len(*mails)) + } + d, mails = receiptDispatcher(t, "customer@example.com", nil) + if err := d.store.SetCustomerConfigStatus("c1", "blocked"); err != nil { + t.Fatal(err) + } + if out, _ := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeNoAddress || len(*mails) != 0 { + t.Fatalf("blocked: outcome %s, %d mail(s)", out, len(*mails)) + } + if err := d.store.SetCustomerConfigStatus("c1", "active"); err != nil { + t.Fatal(err) + } + if out, _ := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeSent || len(*mails) != 1 { + t.Fatalf("positive control: an unblocked household must get the notice: outcome %s, %d mail(s)", out, len(*mails)) + } +} + +// The daily limit DELAYS: the sixth notice of 24 hours is not sent and says „limit”; a hub restart (a new dispatcher +// on the same store) does not give five more; a day later it goes. +func TestNotice_TheDailyLimitDelaysAndSurvivesARestart(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", nil) + for i := 0; i < receiptsPerDay; i++ { + if out, why := d.SendEndNotice("c1", fmt.Sprintf("app-%d", i), noticeDay); out != EndNoticeSent { + t.Fatalf("notice %d: %s (%s)", i, out, why) + } + } + if out, why := d.SendEndNotice("c1", "one-more", noticeDay); out != EndNoticeLimit || !strings.Contains(why, "later") { + t.Fatalf("the sixth notice: outcome %s (%q), want limit", out, why) + } + d2 := opOnlyDispatcher(t, d.store, &sentTo{}) // the restart: nothing in memory + n2 := 0 + d2.sendEmailFn = func(string, string, string, map[string]string) error { n2++; return nil } + if out, _ := d2.SendEndNotice("c1", "one-more", noticeDay); out != EndNoticeLimit || n2 != 0 { + t.Fatalf("after a restart: outcome %s, %d mail(s) — the limit must be the hub's sent log", out, n2) + } + if len(*mails) != receiptsPerDay { + t.Fatalf("mails = %d, want %d", len(*mails), receiptsPerDay) + } + // a day later the log's rows are older than 24 hours: the delayed notice goes + if err := d.store.BackdateNotificationLogForTest("c1", 25*time.Hour); err != nil { + t.Fatal(err) + } + if out, why := d.SendEndNotice("c1", "one-more", noticeDay); out != EndNoticeSent { + t.Fatalf("a day later: %s (%s), want sent — the limit delays, it does not drop", out, why) + } +} + +// The mail hold and a failed send tell nobody, and say which it was. +func TestNotice_HeldOrFailed_IsNotSent(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", nil) + dir := t.TempDir() + if err := os.WriteFile(filepath.Join(dir, mailhold.FileName), nil, 0o644); err != nil { + t.Fatal(err) + } + d.SetMailHold(mailhold.New(dir, nil)) + if out, why := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeHeld || !strings.Contains(why, "MAIL-HOLD") || len(*mails) != 0 { + t.Fatalf("held: outcome %s (%q), %d mail(s)", out, why, len(*mails)) + } + if !d.MailHeld() { + t.Fatal("MailHeld() = false with the marker present") + } + d.SetMailHold(nil) + d.sendEmailFn = func(string, string, string, map[string]string) error { return errors.New("resend: 503") } + if out, _ := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeFailed { + t.Fatalf("failed send: outcome %s", out) + } + // neither left a „sent” row: the limit must not count a mail that did not go + if n, _ := d.store.CountCustomerSentSince("c1", EndNoticeEvent, time.Now().Add(-time.Hour)); n != 0 { + t.Fatalf("sent rows after a held and a failed try: %d", n) + } + // no mail service at all + d.resendAPIKey = "" + if out, _ := d.SendEndNotice("c1", "vikunja", noticeDay); out != EndNoticeFailed { + t.Fatalf("no mail service: outcome %s", out) + } +} + +// A name that is not an app name never reaches a mail. +func TestNotice_OnlyAnAppNameIsMailed(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", nil) + for _, app := range []string{"", "pay now at evil.example", "x", "traefik", "_shares", strings.Repeat("a", 65)} { + if out, _ := d.SendEndNotice("c1", app, noticeDay); out == EndNoticeSent || len(*mails) != 0 { + t.Fatalf("%q: outcome %s, %d mail(s)", app, out, len(*mails)) + } + } +} + +// The receipt register does not open any other type: an ordinary info event still mails nobody, and a type the +// household switched off still stays off. +func TestD84_Receipt_OpensNothingElse(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", []string{}) + d.ProcessBoxEvent("c1", "app_removed", "info", "Alkalmazás eltávolítva.", "", `{"stack_name":"vikunja"}`, "controller") + d.ProcessBoxEvent("c1", "app_stopped_unhealthy", "error", "x", "", `{"stack_name":"vikunja"}`, "controller") + for _, m := range *mails { + if m.to == "customer@example.com" { + t.Fatalf("the household was mailed a type it switched off / an info event: %+v", m) + } + } + if len(householdReceiptEvents) != 1 || !householdReceiptEvents["offsite_end_scheduled"] { + t.Fatalf("the receipt register changed: %v — every entry bypasses the household's switches and needs its own ruling", householdReceiptEvents) + } + if operatorOnlyEvents["offsite_end_scheduled"] { + t.Fatal("a receipt cannot be operator-only") + } +} + +// SendOperatorNow answers only when the mail service has: nil = accepted. It refuses a type a household could get. +func TestNotice_SendOperatorNow(t *testing.T) { + d, mails := receiptDispatcher(t, "customer@example.com", nil) + if err := d.SendOperatorNow("c1", "offsite_end_notice_operator", "warning", "m", `{"subject":"vikunja"}`); err != nil || len(*mails) != 1 { + t.Fatalf("err=%v mails=%d", err, len(*mails)) + } + if (*mails)[0].to != "operator@felhom.eu" { + t.Fatalf("went to %q", (*mails)[0].to) + } + if err := d.SendOperatorNow("c1", "app_stopped_unhealthy", "warning", "m", ""); err == nil { + t.Fatal("a type that is not operator-only was accepted") + } + d.sendEmailFn = func(string, string, string, map[string]string) error { return errors.New("resend: 503") } + if err := d.SendOperatorNow("c1", "offsite_end_notice_operator", "warning", "m", ""); err == nil { + t.Fatal("a failed send answered nil — the caller would start the 30 days on a mail that never went") + } + d.operatorOn = false + if err := d.SendOperatorNow("c1", "offsite_end_notice_operator", "warning", "m", ""); err == nil { + t.Fatal("the operator's mail is off, and the call answered nil") + } + for _, typ := range []string{"offsite_end_notice_operator", "offsite_end_notice_stuck"} { + if !IsOperatorOnly(typ) { + t.Fatalf("%s must be operator-only", typ) + } + } + if !HasPerSubjectCooldown("offsite_end_notice_stuck") { + t.Fatal("offsite_end_notice_stuck: two apps stuck in one hour must be two mails") + } +} diff --git a/hub/internal/notify/mail_golden_test.go b/hub/internal/notify/mail_golden_test.go index 8439f84c..774f1d33 100644 --- a/hub/internal/notify/mail_golden_test.go +++ b/hub/internal/notify/mail_golden_test.go @@ -96,15 +96,9 @@ func customerMailCases(lang string) []mailCase { }, mailCase{ name: "customer_shape_offsite_end_scheduled_receipt", - comment: "D84: the household's receipt — the entry names the app, the box's sentence is the line, no raw details", + comment: "D84 + decision 315: the household's notice as the hub sends it — the entry names the app, the hub's sentence is the line, no raw details", render: func() (string, string) { - box := "vikunja: az alkalmazás távoli másolatai törlésre vannak kijelölve. Törlésük napja: 2026. 12. 15. Addig a Mentések oldalon a „Mégis megtartom” gombbal visszavonhatod." - household := "" - if lang == "en" { - household = "vikunja: the off-site copies of this app are marked for deletion. They are deleted on: 2026-12-15. Until then you can take this back on the Backups page with the “Keep it after all” button." - } - return FormatCustomerEmail(lang, "demo-fixture", "offsite_end_scheduled", "info", box, household, - `{"stack_name":"vikunja","removed_at":"2026-11-15T10:00:00Z","ends_at":"2026-12-15T10:00:00Z","subject":"vikunja|2026-11-15T10:00:00Z"}`) + return FormatReceiptEmail(lang, "demo-fixture", "offsite_end_scheduled", "info", "vikunja", time.Date(2026, 12, 15, 12, 0, 0, 0, time.UTC)) }, }, mailCase{ diff --git a/hub/internal/notify/templates.go b/hub/internal/notify/templates.go index 62839f80..9f78d87c 100644 --- a/hub/internal/notify/templates.go +++ b/hub/internal/notify/templates.go @@ -482,7 +482,7 @@ var appNamedMailEvents = map[string]bool{ "app_update_held": true, // v0.123.0 (`09` §3 decision 28): the box stopped an app that kept crashing / ran out of memory. "app_stopped_unhealthy": true, - // D84: the receipt's headline names the app; the box's own sentence (the day, and how to take it back) follows. + // D84: the receipt's headline names the app; the hub's own sentence (the day, and how to take it back) follows. "offsite_end_scheduled": true, } diff --git a/hub/internal/notify/testdata/mail_goldens/en/customer_shape_offsite_end_scheduled_receipt.txt b/hub/internal/notify/testdata/mail_goldens/en/customer_shape_offsite_end_scheduled_receipt.txt index ab45c02d..4115c23c 100644 --- a/hub/internal/notify/testdata/mail_goldens/en/customer_shape_offsite_end_scheduled_receipt.txt +++ b/hub/internal/notify/testdata/mail_goldens/en/customer_shape_offsite_end_scheduled_receipt.txt @@ -1,4 +1,4 @@ -# D84: the household's receipt — the entry names the app, the box's sentence is the line, no raw details +# D84 + decision 315: the household's notice as the hub sends it — the entry names the app, the hub's sentence is the line, no raw details SUBJECT: [Felhom] Information: vikunja: the off-site copies are marked for deletion --- Dear Customer, diff --git a/hub/internal/notify/testdata/mail_goldens/hu/customer_shape_offsite_end_scheduled_receipt.txt b/hub/internal/notify/testdata/mail_goldens/hu/customer_shape_offsite_end_scheduled_receipt.txt index 06822b34..77e14782 100644 --- a/hub/internal/notify/testdata/mail_goldens/hu/customer_shape_offsite_end_scheduled_receipt.txt +++ b/hub/internal/notify/testdata/mail_goldens/hu/customer_shape_offsite_end_scheduled_receipt.txt @@ -1,4 +1,4 @@ -# D84: the household's receipt — the entry names the app, the box's sentence is the line, no raw details +# D84 + decision 315: the household's notice as the hub sends it — the entry names the app, the hub's sentence is the line, no raw details SUBJECT: [Felhom] Információ: vikunja: a távoli másolatok törlésre kijelölve --- Kedves Ügyfél! diff --git a/hub/internal/offsitekeys/ended.go b/hub/internal/offsitekeys/ended.go index f8e1e78f..e3527c8f 100644 --- a/hub/internal/offsitekeys/ended.go +++ b/hub/internal/offsitekeys/ended.go @@ -20,6 +20,11 @@ import ( // 1. THE APP. The hub's own record (store.AppPresences, written from the box's reports by the hub's clock) must say // the app has been absent from that box's app list for EndedAppAfter. An app the newest report lists, an app the // hub has no record of, an app absent for a shorter time and a reserved name are refused, each with its reason. +// 1b. THE NOTICE (`09` §3 decision 315 — „no notice, no deletion”). The hub's own record (store.EndNotices, written +// only by the hub when its mail service accepted the mail) must say the household — or, for a household with no +// usable address, the operator — was told about THIS press EndedAppAfter ago, by the hub's clock. Beside the 30 +// days of absence, not in place of them. No record, a record not told, a record told later: refused, with the +// reason. So an app a box names only in a window request (never in a report) is never agreed. // 2. THE ID. A snapshot id is agreed only when the hub's own listing of the repository (the 07:10 audit's stored // baseline — names and upload times, read over the hub's own login) holds it AND shows it uploaded no later than // the moment the hub first saw the app absent. An app that is gone makes no new snapshots, so a younger file can @@ -39,6 +44,9 @@ const ( // 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 + // The notice lock (`09` §3 decision 315) — two operator warnings, both mailed, both hub-made (api/end_notice.go): + EventEndNoticeOperator = "offsite_end_notice_operator" // told in place of a household with no usable address + EventEndNoticeStuck = "offsite_end_notice_stuck" // a notice has told nobody for three days // 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). @@ -67,7 +75,7 @@ func reservedEndedName(app string) bool { // agreeEnded is the PURE decision. presence is the hub's own record; listing the hub's own stored listing (ok=false // when there is none). It returns the agreed ids (sorted), the agreed ids per agreed app, and every refusal. -func agreeEnded(now time.Time, presence map[string]store.AppPresence, listing store.OffsiteSnapshotListing, haveListing bool, claims []EndedClaim) (ids []string, byApp map[string][]string, refused []store.EndedRefusal) { +func agreeEnded(now time.Time, presence map[string]store.AppPresence, notices map[string]store.EndNotice, listing store.OffsiteSnapshotListing, haveListing bool, claims []EndedClaim) (ids []string, byApp map[string][]string, refused []store.EndedRefusal) { if len(claims) > maxEndedClaims { for _, c := range claims[maxEndedClaims:] { refused = append(refused, store.EndedRefusal{App: ledgerName(c.App), Reason: fmt.Sprintf("more than %d apps in one request", maxEndedClaims)}) @@ -97,6 +105,9 @@ func agreeEnded(now time.Time, presence map[string]store.AppPresence, listing st reason = fmt.Sprintf("the hub has seen the app absent since %s — %d full day(s), %d needed", p.AbsentSince.UTC().Format("2006-01-02 15:04 UTC"), int(now.Sub(p.AbsentSince).Hours()/24), int(EndedAppAfter.Hours()/24)) } + if reason == "" { + reason = untoldReason(now, notices, c.App) + } if reason != "" { refusedApp[c.App] = true // A claimed name that has not the shape of an app name is the box's free text: it is never written @@ -185,14 +196,47 @@ func agreeEnded(now time.Time, presence map[string]store.AppPresence, listing st return ids, byApp, refused } +// untoldReason is the notice lock's half of the decision: "" when the hub's own record says the household (or the +// operator in its place) was told about this app EndedAppAfter ago; else the reason, in the hub's own words. +func untoldReason(now time.Time, notices map[string]store.EndNotice, app string) string { + n, ok := notices[app] + switch { + case !ok: + return reasonNoNotice + case !n.Told(): + why := n.LastReason + if why == "" { + why = "the notice has not been sent yet" + } + return "the household has not been told yet, so nothing is removed: " + why + case now.Sub(n.ToldAt) < EndedAppAfter: + who := "the household was" + if n.ToldTo == store.EndNoticeOperator { + who = "the operator (the household has no usable address) was" + } + return fmt.Sprintf("%s told on %s — %d full day(s), %d needed", + who, n.ToldAt.UTC().Format("2006-01-02 15:04 UTC"), int(now.Sub(n.ToldAt).Hours()/24), int(EndedAppAfter.Hours()/24)) + } + return "" +} + +const reasonNoNotice = "the hub has no record that the household was told: no report of the box names this app in a pending end record" + // clearDisagreement: a refusal the operator must hear about. A box that asks a little early (its clock is minutes or // hours ahead of the hub's first sight of the absence) is refused quietly and asks again next week; a box that claims // an end for an app it reports as installed, or that the hub has seen absent for less than 29 days, is not a matter of // minutes — its clock is wrong by a day or more (R-1384), or it is not telling the truth. +// +// The notice lock adds one clear case: the box asks for an app whose absence is old enough, and NO report of it ever +// named the app in a pending end record (an honest box names it in every report). A notice that is only not sent +// yet, or not 30 days old, is quiet here — the operator's line for that is `offsite_end_notice_stuck`. func clearDisagreement(now time.Time, presence map[string]store.AppPresence, r store.EndedRefusal) bool { if r.App == "" { return false } + if r.Reason == reasonNoNotice { + return true + } p, known := presence[r.App] // An installed app has no absence date (store.AppPresences), so the zero date covers it too. if !known || p.AbsentSince.IsZero() { @@ -216,8 +260,17 @@ func (s *Service) agreeEndedFor(customerID string, windowID int64, maxRemove int } return nil, nil, refused } + // The notice lock: a record that cannot be read is „nobody was told” — nothing agreed. + notices, nerr := s.Store.EndNotices(customerID) + if nerr != nil { + s.logf("[WARN] offsitekeys: ended apps %s: the hub's own notice record could not be read (%v) — nothing agreed", customerID, nerr) + for _, c := range claims { + refused = append(refused, store.EndedRefusal{App: ledgerName(c.App), Reason: "the hub's own notice record could not be read"}) + } + return nil, nil, refused + } listing, have := s.Store.GetOffsiteSnapshotListing(customerID) - ids, byApp, refused = agreeEnded(now, presence, listing, have, claims) + ids, byApp, refused = agreeEnded(now, presence, notices, 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: // diff --git a/hub/internal/offsitekeys/ended_bound_test.go b/hub/internal/offsitekeys/ended_bound_test.go index 1cdf26ff..49d2ffef 100644 --- a/hub/internal/offsitekeys/ended_bound_test.go +++ b/hub/internal/offsitekeys/ended_bound_test.go @@ -38,6 +38,7 @@ func ghostFixture(t *testing.T) (*Service, *[]evt, []string) { if err := s.Store.NoteAppList("c1", []string{"immich"}, []string{"ghost"}, now.Add(-time.Hour)); err != nil { t.Fatal(err) } + toldLongAgo(t, s, "ghost") *events = nil return s, events, all } @@ -133,6 +134,7 @@ 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)) + toldLongAgo(t, s, "second") 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) diff --git a/hub/internal/offsitekeys/ended_large_marker_test.go b/hub/internal/offsitekeys/ended_large_marker_test.go index 135d1187..2711e95d 100644 --- a/hub/internal/offsitekeys/ended_large_marker_test.go +++ b/hub/internal/offsitekeys/ended_large_marker_test.go @@ -96,6 +96,7 @@ func TestD84_TwoAppSetsThatDifferAfterTheTenthNameDoNotShareAWait(t *testing.T) if err := s.Store.NoteAppList("c1", []string{"immich"}, names, now.Add(-31*24*time.Hour)); err != nil { t.Fatal(err) } + toldLongAgo(t, s, names...) set := func(last string) []EndedClaim { var cl []EndedClaim for i := 0; i < 10; i++ { diff --git a/hub/internal/offsitekeys/ended_test.go b/hub/internal/offsitekeys/ended_test.go index fee33bca..3cb8106b 100644 --- a/hub/internal/offsitekeys/ended_test.go +++ b/hub/internal/offsitekeys/ended_test.go @@ -105,7 +105,12 @@ func TestD84_AgreeEnded_TheHubsOwnRecordsDecide(t *testing.T) { } for _, c := range cases { t.Run(c.name, func(t *testing.T) { - ids, byApp, refused := agreeEnded(now, c.presence, listing, c.listing, c.claims) + // the notice lock is not this table's subject: every claimed app was told 31 days ago (TestNotice_* pin it) + notices := map[string]store.EndNotice{} + for _, cl := range c.claims { + notices[cl.App] = store.EndNotice{App: cl.App, ToldAt: days(31), ToldTo: store.EndNoticeHousehold} + } + ids, byApp, refused := agreeEnded(now, c.presence, notices, listing, c.listing, c.claims) if strings.Join(ids, ",") != strings.Join(c.wantIDs, ",") { t.Fatalf("agreed ids = %v, want %v (refused: %+v)", shortIDs(ids), shortIDs(c.wantIDs), refused) } @@ -147,9 +152,22 @@ func endedFixture(t *testing.T) (*Service, *[]evt) { if err := s.Store.NoteAppList("c1", []string{"immich"}, nil, now.Add(-31*24*time.Hour)); err != nil { t.Fatal(err) } + toldLongAgo(t, s, "vikunja") return s, events } +// toldLongAgo writes the hub's own notice record for apps as told to the household 31 days ago (the notice lock is +// pinned by TestNotice_*; the D84 tests are about the other conditions). +func toldLongAgo(t *testing.T, s *Service, apps ...string) { + t.Helper() + at := time.Now().UTC().Add(-31 * 24 * time.Hour) + for _, app := range apps { + if err := s.Store.SetEndNoticeForTest("c1", app, "", at, at, store.EndNoticeHousehold); err != nil { + t.Fatal(err) + } + } +} + func openGranted(t *testing.T, s *Service, count int, ended ...EndedClaim) WindowGrant { t.Helper() if err := s.Store.GrantOffsiteWindowOnce("c1"); err != nil { @@ -231,6 +249,7 @@ func TestD84_Window_ARefusalTellsTheOperatorOnlyWhenItIsClear(t *testing.T) { _ = s.Store.NoteAppList("c1", []string{"immich", "kimai", "nearly"}, nil, now.Add(-80*24*time.Hour)) _ = s.Store.NoteAppList("c1", []string{"immich", "kimai"}, nil, now.Add(-EndedAppAfter+time.Hour)) _ = s.Store.NoteAppList("c1", []string{"immich"}, nil, now.Add(-2*24*time.Hour)) + toldLongAgo(t, s, "kimai", "nearly", "immich") g := openGranted(t, s, 20, EndedClaim{App: "kimai", EndsAt: now.Add(-time.Hour).Format(time.RFC3339), SnapshotIDs: []string{eid(1)}}, EndedClaim{App: "nearly", SnapshotIDs: []string{eid(2)}}, diff --git a/hub/internal/offsitekeys/notice_lock_test.go b/hub/internal/offsitekeys/notice_lock_test.go new file mode 100644 index 00000000..b7ccd4d3 --- /dev/null +++ b/hub/internal/offsitekeys/notice_lock_test.go @@ -0,0 +1,149 @@ +package offsitekeys + +import ( + "strings" + "testing" + "time" + + "gitea.dooplex.hu/admin/felhom-hub/internal/store" +) + +// THE NOTICE LOCK, the agreement's half (`09` §3 decision 315; `07-backup-architecture.md` §8.2f): the hub agrees to +// an app only when ITS OWN record says the household was told at least 30 days ago — beside the 30 days of absence. +// RED-PROOFS: documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-agree.txt. + +// The pure decision. In every row the app has been absent for 40 days and its file is 60 days old: without the +// notice lock every row would be agreed. +func TestNotice_AgreeEnded_NoNoticeNoDeletion(t *testing.T) { + now := time.Date(2026, 12, 20, 3, 0, 0, 0, time.UTC) + days := func(n int) time.Time { return now.Add(-time.Duration(n) * 24 * time.Hour) } + listing := store.OffsiteSnapshotListing{ListedAt: now.Add(-20 * time.Hour), Entries: map[string]time.Time{eid(1): days(60), eid(2): days(60)}} + absent40 := map[string]store.AppPresence{"vikunja": {AbsentSince: days(40)}, "kimai": {AbsentSince: days(40)}} + claim := []EndedClaim{{App: "vikunja", RemovedAt: days(400).Format(time.RFC3339), EndsAt: days(370).Format(time.RFC3339), SnapshotIDs: []string{eid(1)}}} + told := func(at time.Time, to string) map[string]store.EndNotice { + return map[string]store.EndNotice{"vikunja": {App: "vikunja", ToldAt: at, ToldTo: to}} + } + cases := []struct { + name string + presence map[string]store.AppPresence + notices map[string]store.EndNotice + claims []EndedClaim + wantIDs []string + refused string // a fragment of vikunja's reason + }{ + {name: "told 30 days and a minute ago: agreed", presence: absent40, notices: told(now.Add(-EndedAppAfter-time.Minute), store.EndNoticeHousehold), claims: claim, wantIDs: []string{eid(1)}}, + {name: "the operator was told in the household's place 31 days ago: agreed", presence: absent40, notices: told(days(31), store.EndNoticeOperator), claims: claim, wantIDs: []string{eid(1)}}, + {name: "no notice record at all (the box names the app only in the window request)", presence: absent40, notices: nil, claims: claim, refused: "no record that the household was told"}, + {name: "a record, and nobody told yet (the send failed)", presence: absent40, + notices: map[string]store.EndNotice{"vikunja": {App: "vikunja", LastReason: "the mail service did not accept the mail"}}, claims: claim, + refused: "has not been told yet, so nothing is removed: the mail service did not accept the mail"}, + {name: "a record, and nobody told yet (no try so far)", presence: absent40, + notices: map[string]store.EndNotice{"vikunja": {App: "vikunja"}}, claims: claim, refused: "has not been told yet"}, + {name: "told 29 days and 23 hours ago", presence: absent40, notices: told(now.Add(-EndedAppAfter+time.Hour), store.EndNoticeHousehold), claims: claim, refused: "29 full day(s), 30 needed"}, + {name: "told yesterday (the mail waited for the daily limit)", presence: absent40, notices: told(days(1), store.EndNoticeHousehold), claims: claim, refused: "the household was told on"}, + {name: "the operator was told 5 days ago", presence: absent40, notices: told(days(5), store.EndNoticeOperator), claims: claim, refused: "the operator (the household has no usable address) was told on"}, + {name: "a told time and no recipient (a value the hub never writes)", presence: absent40, notices: told(days(90), ""), claims: claim, refused: "has not been told yet"}, + {name: "BESIDE the absence, not in its place: told 40 days ago, absent for 10", presence: map[string]store.AppPresence{"vikunja": {AbsentSince: days(10)}}, + notices: told(days(40), store.EndNoticeHousehold), claims: claim, refused: "10 full day(s), 30 needed"}, + {name: "told, and installed again", presence: map[string]store.AppPresence{"vikunja": {Present: true}}, + notices: told(days(40), store.EndNoticeHousehold), claims: claim, refused: "lists the app as installed"}, + {name: "a snapshot listed under a told app AND an app nobody was told about stays", presence: absent40, + notices: told(days(40), store.EndNoticeHousehold), + claims: []EndedClaim{{App: "vikunja", SnapshotIDs: []string{eid(1), eid(2)}}, {App: "kimai", SnapshotIDs: []string{eid(2)}}}, + wantIDs: []string{eid(1)}}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + ids, _, refused := agreeEnded(now, c.presence, c.notices, listing, true, c.claims) + if strings.Join(ids, ",") != strings.Join(c.wantIDs, ",") { + t.Fatalf("agreed ids = %v, want %v (refused: %+v)", shortIDs(ids), shortIDs(c.wantIDs), refused) + } + if got := endedRefusedFor(refused, "vikunja"); !strings.Contains(got, c.refused) || (c.refused == "" && got != "") { + t.Fatalf("vikunja's refusal = %q, want it to say %q", got, c.refused) + } + }) + } +} + +// Through the window: the hub's own app record says vikunja left 31 days ago and its files are old — and the answer +// depends on the notice record alone. +func TestNotice_Window_TheNoticeRecordDecides(t *testing.T) { + ids := []string{eid(0), eid(1)} + claim := EndedClaim{App: "vikunja", SnapshotIDs: ids} + now := time.Now().UTC() + + // (a) the box names the app ONLY in the window request, never in a report: no record → nothing, and the operator + // hears it (an honest box names a pending record in every report). + s, events := endedFixtureNoNotice(t) + g := openGranted(t, s, 20, claim) + if len(g.EndedAllowed) != 0 || !hasReason(g.EndedRefused, "no record that the household was told") { + t.Fatalf("no notice record: agreed %v, refused %+v", shortIDs(g.EndedAllowed), g.EndedRefused) + } + if w, _ := s.Store.GetOffsiteWindow(g.WindowID); len(w.EndedAgreed) != 0 || len(w.EndedRefused) == 0 { + t.Fatalf("the window's own row: %+v", w) + } + if e := ofType(*events, EventEndedAppRefused); len(e) != 1 || !strings.Contains(e[0].msg, "no record that the household was told") { + t.Fatalf("the operator must hear of a box that asks for an app it never named in a report: %+v", *events) + } + + // (b) the notice could not go out (the mail hold): nothing, the answer names the reason, and this refusal is + // quiet (the operator's line for it is offsite_end_notice_stuck). + s, events = endedFixtureNoNotice(t) + first := now.Add(-31 * 24 * time.Hour) + if err := s.Store.SetEndNoticeForTest("c1", "vikunja", "", first, time.Time{}, ""); err != nil { + t.Fatal(err) + } + if err := s.Store.MarkEndNoticeTried("c1", "vikunja", "", "the hub is not sending mail (the MAIL-HOLD marker is present)", now); err != nil { + t.Fatal(err) + } + g = openGranted(t, s, 20, claim) + if len(g.EndedAllowed) != 0 || !hasReason(g.EndedRefused, "MAIL-HOLD") { + t.Fatalf("a notice that could not go out: agreed %v, refused %+v", shortIDs(g.EndedAllowed), g.EndedRefused) + } + if e := ofType(*events, EventEndedAppRefused); len(e) != 0 { + t.Fatalf("a notice that is only not sent yet raised the disagreement warning: %+v", e) + } + + // (c) told 29 days ago: nothing. (d) told 31 days ago: agreed. + s, _ = endedFixtureNoNotice(t) + at := now.Add(-29 * 24 * time.Hour) + if err := s.Store.SetEndNoticeForTest("c1", "vikunja", "", at, at, store.EndNoticeHousehold); err != nil { + t.Fatal(err) + } + if g := openGranted(t, s, 20, claim); len(g.EndedAllowed) != 0 || !hasReason(g.EndedRefused, "29 full day(s), 30 needed") { + t.Fatalf("told 29 days ago: agreed %v, refused %+v", shortIDs(g.EndedAllowed), g.EndedRefused) + } + s, _ = endedFixtureNoNotice(t) + at = now.Add(-31 * 24 * time.Hour) + if err := s.Store.SetEndNoticeForTest("c1", "vikunja", "", at, at, store.EndNoticeHousehold); err != nil { + t.Fatal(err) + } + if g := openGranted(t, s, 20, claim); strings.Join(g.EndedAllowed, ",") != strings.Join(ids, ",") { + t.Fatalf("positive control — told 31 days ago, absent 31 days: agreed %v, refused %+v", shortIDs(g.EndedAllowed), g.EndedRefused) + } + + // (e) the household is deleted between the notice and the window: its record is gone, nothing is agreed. + s, _ = endedFixtureNoNotice(t) + if err := s.Store.SetEndNoticeForTest("c1", "vikunja", "", at, at, store.EndNoticeHousehold); err != nil { + t.Fatal(err) + } + if err := s.Store.PurgeCustomerResidue("c1"); err != nil { + t.Fatal(err) + } + if ids, _, refused := s.agreeEndedFor("c1", 1, 10, []EndedClaim{claim}); len(ids) != 0 || len(refused) == 0 { + t.Fatalf("a deleted household: agreed %v, refused %+v", shortIDs(ids), refused) + } +} + +// endedFixtureNoNotice is endedFixture without the notice row it writes. +func endedFixtureNoNotice(t *testing.T) (*Service, *[]evt) { + t.Helper() + s, events := endedFixture(t) + if err := s.Store.NoteEndNotices("c1", []string{"vikunja"}, nil, true, time.Now()); err != nil { // an install voids it + t.Fatal(err) + } + if ns, _ := s.Store.EndNotices("c1"); len(ns) != 0 { + t.Fatalf("fixture: %+v", ns) + } + return s, events +} diff --git a/hub/internal/store/customer_delete.go b/hub/internal/store/customer_delete.go index 065c7b89..36035750 100644 --- a/hub/internal/store/customer_delete.go +++ b/hub/internal/store/customer_delete.go @@ -55,6 +55,8 @@ type CustomerResidue struct { OffsiteAppPresence int // The hub's own first sight of a large ended-app request (offsite_ended.go). OffsiteLargeRequests int + // The notice lock: the hub's own record that the household was told (offsite_end_notice.go). + OffsiteEndNotices int } // Total is the single number the "is there anything left at all?" decision hangs on. @@ -64,7 +66,7 @@ func (r *CustomerResidue) Total() int { } return r.Reports + r.AppTelemetry + r.AppLogTails + r.LogTailRequests + r.NotificationPrefs + r.SelfBindTokens + r.ApplianceRegistrations + r.AppLogIssueRefs + - r.OffsiteKeys + r.OffsiteWindows + r.OffsiteAbandonRequests + r.OffsiteAppPresence + r.OffsiteLargeRequests + r.OffsiteKeys + r.OffsiteWindows + r.OffsiteAbandonRequests + r.OffsiteAppPresence + r.OffsiteLargeRequests + r.OffsiteEndNotices } // residueQueries is the ONE list both the counter and the purge walk, so a table can never be @@ -85,6 +87,7 @@ var residueQueries = []struct { {"offsite_abandon_requests", func(r *CustomerResidue) *int { return &r.OffsiteAbandonRequests }}, {"offsite_app_presence", func(r *CustomerResidue) *int { return &r.OffsiteAppPresence }}, {"offsite_large_requests", func(r *CustomerResidue) *int { return &r.OffsiteLargeRequests }}, + {"offsite_end_notices", func(r *CustomerResidue) *int { return &r.OffsiteEndNotices }}, } // CustomerResidue counts the customer's report-derived + binding residue. Read-only. diff --git a/hub/internal/store/offsite_end_notice.go b/hub/internal/store/offsite_end_notice.go new file mode 100644 index 00000000..12d4cfd1 --- /dev/null +++ b/hub/internal/store/offsite_end_notice.go @@ -0,0 +1,300 @@ +package store + +import ( + "database/sql" + "fmt" + "sort" + "sync" + "time" +) + +// THE NOTICE LOCK (`09` §3 decision 315; `07-backup-architecture.md` §8.2f „No notice, no deletion”) — THE HUB'S OWN +// RECORD that a household was told its app's off-site copies will be deleted. +// +// One row per (household, app) that a box's REPORT names in a pending off-site end record. The hub mails the notice +// itself (api.endNotices → notify.SendEndNotice) and writes `told_at` — by ITS clock — only when the mail service +// accepted the mail. offsitekeys.agreeEnded agrees to an app only when this table says it was told EndedAppAfter ago. +// +// Why a table and not the sent log (`notification_log`): the 30 days are a condition of a deletion, so they must not +// rest on a log that is pruned (deleted households today; anything tomorrow), nor on anything a box says. Nothing +// here is written from a box's date: `press` is the box's `removed_at`, kept ONLY to tell one press from the next — +// a different value VOIDS the notice (the safe direction), and no value can make one. +// +// A row is deleted — and with it the notice, so a new press needs a new notice and a new 30 days — when: +// - a report lists the app as installed (an install); +// - a report that shows the off-site tier ON no longer names the app (a take-back, or the window has run); +// - the household goes (residueQueries, orphanTables). +// +// A row is RESET (told_at cleared, first_named = now) when a report names the app with another `press`. +// A report that does not show the tier (it is off, or waits for a key) changes nothing: its silence is not a +// take-back. A database put back from a copy that lacks a row has no notice: the hub tells again and waits again. + +// maxEndNoticeRows bounds one household's rows (a box's list is the box's word). A claim above it is not stored, so +// it is never told and never agreed. +const maxEndNoticeRows = 50 + +// EndNoticeHousehold / EndNoticeOperator: who the notice that counts went to. +const ( + EndNoticeHousehold = "household" + EndNoticeOperator = "operator" +) + +func (s *Store) migrateOffsiteEndNotices() error { + if _, err := s.db.Exec(` + CREATE TABLE IF NOT EXISTS offsite_end_notices ( + customer_id TEXT NOT NULL, + app TEXT NOT NULL, + press TEXT NOT NULL DEFAULT '', + first_named TEXT NOT NULL, + told_at TEXT, + told_to TEXT NOT NULL DEFAULT '', + tries INTEGER NOT NULL DEFAULT 0, + last_try TEXT, + last_reason TEXT NOT NULL DEFAULT '', + stuck_told TEXT, + PRIMARY KEY (customer_id, app) + );`); err != nil { + return fmt.Errorf("offsite_end_notices: %w", err) + } + return nil +} + +// EndClaim is one pending end record of a report, as far as the notice needs it. +type EndClaim struct { + App string + // Press is the box's `removed_at`. NormalizeEndPress decides what is stored of it. + Press string +} + +// EndNotice is the hub's record for one app of one household. +type EndNotice struct { + App string + Press string + // FirstNamed: the hub's time of the first report that named this press. + FirstNamed time.Time + // ToldAt: the hub's time at which the notice that counts was accepted by the mail service. Zero = not told. + ToldAt time.Time + // ToldTo: EndNoticeHousehold, or EndNoticeOperator for a household that had no usable address. + ToldTo string + Tries int + LastTry time.Time + LastReason string // the hub's own words for why the last try did not tell anybody + // StuckTold: the hub's time of the operator's one line about a notice that could not go out for days. + StuckTold time.Time +} + +// Told: the hub's record says somebody was told. +func (n EndNotice) Told() bool { return !n.ToldAt.IsZero() && n.ToldTo != "" } + +// NormalizeEndPress turns a box's `removed_at` into the key of a press: the same instant in UTC when it is a time, +// else the empty key. It is never read as a date. +func NormalizeEndPress(removedAt string) string { + if len(removedAt) > 40 { + return "" + } + t, err := time.Parse(time.RFC3339, removedAt) + if err != nil { + return "" + } + return t.UTC().Format(time.RFC3339) +} + +// NoteEndNotices updates the record from ONE report (see the header). deployed is the report's app list; claims are +// its pending end records; tierOn says the report shows the off-site tier switched on (only then is a missing claim +// a take-back). now is the HUB's clock. +func (s *Store) NoteEndNotices(customerID string, deployed []string, claims []EndClaim, tierOn bool, now time.Time) error { + if customerID == "" { + return fmt.Errorf("NoteEndNotices: empty customer_id") + } + if len(deployed) > maxPresenceApps { + deployed = deployed[:maxPresenceApps] + } + if len(claims) > maxPresenceApps { + claims = claims[:maxPresenceApps] + } + cur, err := s.EndNotices(customerID) + if err != nil { + return err + } + if len(cur) == 0 && len(claims) == 0 { + return nil // the steady box: one read + } + in := make(map[string]bool, len(deployed)) + for _, app := range deployed { + in[app] = true + } + claimed := map[string]string{} // app → press (the first claim of a name wins) + var order []string + for _, c := range claims { + if !ValidPresenceApp(c.App) || ReservedPresenceApp(c.App) || in[c.App] { + continue + } + if _, dup := claimed[c.App]; dup { + continue + } + claimed[c.App] = NormalizeEndPress(c.Press) + order = append(order, c.App) + } + var drop, fresh []string + for app, n := range cur { + press, named := claimed[app] + switch { + case in[app]: // an install voids the notice + drop = append(drop, app) + case named && press != n.Press: // another press: a new notice, a new 30 days + drop = append(drop, app) + fresh = append(fresh, app) + case !named && tierOn: // a take-back, or the window has run + drop = append(drop, app) + } + } + rows := len(cur) - len(drop) + notStored := 0 + for _, app := range order { + if _, ok := cur[app]; ok { + continue + } + fresh = append(fresh, app) + } + sort.Strings(fresh) + if over := rows + len(fresh) - maxEndNoticeRows; over > 0 { + notStored = over + fresh = fresh[:len(fresh)-over] + } + s.noteEndNoticesFull(customerID, notStored) + if len(drop) == 0 && len(fresh) == 0 { + return nil + } + stamp := now.UTC().Format(time.RFC3339) + tx, err := s.db.Begin() + if err != nil { + return err + } + defer tx.Rollback() + for _, app := range drop { + if _, err := tx.Exec(`DELETE FROM offsite_end_notices WHERE customer_id = ? AND app = ?`, customerID, app); err != nil { + return fmt.Errorf("NoteEndNotices %s/%s: %w", customerID, app, err) + } + } + for _, app := range fresh { + if _, err := tx.Exec(`INSERT INTO offsite_end_notices (customer_id, app, press, first_named) VALUES (?, ?, ?, ?)`, + customerID, app, claimed[app], stamp); err != nil { + return fmt.Errorf("NoteEndNotices %s/%s: %w", customerID, app, err) + } + } + return tx.Commit() +} + +// endNoticesFull: the row limit is said in the log once per household, not once per report (in memory). +var ( + endNoticesFullMu sync.Mutex + endNoticesFull = map[string]bool{} +) + +func (s *Store) noteEndNoticesFull(customerID string, notStored int) { + endNoticesFullMu.Lock() + defer endNoticesFullMu.Unlock() + if notStored == 0 { + delete(endNoticesFull, customerID) + return + } + if endNoticesFull[customerID] { + return + } + endNoticesFull[customerID] = true + if s.logger != nil { + s.logger.Printf("[WARN] off-site end notices for %s are at their limit of %d apps: %d pending end record(s) of this report were NOT stored — nobody is told about them and the hub agrees to none of them. A household does not remove that many apps at once — look at what the box reports. (Said once; not repeated per report.)", + customerID, maxEndNoticeRows, notStored) + } +} + +// EndNotices returns the hub's record for one household, by app. A date that cannot be read is the zero time — and +// a zero ToldAt is „not told”. +func (s *Store) EndNotices(customerID string) (map[string]EndNotice, error) { + rows, err := s.db.Query(`SELECT app, press, first_named, told_at, told_to, tries, last_try, last_reason, stuck_told + FROM offsite_end_notices WHERE customer_id = ?`, customerID) + if err != nil { + return nil, err + } + defer rows.Close() + out := map[string]EndNotice{} + for rows.Next() { + var n EndNotice + var first string + var told, lastTry, stuck sql.NullString + if err := rows.Scan(&n.App, &n.Press, &first, &told, &n.ToldTo, &n.Tries, &lastTry, &n.LastReason, &stuck); err != nil { + return nil, err + } + n.FirstNamed = parseNoticeTime(first) + n.ToldAt = parseNoticeTime(told.String) + n.LastTry = parseNoticeTime(lastTry.String) + n.StuckTold = parseNoticeTime(stuck.String) + if n.ToldTo != EndNoticeHousehold && n.ToldTo != EndNoticeOperator { + n.ToldTo, n.ToldAt = "", time.Time{} // a value the hub never writes is „not told” + } + out[n.App] = n + } + return out, rows.Err() +} + +func parseNoticeTime(v string) time.Time { + if v == "" { + return time.Time{} + } + t, err := time.Parse(time.RFC3339, v) + if err != nil { + return time.Time{} + } + return t +} + +// MarkEndNoticeTold writes that the notice of THIS press was accepted by the mail service, at the hub's time `now`, +// to `to` (EndNoticeHousehold or EndNoticeOperator). It matches the press: a row that was voided or reset while the +// mail was being sent is not marked (ok=false) — that press was never told. +func (s *Store) MarkEndNoticeTold(customerID, app, press, to string, now time.Time) (ok bool, err error) { + if to != EndNoticeHousehold && to != EndNoticeOperator { + return false, fmt.Errorf("MarkEndNoticeTold: unknown recipient %q", to) + } + stamp := now.UTC().Format(time.RFC3339) + res, err := s.db.Exec(`UPDATE offsite_end_notices SET told_at = ?, told_to = ?, tries = tries + 1, last_try = ?, last_reason = '' + WHERE customer_id = ? AND app = ? AND press = ?`, stamp, to, stamp, customerID, app, press) + if err != nil { + return false, err + } + n, _ := res.RowsAffected() + return n == 1, nil +} + +// MarkEndNoticeTried writes a try that told nobody, with the hub's own words for why. It never touches told_at. +func (s *Store) MarkEndNoticeTried(customerID, app, press, reason string, now time.Time) error { + _, err := s.db.Exec(`UPDATE offsite_end_notices SET tries = tries + 1, last_try = ?, last_reason = ? + WHERE customer_id = ? AND app = ? AND press = ?`, now.UTC().Format(time.RFC3339), reason, customerID, app, press) + return err +} + +// MarkEndNoticeStuckTold writes that the operator's one line about a notice that cannot go out was filed. +func (s *Store) MarkEndNoticeStuckTold(customerID, app, press string, now time.Time) error { + _, err := s.db.Exec(`UPDATE offsite_end_notices SET stuck_told = ? WHERE customer_id = ? AND app = ? AND press = ?`, + now.UTC().Format(time.RFC3339), customerID, app, press) + return err +} + +// SetEndNoticeForTest writes a row as if the hub had named the app at firstNamed and (toldAt non-zero) told `to` +// at toldAt. TEST-ONLY. +func (s *Store) SetEndNoticeForTest(customerID, app, press string, firstNamed, toldAt time.Time, to string) error { + var told sql.NullString + if !toldAt.IsZero() { + told = sql.NullString{String: toldAt.UTC().Format(time.RFC3339), Valid: true} + } + _, err := s.db.Exec(`INSERT INTO offsite_end_notices (customer_id, app, press, first_named, told_at, told_to) VALUES (?, ?, ?, ?, ?, ?) + ON CONFLICT(customer_id, app) DO UPDATE SET press = excluded.press, first_named = excluded.first_named, told_at = excluded.told_at, told_to = excluded.told_to`, + customerID, app, press, firstNamed.UTC().Format(time.RFC3339), told, to) + return err +} + +// BackdateNotificationLogForTest moves a household's sent-log rows into the past. TEST-ONLY. +func (s *Store) BackdateNotificationLogForTest(customerID string, by time.Duration) error { + _, err := s.db.Exec(`UPDATE notification_log SET created_at = datetime(created_at, ?) WHERE customer_id = ?`, + fmt.Sprintf("-%d seconds", int(by.Seconds())), customerID) + return err +} diff --git a/hub/internal/store/offsite_end_notice_test.go b/hub/internal/store/offsite_end_notice_test.go new file mode 100644 index 00000000..b1f6d971 --- /dev/null +++ b/hub/internal/store/offsite_end_notice_test.go @@ -0,0 +1,186 @@ +package store + +import ( + "fmt" + "strings" + "testing" + "time" +) + +// THE NOTICE LOCK, the hub's own record (`09` §3 decision 315; `07-backup-architecture.md` §8.2f). +// RED-PROOFS: documentation/audits/build-release-4b-2026-11-15/A/redproof-notice-store.txt. + +func endNotice(t *testing.T, s *Store, cust, app string) (EndNotice, bool) { + t.Helper() + ns, err := s.EndNotices(cust) + if err != nil { + t.Fatal(err) + } + n, ok := ns[app] + return n, ok +} + +// One press is one row, made at the first report that names it — by the HUB's clock — and nothing a later report +// says moves it. „Told” is written only by the hub, and only for the press it mailed about. +func TestNotice_Record_OnePressOneRow(t *testing.T) { + s := newTestStore(t) + t0 := time.Date(2026, 11, 15, 10, 0, 0, 0, time.UTC) + press := "2026-11-15T09:59:00Z" + note := func(at time.Time, deployed []string, tierOn bool, claims ...EndClaim) { + t.Helper() + if err := s.NoteEndNotices("c1", deployed, claims, tierOn, at); err != nil { + t.Fatal(err) + } + } + note(t0, []string{"immich"}, true, EndClaim{App: "vikunja", Press: press}) + n, ok := endNotice(t, s, "c1", "vikunja") + if !ok || n.Told() || !n.FirstNamed.Equal(t0) || n.Press != press { + t.Fatalf("first report: %+v (found=%v) — want one row, not told, first named at the hub's time", n, ok) + } + // the same press in another time zone's writing, a day later: the same row + note(t0.Add(24*time.Hour), []string{"immich"}, true, EndClaim{App: "vikunja", Press: "2026-11-15T10:59:00+01:00"}) + if n, _ := endNotice(t, s, "c1", "vikunja"); !n.FirstNamed.Equal(t0) { + t.Fatalf("a later report of the same press moved the row: %+v", n) + } + // told: only with the press the hub mailed about + if ok, err := s.MarkEndNoticeTold("c1", "vikunja", "2026-11-01T00:00:00Z", EndNoticeHousehold, t0); err != nil || ok { + t.Fatalf("a told mark for ANOTHER press was written (ok=%v err=%v)", ok, err) + } + if n, _ := endNotice(t, s, "c1", "vikunja"); n.Told() { + t.Fatalf("told by a mark for another press: %+v", n) + } + if _, err := s.MarkEndNoticeTold("c1", "vikunja", press, "the box", t0); err == nil { + t.Fatal("an unknown recipient was accepted") + } + told := t0.Add(time.Hour) + if ok, err := s.MarkEndNoticeTold("c1", "vikunja", press, EndNoticeHousehold, told); err != nil || !ok { + t.Fatalf("MarkEndNoticeTold: ok=%v err=%v", ok, err) + } + n, _ = endNotice(t, s, "c1", "vikunja") + if !n.Told() || !n.ToldAt.Equal(told) || n.ToldTo != EndNoticeHousehold { + t.Fatalf("told: %+v", n) + } + // a try that told nobody never touches the told time + if err := s.MarkEndNoticeTried("c1", "vikunja", press, "x", told.Add(time.Hour)); err != nil { + t.Fatal(err) + } + if n, _ := endNotice(t, s, "c1", "vikunja"); !n.ToldAt.Equal(told) { + t.Fatalf("a failed try moved the told time: %+v", n) + } +} + +// What voids a notice, and what does not. +func TestNotice_Record_WhatVoidsIt(t *testing.T) { + t0 := time.Date(2026, 11, 15, 10, 0, 0, 0, time.UTC) + press := "2026-11-15T09:59:00Z" + cases := []struct { + name string + deployed []string + tierOn bool + claims []EndClaim + want string // "told" (kept), "gone", "fresh" (a new row, not told) + }{ + {"the same press again", []string{"immich"}, true, []EndClaim{{App: "vikunja", Press: press}}, "told"}, + {"a take-back: the tier is on and no record names the app", []string{"immich"}, true, nil, "gone"}, + {"an install: the app is in the app list", []string{"immich", "vikunja"}, true, nil, "gone"}, + {"an install that the box still claims (it lies, or it is slow)", []string{"immich", "vikunja"}, true, []EndClaim{{App: "vikunja", Press: press}}, "gone"}, + {"another press", []string{"immich"}, true, []EndClaim{{App: "vikunja", Press: "2026-11-15T16:00:00Z"}}, "fresh"}, + {"a press whose key is not a time", []string{"immich"}, true, []EndClaim{{App: "vikunja", Press: "yesterday"}}, "fresh"}, + {"the report does not show the tier: its silence is not a take-back", []string{"immich"}, false, nil, "told"}, + {"the report does not show the tier, and the app is installed", []string{"vikunja"}, false, nil, "gone"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + s := newTestStore(t) + if err := s.SetEndNoticeForTest("c1", "vikunja", press, t0, t0, EndNoticeHousehold); err != nil { + t.Fatal(err) + } + later := t0.Add(5 * 24 * time.Hour) + if err := s.NoteEndNotices("c1", c.deployed, c.claims, c.tierOn, later); err != nil { + t.Fatal(err) + } + n, ok := endNotice(t, s, "c1", "vikunja") + got := "gone" + switch { + case ok && n.Told() && n.ToldAt.Equal(t0): + got = "told" + case ok && !n.Told() && n.FirstNamed.Equal(later): + got = "fresh" + case ok: + got = fmt.Sprintf("?? %+v", n) + } + if got != c.want { + t.Fatalf("the notice is %s, want %s", got, c.want) + } + }) + } +} + +// A box's list is the box's word: only app names are stored, at most maxEndNoticeRows per household; a stored value +// the hub never writes is „not told”; a told time that cannot be read is „not told”. +func TestNotice_Record_IsBoundedAndFailsClosed(t *testing.T) { + s := newTestStore(t) + now := time.Date(2026, 11, 15, 10, 0, 0, 0, time.UTC) + var claims []EndClaim + for _, bad := range []string{"", "_shares", "traefik", "felhom-offbox", "x", "pay now", strings.Repeat("a", 65)} { + claims = append(claims, EndClaim{App: bad}) + } + for i := 0; i < 80; i++ { + claims = append(claims, EndClaim{App: fmt.Sprintf("app-%02d", i)}) + } + if err := s.NoteEndNotices("c1", nil, claims, true, now); err != nil { + t.Fatal(err) + } + ns, _ := s.EndNotices("c1") + if len(ns) != maxEndNoticeRows { + t.Fatalf("rows = %d, want the limit %d", len(ns), maxEndNoticeRows) + } + for app := range ns { + if !strings.HasPrefix(app, "app-") { + t.Fatalf("a name that is not an app name was stored: %q", app) + } + } + // the same 80 again: still the limit, and the rows it holds are not replaced + if err := s.NoteEndNotices("c1", nil, claims, true, now.Add(time.Hour)); err != nil { + t.Fatal(err) + } + ns2, _ := s.EndNotices("c1") + if len(ns2) != maxEndNoticeRows || !ns2["app-00"].FirstNamed.Equal(now) { + t.Fatalf("a second report changed the bounded record: %d rows, app-00 %+v", len(ns2), ns2["app-00"]) + } + // fail closed: a recipient the hub never writes, and a told time that is not a time + if _, err := s.db.Exec(`UPDATE offsite_end_notices SET told_at = '2020-01-01T00:00:00Z', told_to = 'box' WHERE app = 'app-00'`); err != nil { + t.Fatal(err) + } + if _, err := s.db.Exec(`UPDATE offsite_end_notices SET told_at = 'long ago', told_to = 'household' WHERE app = 'app-01'`); err != nil { + t.Fatal(err) + } + ns3, _ := s.EndNotices("c1") + if ns3["app-00"].Told() || ns3["app-01"].Told() { + t.Fatalf("an unreadable record counts as told: %+v %+v", ns3["app-00"], ns3["app-01"]) + } +} + +// The notice record goes with the household (D73's rule for every household-keyed table). +func TestNotice_Record_GoesWithTheHousehold(t *testing.T) { + s := newTestStore(t) + now := time.Now() + if err := s.SetEndNoticeForTest("gone", "vikunja", "", now, now, EndNoticeHousehold); err != nil { + t.Fatal(err) + } + if r, err := s.CustomerResidue("gone"); err != nil || r.OffsiteEndNotices != 1 || r.Total() < 1 { + t.Fatalf("the residue count does not see the notice record: %+v %v", r, err) + } + if err := s.PurgeCustomerResidue("gone"); err != nil { + t.Fatal(err) + } + if m, _ := s.EndNotices("gone"); len(m) != 0 { + t.Fatalf("the notice record outlived the household: %+v", m) + } + if err := s.SetEndNoticeForTest("ghost", "vikunja", "", now, now, EndNoticeHousehold); err != nil { + t.Fatal(err) + } + if n, err := s.PurgeOrphanRows(); err != nil || n["offsite_end_notices"] != 1 { + t.Fatalf("orphan sweep: %+v %v", n, err) + } +} diff --git a/hub/internal/store/orphan_rows.go b/hub/internal/store/orphan_rows.go index 535e841d..ddf30ab2 100644 --- a/hub/internal/store/orphan_rows.go +++ b/hub/internal/store/orphan_rows.go @@ -29,6 +29,7 @@ var orphanTables = []struct{ table, where string }{ {"offsite_abandon_requests", `customer_id NOT IN (SELECT customer_id FROM customer_configs) AND customer_id NOT IN (SELECT customer_id FROM hosts)`}, {"offsite_app_presence", `customer_id NOT IN (SELECT customer_id FROM customer_configs) AND customer_id NOT IN (SELECT customer_id FROM hosts)`}, {"offsite_large_requests", `customer_id NOT IN (SELECT customer_id FROM customer_configs) AND customer_id NOT IN (SELECT customer_id FROM hosts)`}, + {"offsite_end_notices", `customer_id NOT IN (SELECT customer_id FROM customer_configs) AND customer_id NOT IN (SELECT customer_id FROM hosts)`}, } // PurgeOrphanRows removes, in ONE transaction, the rows of boxes and households that no longer exist from the six diff --git a/hub/internal/store/store.go b/hub/internal/store/store.go index 42ed45f8..ae1869fe 100644 --- a/hub/internal/store/store.go +++ b/hub/internal/store/store.go @@ -879,6 +879,10 @@ func (s *Store) migrate() error { if err := s.migrateOffsiteEnded(); err != nil { return err } + // The notice lock (`09` §3 decision 315): the hub's own record that a household was told. + if err := s.migrateOffsiteEndNotices(); err != nil { + return err + } // OS updates, guest fast lane (hub v0.130.0, `11` §8 step 2). if err := s.migrateOSUpdates(); err != nil { return fmt.Errorf("os_updates: %w", err)