From ee87d17cb932ce3bfe2bcec9f2b7d78c42afaaa8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9D=D1=83=D1=80=D0=BB=D1=8B=D0=B3=D0=B0=D1=8F=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=D0=B0=20=D0=95=D0=BA=D0=B0=D1=82=D0=B5=D1=80=D0=B8?= =?UTF-8?q?=D0=BD=D0=B0?= Date: Thu, 29 Oct 2026 15:18:44 +0300 Subject: [PATCH] fixed read-after-write after failed cache invalidation and API restart --- REPORT.md | 14 +- app/cmd/messenger/main.go | 1 + app/e2e/failures_test.go | 47 ++++++ app/internal/cache/history.go | 128 +++++++++++--- app/internal/cache/history_test.go | 159 ++++++++++++++++++ app/internal/store/db/integration_test.go | 42 +++++ app/internal/store/db/invalidations.go | 63 +++++++ evidence/failures.txt | 38 +++-- evidence/integration-tests.txt | 22 ++- evidence/migrations.txt | 43 ++--- ...00006_create_cache_invalidations_table.sql | 23 +++ scripts/integration-tests.sh | 2 +- scripts/migrations-check.sh | 6 +- 13 files changed, 510 insertions(+), 78 deletions(-) create mode 100644 app/internal/store/db/invalidations.go create mode 100644 migrations/00006_create_cache_invalidations_table.sql diff --git a/REPORT.md b/REPORT.md index 2a0a7e2..64e1086 100644 --- a/REPORT.md +++ b/REPORT.md @@ -24,6 +24,7 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh cd app && go test ./... # unit/HTTP; интеграционные и e2e пропускаются sh scripts/integration-tests.sh # гонка username, rollback, кэш (PostgreSQL + valkey-cache) sh scripts/failures-tests.sh # уровень 4: пароль, logout, expiry, отказы → evidence/failures.txt + # если 127.0.0.1:8080 занят другим процессом: sh scripts/failures-tests.sh 'http://[::1]:8080' sh scripts/explain.sh # EXPLAIN → evidence/explain.txt sh scripts/migrations-check.sh # миграции с нуля и повторно → evidence/migrations.txt sh scripts/persistence-evidence.sh # persistence + StartedAt до/после → evidence/persistence.txt @@ -53,7 +54,7 @@ migrate (goose, одноразовый) ─▶ postgres до старта api **Из lab1** перенесены роутер, middleware (request id, recover, логи, лимиты), валидация, формат ошибок, keyset-курсоры. **Изменено:** хранилище — PostgreSQL; Basic только на `POST /auth/sessions`, далее opaque Bearer; `X-User-Id` не читается. -**Схема** (`migrations/0000{1..4}`): `users` (UNIQUE username, CHECK формата), `chats`, `chat_members` (PK `(chat_id, user_id)`, индекс `(user_id, chat_id)`), `messages` (FK `(chat_id, sender_id) → chat_members` — отправитель обязан быть участником на уровне БД; индекс `(chat_id, created_at, id)` под keyset). +**Схема** (`migrations/0000{1..6}`): `users` (UNIQUE username, CHECK формата), `chats`, `chat_members` (PK `(chat_id, user_id)`, индекс `(user_id, chat_id)`), `messages` (FK `(chat_id, sender_id) → chat_members` — отправитель обязан быть участником на уровне БД; индекс `(chat_id, created_at, id)` под keyset). `00005` — экранирование U+0000 в текстовых полях, `00006` — `cache_invalidations` (долг инвалидации кэша, см. трек 1). **Транзакции.** Создание чата — одна транзакция `INSERT chats` + `INSERT chat_members SELECT unnest(...)`; неизвестный участник → FK → rollback → 400. Регистрация — один `INSERT`, гонку решает UNIQUE (→ 409). Сообщение — один `INSERT`, членство проверяет FK. COMMIT с `synchronous_commit=on` переживает падение процесса PostgreSQL, но не потерю диска. @@ -84,7 +85,7 @@ migrate (goose, одноразовый) ─▶ postgres до старта api | **Уровень 3** | | | | | Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/checks.txt` | | Данные и сессии переживают рестарт API и всех хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; `StartedAt` всех 4 контейнеров новый, volumes те же | `evidence/persistence.txt` | -| PK/FK, UNIQUE username, миграции с нуля и повторно | `scripts/migrations-check.sh` | 4 миграции на пустом volume; повтор — `no migrations to run`, строк столько же | `evidence/migrations.txt` | +| PK/FK, UNIQUE username, миграции с нуля и повторно | `scripts/migrations-check.sh` | 6 миграций на пустом volume; повтор — `no migrations to run`, строк столько же | `evidence/migrations.txt` | | Атомарное создание чата | `TestCreateChatRollback` | неизвестный участник → 400, таблицы без изменений | `evidence/integration-tests.txt` | | Basic только на вход, Bearer на остальном, `X-User-Id` не даёт доступ | `TestFailures`, `TestAuth_BearerRequired` | X-User-Id → 401; Basic на `/users/me` → 401 | `evidence/failures.txt` | | Expiry и logout | `TestFailures` | TTL=2: 200 → 401; logout 204 → 401 | `evidence/failures.txt` | @@ -104,6 +105,7 @@ migrate (goose, одноразовый) ─▶ postgres до старта api | SQL и latency до/после | `scripts/track1.sh` | SQL на чтение 2,014 → 0,0034; p95 28,5 → 14,4 мс | `evidence/track1/summary.md` | | Read-after-write | `cachebench` | `safe`: 0 нарушений на 826 552 проверках | `evidence/track1/*.json` | | Восстановление после рестарта кэша | `track1.sh`: stop/start и pause/unpause под нагрузкой | 0 ошибок, 0 stale | `evidence/track1/summary.md` | +| Read-after-write: `DEL` не удался, затем рестарт API | `TestFailures` (pause кэша → 201 → `restart api`), `TestReadAfterWrite_InvalidationFailedThenRestart` | сообщение с 201 есть в первом же чтении после рестарта; без `cache_invalidations` — отсутствует до 30 с | `evidence/failures.txt`, `evidence/integration-tests.txt` | ## Эксперименты и отказы @@ -111,7 +113,9 @@ migrate (goose, одноразовый) ─▶ postgres до старта api **Гипотеза.** Классический cache-aside (`naive`: прочитать БД → положить в кэш; после COMMIT удалить ключи) на горячем чате (1) нарушает read-after-write — читатель кладёт в кэш снимок, прочитанный до COMMIT, уже после удаления ключей; (2) даёт stampede. Версионные ключи + singleflight + lock (`safe`) устраняют оба эффекта. -**Защита** (`app/internal/cache/history.go`). Страница лежит под `hc:page:{chat}:{ver}:…`, `ver` — случайные 64 бита. Запись: COMMIT → `DEL hc:ver:{chat}` → 201. Снимок, прочитанный до COMMIT, попадает только под старую версию, которую никто не прочитает. Версия случайная, поэтому её потеря (LRU, рестарт) — только промах. Stampede: `singleflight` в процессе + `SET NX PX 500` lock между репликами. Доступ проверяется до выдачи страницы. При отказе кэша — breaker и чтение из PostgreSQL; несработавший `DEL` повторяется каждые 200 мс, чат до этого читается мимо кэша. Ошибка кэша не превращает подтверждённую запись в 503. +**Защита** (`app/internal/cache/history.go`). Страница лежит под `hc:page:{chat}:{ver}:…`, `ver` — случайные 64 бита. Запись: COMMIT → `DEL hc:ver:{chat}` → 201. Снимок, прочитанный до COMMIT, попадает только под старую версию, которую никто не прочитает. Версия случайная, поэтому её потеря (LRU, рестарт) — только промах. Stampede: `singleflight` в процессе + `SET NX PX 500` lock между репликами. Доступ проверяется до выдачи страницы. При отказе кэша — breaker и чтение из PostgreSQL. Ошибка кэша не превращает подтверждённую запись в 503. + +**Неудачный `DEL` и рестарт API.** Если `DEL hc:ver:{chat}` не прошёл, старая версия и её страницы остаются в Valkey. Раньше долг помнила только память процесса: после рестарта API кэш отдавал страницу без подтверждённого сообщения до истечения TTL (30 с). Теперь до ответа 201 долг записывается в PostgreSQL — `INSERT … ON CONFLICT DO UPDATE` в `cache_invalidations (chat_id, gen)`. Чат с долгом читается мимо кэша; повтор каждые 200 мс делает `DEL`, затем `DELETE … WHERE gen = $2`. При старте API долги загружаются из PostgreSQL, и пока загрузка не удалась, мимо кэша читаются все чаты. `gen` берётся из общей последовательности, а запись в памяти получает новый номер при каждом сбое: повтор, начатый до нового сбоя, не снимает его ни в памяти, ни в таблице (`TestRetryDoesNotDropNewerFailure`, `TestPendingInvalidationCAS`). Цена — один upsert в PostgreSQL только на запись, у которой не прошёл `DEL`; в штатном режиме лишних запросов нет. **Методика.** `REPEATS=3 DURATION=30s sh scripts/track1.sh`: для каждого режима API пересоздаётся с нужным `HISTORY_CACHE` и `FILL_DELAY` (0 или 20 мс — расширенное окно гонки), кэш очищается. `cachebench` в той же Docker-сети создаёт чат со 150 сообщениями; 3 с прогрева, 30 с замера. 32 читателя в closed loop опрашивают хвост истории; 2 писателя раз в 100 мс пишут и сразу читают (RAW). Каждое полное чтение хвоста сверяется со всеми сообщениями, получившими 201 до его начала (stale read). SQL — `pg_stat_statements`, hit/miss — `INFO stats`, CPU/RAM — `docker stats`. @@ -131,7 +135,7 @@ CPU postgres: off 175 % → naive 8 % → safe 3 %; RAM api ≤74 MiB, postgres **Выводы.** Stale read воспроизведён во всех 6 прогонах `naive`, в том числе без fault injection; в `safe` — 0 на 826 552 проверках. В `safe` SQL страницы ≈ числу записей (одно заполнение на инвалидацию при 32 читателях); в `naive` при окне 20 мс — в 19 раз больше. Относительно `off` кэш снимает ~99,8 % SQL чтения, пропускная способность ×2, p95 почти вдвое ниже. Цена — +1 обращение к Valkey на чтение и +1 `DEL` на запись. -**Ограничения.** Один host, closed-loop генератор (coordinated omission): абсолютные RPS не переносимы, устойчивы SQL на чтение и наличие/отсутствие нарушений. Доказана одна реплика API. Не закрыто окно: `DEL` не удался, а другая реплика (lab3) видит кэш — устаревание ≤ TTL страницы 30 с. +**Ограничения.** Один host, closed-loop генератор (coordinated omission): абсолютные RPS не переносимы, устойчивы SQL на чтение и наличие/отсутствие нарушений. Доказана одна реплика API. ### Отказы @@ -143,11 +147,11 @@ CPU postgres: off 175 % → naive 8 % → safe 3 %; RAM api ≤74 MiB, postgres | `stop valkey-cache` | обход кэша | ready 200, запись 201, чтение из PostgreSQL | без ошибок; кэш холодный | | stop/start кэша под нагрузкой | 0 ошибок, 0 stale | 153 522 чтения, 0 ошибок, 0 stale | без потерь | | pause/unpause кэша под нагрузкой | 0 stale при сохранённых старых страницах | 160 911 чтений, 0 ошибок, 0 stale; p95 записи 211 мс (таймаут `DEL`) | отложенные инвалидации выполнены до первого чтения из кэша | +| pause кэша → запись 201 → `restart api` → unpause | сообщение видно сразу | 3 чтения после рестарта, сообщение в каждом; в логе `invalidation deferred gen=…` → `pending invalidations loaded chats=1` | долг из `cache_invalidations` погашен после unpause | ## Ограничения и следующие шаги - Один Docker-host, без реплик PostgreSQL/Valkey: потеря host или volume — потеря данных и сессий. - `appendfsync everysec`: при аварии теряется до ~1 с входов/logout; отозванная сессия может «воскреснуть» до `expires_at`. `always` убирает окно ценой задержки. -- Кэш: окно ≤30 с при неудачном `DEL` и нескольких репликах или падении API до повтора. Полностью закрыла бы его версия в PostgreSQL в той же транзакции — не реализовано. - `ListChats` использует `$2 IS NULL OR …`; при большом числе чатов на пользователя запрос стоит разделить, как для истории. - `valkey-cache` получает анонимный volume из образа, но с `--save "" --appendonly no` он пуст. diff --git a/app/cmd/messenger/main.go b/app/cmd/messenger/main.go index 4670842..2343bb5 100644 --- a/app/cmd/messenger/main.go +++ b/app/cmd/messenger/main.go @@ -72,6 +72,7 @@ func main() { defer hcClient.Close() hc := cache.New(storage.Messages, hcClient, cache.Options{ Mode: cfg.HistoryCache.Mode, + Outbox: storage.Messages, PageTTL: time.Duration(cfg.HistoryCache.PageTTLSeconds) * time.Second, FillDelay: time.Duration(cfg.HistoryCache.FillDelayMs) * time.Millisecond, Logger: logger, diff --git a/app/e2e/failures_test.go b/app/e2e/failures_test.go index 827b3f5..eb010a3 100644 --- a/app/e2e/failures_test.go +++ b/app/e2e/failures_test.go @@ -136,6 +136,23 @@ func compose(t *testing.T, env map[string]string, args ...string) { } } +// waitHealthy ждёт healthcheck сервиса: после unpause он остаётся unhealthy +// до следующей успешной проверки, и compose up --wait сразу падает. +func waitHealthy(t *testing.T, service string) { + t.Helper() + deadline := time.Now().Add(30 * time.Second) + for time.Now().Before(deadline) { + cmd := exec.Command("docker", "compose", "--env-file", ".env", "ps", "--format", "{{.Health}}", service) + cmd.Dir = root + out, _ := cmd.Output() + if strings.TrimSpace(string(out)) == "healthy" { + return + } + time.Sleep(500 * time.Millisecond) + } + t.Fatalf("%s не стал healthy за 30 с", service) +} + func randHex(n int) string { b := make([]byte, n) _, _ = rand.Read(b) @@ -326,4 +343,34 @@ func TestFailures(t *testing.T) { t.Error("ожидали две одинаковые полные страницы с сообщением, записанным при упавшем кэше") } }) + + t.Run("инвалидация не удалась, API перезапущен: сообщение с 201 сразу видно в истории", func(t *testing.T) { + // Прогреваем страницу в кэше, затем замораживаем Valkey-кэш: данные + // (и старая версия) остаются, но DEL версии падает по таймауту. + c.call(http.MethodGet, messagesPath+"?limit=100", token, nil, nil) + c.call(http.MethodGet, messagesPath+"?limit=100", token, nil, nil) + compose(t, nil, "pause", "valkey-cache") + paused := true + t.Cleanup(func() { + if paused { + compose(t, nil, "unpause", "valkey-cache") + } + waitHealthy(t, "valkey-cache") + }) + send := c.call(http.MethodPost, messagesPath, token, map[string]string{"text": "до рестарта API"}, nil) + if send.status != 201 { + t.Fatalf("ожидали 201, получили %d", send.status) + } + compose(t, nil, "restart", "api") + c.waitReady(t) + compose(t, nil, "unpause", "valkey-cache") + paused = false + for i := 0; i < 3; i++ { + list := c.call(http.MethodGet, messagesPath+"?limit=100", token, nil, nil) + if list.status != 200 || !slices.Contains(list.itemIDs(), send.str("id")) { + t.Fatalf("чтение %d после рестарта: status %d, подтверждённого сообщения нет в истории", i+1, list.status) + } + time.Sleep(300 * time.Millisecond) + } + }) } diff --git a/app/internal/cache/history.go b/app/internal/cache/history.go index 0d6d526..5f78354 100644 --- a/app/internal/cache/history.go +++ b/app/internal/cache/history.go @@ -35,8 +35,17 @@ type Source interface { HistoryPage(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error) } +// Outbox хранит долг инвалидации в источнике истины, чтобы он пережил +// рестарт API. Без него отложенная инвалидация живёт только в памяти. +type Outbox interface { + AddPendingInvalidation(ctx context.Context, chatID string) (int64, error) + PendingInvalidations(ctx context.Context) (map[string]int64, error) + ResolvePendingInvalidation(ctx context.Context, chatID string, gen int64) error +} + type Options struct { Mode string + Outbox Outbox PageTTL time.Duration LockTTL time.Duration FillDelay time.Duration @@ -45,6 +54,14 @@ type Options struct { var _ store.MessageStore = (*Messages)(nil) +// pendingEntry — несброшенная версия чата. seq меняется при каждом новом +// сбое: повтор снимает запись, только если seq не изменился с его снимка. +// gen — поколение строки в Outbox (0 — не записана). +type pendingEntry struct { + seq uint64 + gen int64 +} + type Messages struct { src Source rdb *redis.Client @@ -53,9 +70,13 @@ type Messages struct { log *slog.Logger downUntil atomic.Int64 + // loaded: долг инвалидации из Outbox прочитан. До этого любой чат может + // иметь устаревшую версию, поэтому все чтения идут мимо кэша. + loaded atomic.Bool mu sync.Mutex - pending map[string]struct{} + pending map[string]pendingEntry + seq uint64 stop chan struct{} done chan struct{} } @@ -85,10 +106,11 @@ func New(src Source, rdb *redis.Client, opt Options) *Messages { rdb: rdb, opt: opt, log: opt.Logger, - pending: make(map[string]struct{}), + pending: make(map[string]pendingEntry), stop: make(chan struct{}), done: make(chan struct{}), } + m.loaded.Store(opt.Outbox == nil || opt.Mode != ModeSafe) go m.retryLoop() return m } @@ -136,7 +158,7 @@ func (m *Messages) AddMessage(ctx context.Context, callerID, chatID, text string case ModeSafe: if err := m.rdb.Del(ictx, verKey(chatID)).Err(); err != nil { m.markDown(err) - m.addPending(chatID) + m.addPending(ictx, chatID) } } return msg, nil @@ -285,15 +307,39 @@ func (m *Messages) fill(ctx context.Context, key, chatID, cursor string, limit i return page, nil } -func (m *Messages) addPending(chatID string) { +// addPending вызывается до ответа 201: после него чат читается мимо кэша, +// пока версия не будет сброшена, в том числе после рестарта API. +func (m *Messages) addPending(ctx context.Context, chatID string) { + m.markPending(chatID, 0) + if m.opt.Outbox == nil { + m.log.Warn("history cache invalidation deferred", slog.String("chat_id", chatID)) + return + } + gen, err := m.opt.Outbox.AddPendingInvalidation(ctx, chatID) + if err != nil { + m.log.Error("history cache invalidation deferred in memory only, lost on restart", + slog.String("chat_id", chatID), slog.Any("err", err)) + return + } + m.markPending(chatID, gen) + m.log.Warn("history cache invalidation deferred", + slog.String("chat_id", chatID), slog.Int64("gen", gen)) +} + +// markPending всегда выдаёт новый seq, чтобы повтор, начатый раньше, не снял +// запись. gen не уменьшается. +func (m *Messages) markPending(chatID string, gen int64) { m.mu.Lock() - m.pending[chatID] = struct{}{} + m.seq++ + e := m.pending[chatID] + e.seq = m.seq + e.gen = max(e.gen, gen) + m.pending[chatID] = e m.mu.Unlock() - m.log.Warn("history cache invalidation deferred", slog.String("chat_id", chatID)) } func (m *Messages) bypass(chatID string) bool { - if m.isDown() { + if m.isDown() || !m.loaded.Load() { return true } m.mu.Lock() @@ -302,36 +348,70 @@ func (m *Messages) bypass(chatID string) bool { return ok } +func (m *Messages) loadPending() { + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + rows, err := m.opt.Outbox.PendingInvalidations(ctx) + if err != nil { + m.log.Warn("history cache: pending invalidations not loaded, bypassing", slog.Any("err", err)) + return + } + for id, gen := range rows { + m.markPending(id, gen) + } + m.loaded.Store(true) + if len(rows) > 0 { + m.log.Info("history cache: pending invalidations loaded", slog.Int("chats", len(rows))) + } +} + func (m *Messages) retryLoop() { defer close(m.done) t := time.NewTicker(retryInterval) defer t.Stop() for { + if !m.loaded.Load() { + m.loadPending() + } + m.retryPending() select { case <-m.stop: return case <-t.C: } - m.mu.Lock() - chats := make([]string, 0, len(m.pending)) - for id := range m.pending { - chats = append(chats, id) - } - m.mu.Unlock() - for _, id := range chats { - ctx, cancel := context.WithTimeout(context.Background(), time.Second) - err := m.rdb.Del(ctx, verKey(id)).Err() - cancel() - if err != nil { - break - } - m.mu.Lock() - delete(m.pending, id) - m.mu.Unlock() - } } } +func (m *Messages) retryPending() { + m.mu.Lock() + chats := make(map[string]pendingEntry, len(m.pending)) + for id, e := range m.pending { + chats[id] = e + } + m.mu.Unlock() + for id, e := range chats { + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + err := m.rdb.Del(ctx, verKey(id)).Err() + if err == nil && e.gen > 0 { + err = m.opt.Outbox.ResolvePendingInvalidation(ctx, id, e.gen) + } + cancel() + if err != nil { + return + } + m.resolved(id, e) + } +} + +// resolved снимает запись, если после снимка e не было нового сбоя. +func (m *Messages) resolved(chatID string, e pendingEntry) { + m.mu.Lock() + if m.pending[chatID].seq == e.seq { + delete(m.pending, chatID) + } + m.mu.Unlock() +} + func (m *Messages) isDown() bool { return time.Now().UnixNano() < m.downUntil.Load() } diff --git a/app/internal/cache/history_test.go b/app/internal/cache/history_test.go index 9b91c52..ecfa987 100644 --- a/app/internal/cache/history_test.go +++ b/app/internal/cache/history_test.go @@ -264,3 +264,162 @@ func TestCacheDown_Bypass(t *testing.T) { t.Fatalf("обход кэша не должен пропускать постороннего: %v", err) } } + +type fakeOutbox struct { + mu sync.Mutex + rows map[string]int64 + seq int64 // как cache_invalidations_gen_seq: gen не повторяется + loadErr error +} + +func (f *fakeOutbox) AddPendingInvalidation(_ context.Context, chatID string) (int64, error) { + f.mu.Lock() + defer f.mu.Unlock() + f.seq++ + f.rows[chatID] = f.seq + return f.seq, nil +} + +func (f *fakeOutbox) PendingInvalidations(context.Context) (map[string]int64, error) { + f.mu.Lock() + defer f.mu.Unlock() + if f.loadErr != nil { + return nil, f.loadErr + } + out := make(map[string]int64, len(f.rows)) + for k, v := range f.rows { + out[k] = v + } + return out, nil +} + +func (f *fakeOutbox) ResolvePendingInvalidation(_ context.Context, chatID string, gen int64) error { + f.mu.Lock() + defer f.mu.Unlock() + if f.rows[chatID] == gen { + delete(f.rows, chatID) + } + return nil +} + +func (f *fakeOutbox) len() int { + f.mu.Lock() + defer f.mu.Unlock() + return len(f.rows) +} + +// Сброс версии не удался, процесс API перезапущен: новый процесс не знает о +// долге из памяти, но обязан отдать подтверждённое сообщение сразу. +func TestReadAfterWrite_InvalidationFailedThenRestart(t *testing.T) { + ctx := context.Background() + c := testClient(t) + src := &fakeSource{} + outbox := &fakeOutbox{rows: map[string]int64{}} + chat := "chat-restart" + opts := Options{ + Mode: ModeSafe, + Outbox: outbox, + PageTTL: time.Minute, + Logger: slog.New(slog.NewTextHandler(io.Discard, nil)), + } + + warm := New(src, c, opts) + if _, err := warm.ListMessages(ctx, member, chat, "", 50); err != nil { + t.Fatal(err) + } + warm.Close() + + dead := redis.NewClient(&redis.Options{ + Addr: "127.0.0.1:1", DialTimeout: 50 * time.Millisecond, MaxRetries: -1, + }) + t.Cleanup(func() { dead.Close() }) + before := New(src, dead, opts) + msg, err := before.AddMessage(ctx, member, chat, "подтверждено 201") + if err != nil { + t.Fatal(err) + } + before.Close() // рестарт: память процесса потеряна, старая версия в Valkey жива + if outbox.len() != 1 { + t.Fatalf("долг инвалидации не записан в Outbox") + } + + after := New(src, c, opts) + t.Cleanup(after.Close) + page, err := after.ListMessages(ctx, member, chat, "", 50) + if err != nil || !contains(page, msg.ID) { + t.Fatalf("после рестарта подтверждённое сообщение не видно: err=%v", err) + } + + deadline := time.Now().Add(2 * time.Second) + for outbox.len() != 0 || after.bypass(chat) { + if time.Now().After(deadline) { + t.Fatal("отложенная инвалидация не выполнена после рестарта") + } + time.Sleep(20 * time.Millisecond) + } + for i := 0; i < 2; i++ { // промах, затем попадание с новой версией + page, err = after.ListMessages(ctx, member, chat, "", 50) + if err != nil || !contains(page, msg.ID) { + t.Fatalf("чтение через кэш после инвалидации: err=%v", err) + } + } +} + +func TestBypassUntilOutboxLoaded(t *testing.T) { + outbox := &fakeOutbox{rows: map[string]int64{}, loadErr: errors.New("db down")} + h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{ + Mode: ModeSafe, + Outbox: outbox, + Logger: slog.New(slog.NewTextHandler(io.Discard, nil)), + }) + defer h.Close() + time.Sleep(3 * retryInterval) + if !h.bypass("any") { + t.Fatal("пока долг из Outbox не прочитан, кэш не должен отдавать страницы") + } + outbox.mu.Lock() + outbox.loadErr = nil + outbox.mu.Unlock() + deadline := time.Now().Add(2 * time.Second) + for h.bypass("any") { + if time.Now().After(deadline) { + t.Fatal("после загрузки Outbox чтение через кэш не включилось") + } + time.Sleep(20 * time.Millisecond) + } +} + +// Повтор сбросил версию и снял строку Outbox, но до того, как он снял запись +// из памяти, новая запись снова не смогла сбросить версию. Запись в памяти и +// строка Outbox должны остаться, иначе ответ 201 придёт при устаревшем кэше. +func TestRetryDoesNotDropNewerFailure(t *testing.T) { + ctx := context.Background() + outbox := &fakeOutbox{rows: map[string]int64{}} + h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{ + Mode: ModeSafe, + Outbox: outbox, + Logger: slog.New(slog.NewTextHandler(io.Discard, nil)), + }) + h.Close() // повтор ведём вручную + h.loaded.Store(true) + chat := "chat-retry-race" + + h.addPending(ctx, chat) + snap := h.pending[chat] // снимок повтора; DEL версии прошёл + if err := outbox.ResolvePendingInvalidation(ctx, chat, snap.gen); err != nil { + t.Fatal(err) + } + h.addPending(ctx, chat) // новый сбой DEL до ответа 201 + h.resolved(chat, snap) + + if !h.bypass(chat) { + t.Fatal("повтор снял запись о более новом сбое") + } + if rows, _ := outbox.PendingInvalidations(ctx); rows[chat] <= snap.gen { + t.Fatalf("строка Outbox: gen=%d, ожидался новый gen > %d", rows[chat], snap.gen) + } + h.resolved(chat, h.pending[chat]) + if h.bypass(chat) { + t.Fatal("актуальный повтор должен снять запись") + } +} diff --git a/app/internal/store/db/integration_test.go b/app/internal/store/db/integration_test.go index b688b64..975d563 100644 --- a/app/internal/store/db/integration_test.go +++ b/app/internal/store/db/integration_test.go @@ -175,3 +175,45 @@ func TestNULRoundTrip(t *testing.T) { } } } + +func TestPendingInvalidationCAS(t *testing.T) { + d, _ := testDB(t) + ctx := context.Background() + u, _ := d.CreateUser(ctx, "pi_"+suffix(), "U", "$argon2id$test") + chat, err := d.CreateChat(ctx, u.ID, "pi-"+suffix(), []string{u.ID}) + if err != nil { + t.Fatal(err) + } + g1, err := d.AddPendingInvalidation(ctx, chat.ID) + if err != nil { + t.Fatal(err) + } + g2, err := d.AddPendingInvalidation(ctx, chat.ID) + if err != nil || g2 <= g1 { + t.Fatalf("gen %d → %d, err=%v; ожидался рост", g1, g2, err) + } + // Повтор, начатый до второго сбоя, не должен снять новый долг. + if err := d.ResolvePendingInvalidation(ctx, chat.ID, g1); err != nil { + t.Fatal(err) + } + rows, err := d.PendingInvalidations(ctx) + if err != nil || rows[chat.ID] != g2 { + t.Fatalf("после устаревшего resolve: %v, err=%v; ожидался gen %d", rows[chat.ID], err, g2) + } + if err := d.ResolvePendingInvalidation(ctx, chat.ID, g2); err != nil { + t.Fatal(err) + } + rows, _ = d.PendingInvalidations(ctx) + if _, ok := rows[chat.ID]; ok { + t.Fatal("актуальный resolve не удалил запись") + } + // Новый сбой после удаления строки: gen не начинается заново, иначе + // запоздалый повтор с g1 снял бы и его. + g3, err := d.AddPendingInvalidation(ctx, chat.ID) + if err != nil || g3 <= g2 { + t.Fatalf("gen после удаления строки = %d, err=%v; ожидался > %d", g3, err, g2) + } + if err := d.ResolvePendingInvalidation(ctx, chat.ID, g3); err != nil { + t.Fatal(err) + } +} diff --git a/app/internal/store/db/invalidations.go b/app/internal/store/db/invalidations.go new file mode 100644 index 0000000..eeba7bd --- /dev/null +++ b/app/internal/store/db/invalidations.go @@ -0,0 +1,63 @@ +package db + +import ( + "context" + + "github.com/jackc/pgx/v5" +) + +// AddPendingInvalidation фиксирует, что версия кэша чата не сброшена. +// Возвращает поколение записи для последующего compare-and-delete. +func (m *Messages) AddPendingInvalidation(ctx context.Context, chatID string) (int64, error) { + ctx, cancel := m.withTimeout(ctx) + defer cancel() + + var gen int64 + err := m.pool.QueryRow(ctx, ` + INSERT INTO cache_invalidations (chat_id) VALUES ($1) + ON CONFLICT (chat_id) DO UPDATE + SET gen = nextval('cache_invalidations_gen_seq'), updated_at = now() + RETURNING gen`, + chatID, + ).Scan(&gen) + if err != nil { + return 0, mapErr(err) + } + return gen, nil +} + +func (m *Messages) PendingInvalidations(ctx context.Context) (map[string]int64, error) { + ctx, cancel := m.withTimeout(ctx) + defer cancel() + + rows, err := m.pool.Query(ctx, `SELECT chat_id::text, gen FROM cache_invalidations`) + if err != nil { + return nil, mapErr(err) + } + out := map[string]int64{} + var ( + id string + gen int64 + ) + _, err = pgx.ForEachRow(rows, []any{&id, &gen}, func() error { + out[id] = gen + return nil + }) + if err != nil { + return nil, mapErr(err) + } + return out, nil +} + +// ResolvePendingInvalidation удаляет запись, только если с момента чтения +// не случилось нового сбоя (gen не изменился). +func (m *Messages) ResolvePendingInvalidation(ctx context.Context, chatID string, gen int64) error { + ctx, cancel := m.withTimeout(ctx) + defer cancel() + + _, err := m.pool.Exec(ctx, + `DELETE FROM cache_invalidations WHERE chat_id = $1 AND gen = $2`, + chatID, gen, + ) + return mapErr(err) +} diff --git a/evidence/failures.txt b/evidence/failures.txt index 55f55da..0386070 100644 --- a/evidence/failures.txt +++ b/evidence/failures.txt @@ -1,38 +1,40 @@ -# sh scripts/failures-tests.sh (2026-10-29T07:49:41Z, Darwin arm64, Docker 29.2.1) +# sh scripts/failures-tests.sh (2026-10-29T12:08:14Z, Darwin arm64, Docker 29.2.1) === RUN TestFailures === RUN TestFailures/неверный_пароль_→_401_Basic,_неотличим_от_неизвестного_username - failures_test.go:180: статусы 401/401, challenge "Basic realm=\"messenger\", charset=\"UTF-8\"" + failures_test.go:197: статусы 401/401, challenge "Basic realm=\"messenger\", charset=\"UTF-8\"" === RUN TestFailures/X-User-Id_без_Bearer_→_401 - failures_test.go:192: status 401 + failures_test.go:209: status 401 === RUN TestFailures/Basic_на_бизнес-endpoint_→_401 - failures_test.go:200: status 401 + failures_test.go:217: status 401 === RUN TestFailures/logout_→_204,_тот_же_токен_→_401,_повторный_logout_→_401,_другая_сессия_жива - failures_test.go:214: статусы [204 401 401 200] + failures_test.go:231: статусы [204 401 401 200] === RUN TestFailures/expiry_при_SESSION_TTL_SECONDS=2:_200_сразу,_401_через_3_с - failures_test.go:243: expires_at через 1.5 с, статусы 200 → 401 + failures_test.go:259: expires_at через 1.1 с, статусы 200 → 401 === RUN TestFailures/Valkey_сессий_остановлен:_Bearer_→_503,_без_токена_→_401,_вход_→_503,_ready_→_503 - failures_test.go:258: me 503, anon 401, login 503, ready 503 + failures_test.go:273: me 503, anon 401, login 503, ready 503 === RUN TestFailures/Valkey_сессий_восстановлен:_прежний_токен_снова_действителен_(AOF) - failures_test.go:269: ready через 0.1 с после start, me 200 + failures_test.go:284: ready через 0.1 с после start, me 200 === RUN TestFailures/PostgreSQL_остановлен:_чтение/запись_→_503_без_деталей,_ready_→_503 - failures_test.go:287: list 503 (кэш может отдать страницу), send 503, ready 503, утечка деталей: false + failures_test.go:301: list 503 (кэш может отдать страницу), send 503, ready 503, утечка деталей: false === RUN TestFailures/PostgreSQL_восстановлен:_запись_201_тем_же_токеном - failures_test.go:300: ready через 0.6 с после start, send 201 + failures_test.go:314: ready через 0.6 с после start, send 201 === RUN TestFailures/Valkey-кэш_остановлен:_ready_200,_запись_201,_чтение_200_из_PostgreSQL_с_новым_сообщением - failures_test.go:316: ready 200, send 201, list 200, сообщений 2 + failures_test.go:328: ready 200, send 201, list 200, сообщений 2 === RUN TestFailures/Valkey-кэш_восстановлен:_история_полная_и_одинаковая_при_промахе_и_попадании - failures_test.go:329: статусы 200/200, сообщений 2 ---- PASS: TestFailures (28.04s) + failures_test.go:341: статусы 200/200, сообщений 2 +=== RUN TestFailures/инвалидация_не_удалась,_API_перезапущен:_сообщение_с_201_сразу_видно_в_истории +--- PASS: TestFailures (34.73s) --- PASS: TestFailures/неверный_пароль_→_401_Basic,_неотличим_от_неизвестного_username (0.04s) --- PASS: TestFailures/X-User-Id_без_Bearer_→_401 (0.00s) --- PASS: TestFailures/Basic_на_бизнес-endpoint_→_401 (0.00s) --- PASS: TestFailures/logout_→_204,_тот_же_токен_→_401,_повторный_logout_→_401,_другая_сессия_жива (0.02s) - --- PASS: TestFailures/expiry_при_SESSION_TTL_SECONDS=2:_200_сразу,_401_через_3_с (17.30s) + --- PASS: TestFailures/expiry_при_SESSION_TTL_SECONDS=2:_200_сразу,_401_через_3_с (17.20s) --- PASS: TestFailures/Valkey_сессий_остановлен:_Bearer_→_503,_без_токена_→_401,_вход_→_503,_ready_→_503 (0.43s) --- PASS: TestFailures/Valkey_сессий_восстановлен:_прежний_токен_снова_действителен_(AOF) (0.14s) - --- PASS: TestFailures/PostgreSQL_остановлен:_чтение/запись_→_503_без_деталей,_ready_→_503 (0.25s) - --- PASS: TestFailures/PostgreSQL_восстановлен:_запись_201_тем_же_токеном (0.64s) - --- PASS: TestFailures/Valkey-кэш_остановлен:_ready_200,_запись_201,_чтение_200_из_PostgreSQL_с_новым_сообщением (0.33s) + --- PASS: TestFailures/PostgreSQL_остановлен:_чтение/запись_→_503_без_деталей,_ready_→_503 (0.23s) + --- PASS: TestFailures/PostgreSQL_восстановлен:_запись_201_тем_же_токеном (0.65s) + --- PASS: TestFailures/Valkey-кэш_остановлен:_ready_200,_запись_201,_чтение_200_из_PostgreSQL_с_новым_сообщением (0.31s) --- PASS: TestFailures/Valkey-кэш_восстановлен:_история_полная_и_одинаковая_при_промахе_и_попадании (7.15s) + --- PASS: TestFailures/инвалидация_не_удалась,_API_перезапущен:_сообщение_с_201_сразу_видно_в_истории (6.78s) PASS -ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/e2e 28.195s +ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/e2e 35.042s diff --git a/evidence/integration-tests.txt b/evidence/integration-tests.txt index 10db338..e21044c 100644 --- a/evidence/integration-tests.txt +++ b/evidence/integration-tests.txt @@ -3,19 +3,21 @@ --- PASS: TestUsernameRace (0.02s) === RUN TestCreateChatRollback integration_test.go:116: неизвестный участник → 400, chats/chat_members без изменений; валидный вызов создаёт 1 чат ---- PASS: TestCreateChatRollback (0.01s) +--- PASS: TestCreateChatRollback (0.02s) === RUN TestMessageRequiresMembership --- PASS: TestMessageRequiresMembership (0.01s) === RUN TestNULRoundTrip ---- PASS: TestNULRoundTrip (0.07s) +--- PASS: TestNULRoundTrip (0.08s) +=== RUN TestPendingInvalidationCAS +--- PASS: TestPendingInvalidationCAS (0.01s) PASS -ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db 0.861s +ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db 0.316s === RUN TestReadAfterWrite_FillRace === RUN TestReadAfterWrite_FillRace/naive history_test.go:141: naive: чтение после подтверждённой записи stale=true === RUN TestReadAfterWrite_FillRace/safe history_test.go:141: safe: чтение после подтверждённой записи stale=false ---- PASS: TestReadAfterWrite_FillRace (0.33s) +--- PASS: TestReadAfterWrite_FillRace (0.32s) --- PASS: TestReadAfterWrite_FillRace/naive (0.11s) --- PASS: TestReadAfterWrite_FillRace/safe (0.22s) === RUN TestStampede_SQLCount @@ -23,8 +25,8 @@ ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db 0 history_test.go:184: naive: 50 одновременных промахов → 50 запросов страницы в БД === RUN TestStampede_SQLCount/safe history_test.go:184: safe: 50 одновременных промахов → 1 запросов страницы в БД ---- PASS: TestStampede_SQLCount (0.13s) - --- PASS: TestStampede_SQLCount/naive (0.07s) +--- PASS: TestStampede_SQLCount (0.14s) + --- PASS: TestStampede_SQLCount/naive (0.08s) --- PASS: TestStampede_SQLCount/safe (0.06s) === RUN TestAccessCheckedBeforeCache --- PASS: TestAccessCheckedBeforeCache (0.01s) @@ -32,5 +34,11 @@ ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db 0 --- PASS: TestCacheLossIsOnlyMiss (0.01s) === RUN TestCacheDown_Bypass --- PASS: TestCacheDown_Bypass (0.00s) +=== RUN TestReadAfterWrite_InvalidationFailedThenRestart +--- PASS: TestReadAfterWrite_InvalidationFailedThenRestart (0.03s) +=== RUN TestBypassUntilOutboxLoaded +--- PASS: TestBypassUntilOutboxLoaded (0.81s) +=== RUN TestRetryDoesNotDropNewerFailure +--- PASS: TestRetryDoesNotDropNewerFailure (0.00s) PASS -ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/cache 1.621s +ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/cache 1.637s diff --git a/evidence/migrations.txt b/evidence/migrations.txt index 41a7600..0493027 100644 --- a/evidence/migrations.txt +++ b/evidence/migrations.txt @@ -1,23 +1,25 @@ -# Миграции (2026-10-29T11:33:55Z) +# Миграции (2026-10-29T12:09:22Z) ## 1. С нуля (проект mtusi-lab2-fresh, пустой volume) Container mtusi-lab2-fresh-postgres-1 Healthy volume: mtusi-lab2-fresh_pgdata -2026/10/29 11:34:02 OK 00001_create_users_table.sql (2.16ms) -2026/10/29 11:34:02 OK 00002_create_chats_table.sql (1.07ms) -2026/10/29 11:34:02 OK 00003_create_chat_members_table.sql (1.56ms) -2026/10/29 11:34:02 OK 00004_create_messages_table.sql (1.74ms) -2026/10/29 11:34:02 OK 00005_escape_nul_in_text.sql (1.64ms) -2026/10/29 11:34:02 goose: successfully migrated database to version: 5 - List of relations - Schema | Name | Type | Owner ---------+------------------+-------+----------- - public | chat_members | table | messenger - public | chats | table | messenger - public | goose_db_version | table | messenger - public | messages | table | messenger - public | users | table | messenger -(5 rows) +2026/10/29 12:09:29 OK 00001_create_users_table.sql (1.98ms) +2026/10/29 12:09:29 OK 00002_create_chats_table.sql (1.48ms) +2026/10/29 12:09:29 OK 00003_create_chat_members_table.sql (1.65ms) +2026/10/29 12:09:29 OK 00004_create_messages_table.sql (2.28ms) +2026/10/29 12:09:29 OK 00005_escape_nul_in_text.sql (2.79ms) +2026/10/29 12:09:29 OK 00006_create_cache_invalidations_table.sql (1.8ms) +2026/10/29 12:09:29 goose: successfully migrated database to version: 6 + List of relations + Schema | Name | Type | Owner +--------+---------------------+-------+----------- + public | cache_invalidations | table | messenger + public | chat_members | table | messenger + public | chats | table | messenger + public | goose_db_version | table | messenger + public | messages | table | messenger + public | users | table | messenger +(6 rows) 0|t 1|t @@ -25,12 +27,13 @@ volume: mtusi-lab2-fresh_pgdata 3|t 4|t 5|t +6|t ### повторный migrate на том же свежем volume -2026/10/29 11:34:03 goose: no migrations to run. current version: 5 +2026/10/29 12:09:30 goose: no migrations to run. current version: 6 Volume mtusi-lab2-fresh_pgdata Removed Network mtusi-lab2-fresh_default Removed ## 2. Повторный migrate на рабочем стенде (volume mtusi-lab2_pgdata сохраняется) -до: 54 26 37 95882 -2026/10/29 11:34:04 goose: no migrations to run. current version: 5 -после: 54 26 37 95882 +до: 86 54 66 95925 +2026/10/29 12:09:32 goose: no migrations to run. current version: 6 +после: 86 54 66 95925 diff --git a/migrations/00006_create_cache_invalidations_table.sql b/migrations/00006_create_cache_invalidations_table.sql new file mode 100644 index 0000000..852dddb --- /dev/null +++ b/migrations/00006_create_cache_invalidations_table.sql @@ -0,0 +1,23 @@ +-- Отложенная инвалидация кэша истории. Если после COMMIT сообщения сброс +-- версии чата в Valkey не удался, строка фиксирует долг до ответа 201 и +-- переживает рестарт API. gen берётся из общей последовательности и при +-- каждом новом сбое получает ещё не выданное значение: строку удаляет только +-- тот повтор, который видел актуальный gen (compare-and-delete). Счётчик +-- внутри строки не годится: после удаления строки он начался бы снова с 1. + +-- +goose Up +-- +goose StatementBegin +CREATE SEQUENCE cache_invalidations_gen_seq; + +CREATE TABLE cache_invalidations ( + chat_id uuid PRIMARY KEY REFERENCES chats (id) ON DELETE CASCADE, + gen bigint NOT NULL DEFAULT nextval('cache_invalidations_gen_seq'), + updated_at timestamptz NOT NULL DEFAULT now() +); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS cache_invalidations; +DROP SEQUENCE IF EXISTS cache_invalidations_gen_seq; +-- +goose StatementEnd diff --git a/scripts/integration-tests.sh b/scripts/integration-tests.sh index 79da529..f5804b0 100644 --- a/scripts/integration-tests.sh +++ b/scripts/integration-tests.sh @@ -11,4 +11,4 @@ TEST_HISTORY_CACHE_URL="redis://:$(cat secrets/valkey_cache_password)@127.0.0.1: export TEST_DATABASE_URL TEST_HISTORY_CACHE_URL cd app -exec go test -count=1 -v -run 'TestUsernameRace|TestCreateChatRollback|TestMessageRequiresMembership|TestReadAfterWrite|TestStampede|TestAccessChecked|TestNULRoundTrip|TestCacheLoss|TestCacheDown' ./internal/store/db/ ./internal/cache/ +exec go test -count=1 -v -run 'TestUsernameRace|TestCreateChatRollback|TestMessageRequiresMembership|TestReadAfterWrite|TestStampede|TestAccessChecked|TestNULRoundTrip|TestCacheLoss|TestCacheDown|TestPendingInvalidation|TestBypassUntil|TestRetryDoesNot' ./internal/store/db/ ./internal/cache/ diff --git a/scripts/migrations-check.sh b/scripts/migrations-check.sh index cd24a00..1fa828a 100644 --- a/scripts/migrations-check.sh +++ b/scripts/migrations-check.sh @@ -15,17 +15,17 @@ counts='SELECT (SELECT count(*) FROM users) AS users, (SELECT count(*) FROM chat echo "## 1. С нуля (проект mtusi-lab2-fresh, пустой volume)" fresh up -d --wait postgres 2>&1 | tail -n 1 docker volume ls --filter name=mtusi-lab2-fresh --format "volume: {{.Name}}" - fresh run --rm migrate 2>&1 | grep -E "OK|goose|no migrations" || true + fresh run --rm --build migrate 2>&1 | grep -E " OK | goose: " || true fresh exec -T postgres psql -U messenger -d messenger -c '\dt' fresh exec -T postgres psql -U messenger -d messenger -At -c "SELECT version_id, is_applied FROM goose_db_version ORDER BY id" echo "### повторный migrate на том же свежем volume" - fresh run --rm migrate 2>&1 | grep -E "OK|goose|no migrations" || true + fresh run --rm migrate 2>&1 | grep -E " OK | goose: " || true fresh down -v 2>&1 | tail -n 2 echo echo "## 2. Повторный migrate на рабочем стенде (volume mtusi-lab2_pgdata сохраняется)" echo "до: $(main exec -T postgres psql -U messenger -d messenger -At -F ' ' -c "$counts")" - main run --rm migrate 2>&1 | grep -E "OK|goose|no migrations" || true + main run --rm --build migrate 2>&1 | grep -E " OK | goose: " || true echo "после: $(main exec -T postgres psql -U messenger -d messenger -At -F ' ' -c "$counts")" } > "$OUT" 2>&1 cat "$OUT"