From 596bd9bf8ee11956be4a054bf50d8cba4fd40c21 Mon Sep 17 00:00:00 2001 From: wanderinho Date: Fri, 30 Oct 2026 00:07:19 +0300 Subject: [PATCH] fixes after review --- REPORT.md | 10 +++-- src/api_test.go | 113 ++++++++++++++++++++++++++++++++++++++++++++++++ src/cache.go | 52 ++++++++++++++++------ src/handlers.go | 80 +++++++++++++++++++++++++++++----- src/store.go | 42 +++++++++++++++++- 5 files changed, 266 insertions(+), 31 deletions(-) diff --git a/REPORT.md b/REPORT.md index 1cbc9b56..6d8a14de 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,8 +1,8 @@ # Отчёт — лабораторная 2 - Автор, группа: Стругов Максим БПИ2303 -- Целевая оценка: **4** -- Использованные источники, библиотеки и помощь ИИ: контракт курса (`contracts/openapi.json`, `contracts/README.md`, `contracts/infrastructure.json`); библиотеки — `github.com/jackc/pgx/v5` + `pgxpool` (драйвер и пул соединений PostgreSQL — выбран как актуальный, активно поддерживаемый драйвер с нативным пулом и поддержкой PostgreSQL-типов, рекомендуемый в официальном Go PostgreSQL wiki), `github.com/golang-migrate/migrate/v4` (миграции — стандартный, широко используемый инструмент), `github.com/redis/go-redis/v9`, `golang.org/x/crypto/argon2` (KDF паролей). Миграции хранятся как `.sql`-файлы, встроенные в бинарь через `//go:embed` (источник `iofs` для `golang-migrate`) — это не свой раннер, просто способ доставки файлов миграций без зависимости от файловой системы хоста. +- Целевая оценка **4** +- Использованные источники, библиотеки и помощь ИИ: контракт курса (`contracts/openapi.json`, `contracts/README.md`, `contracts/infrastructure.json`); реализация написана с помощью Claude (Anthropic); библиотеки — `github.com/jackc/pgx/v5` + `pgxpool` (драйвер и пул соединений PostgreSQL — выбран как актуальный, активно поддерживаемый драйвер с нативным пулом и поддержкой PostgreSQL-типов, рекомендуемый в официальном Go PostgreSQL wiki), `github.com/golang-migrate/migrate/v4` (миграции — стандартный, широко используемый инструмент), `github.com/redis/go-redis/v9`, `golang.org/x/crypto/argon2` (KDF паролей). Миграции хранятся как `.sql`-файлы, встроенные в бинарь через `//go:embed` (источник `iofs` для `golang-migrate`) — это не свой раннер, просто способ доставки файлов миграций без зависимости от файловой системы хоста. ## Запуск из чистого clone @@ -71,6 +71,8 @@ Prerequisites: Docker + Docker Compose v2. | Redis как кэш сессий (уровень 4) | `go test` | `TestSessionCacheHitMatchesDatabase`, `TestSessionCacheInvalidatedOnLogout` — пройдены | `src/api_test.go`, `src/cache.go` | | Устойчивость к падению Redis (уровень 4) | `go test` | `TestSessionValidationSurvivesRedisOutage` — действительная сессия продолжает проверяться напрямую в Postgres, Redis-ошибка никогда не трактуется как «сессия валидна» | `src/api_test.go` | | Устойчивость к падению Postgres | `go test` | `TestReadyAndAuthReturnUnavailableWhenPostgresDown` — `/health/ready` и защищённые endpoint отдают `503`, а не ложный `200`/анонимный доступ | `src/api_test.go` | +| Отзыв токена при отказе Redis | `go test` | `TestRevokedTokenRejectedWhenRedisDelFails` (ACL `-del`: надгробие), `TestRevokedTokenRejectedWhenRedisDelAndSetFail` (ACL `-del -set`: локальный deny-list): после logout чтение истории, `GET /users/me` и отправка сообщения → `401` | `src/api_test.go`, `src/cache.go`, `src/store.go` | +| Отказ PostgreSQL при прогретой сессии | `go test` | `TestPostgresDownWithWarmSessionReturns503`: история, отправка, список чатов, `GET /chats/{id}` и вход (Basic) → `503 unavailable`, не `404`/`500`; анонимного доступа нет | `src/api_test.go`, `src/handlers.go` | | Race на регистрацию username (уровень 4) | `go test -race` | 10 конкурентных регистраций одного username → ровно одна `201`, остальные `409` (защита на `UNIQUE INDEX`, не app-level) | `src/api_test.go` | | Атомарность создания чата + rollback на неизвестного участника (уровень 4) | `go test` | Прямой `SELECT count(*) FROM chats WHERE title = $1` в общей тестовой БД подтверждает: при неизвестном `member_id` чат не создаётся вообще | `src/api_test.go` | | Индекс истории обоснован запросом + `EXPLAIN (ANALYZE, BUFFERS)` на ≥10 000 сообщениях (уровень 4) | `psql ... EXPLAIN (ANALYZE, BUFFERS)` | С индексом `messages_chat_created_idx`: `Index Scan`, 0.07–0.10 мс, 3–5 буферных чтений. Без индекса (контрольный замер, индекс восстановлен после): `Seq Scan`+`Sort`, 2.8 мс, 140 буферных чтений (~×28) | `evidence/explain_pagination.txt` | @@ -94,7 +96,9 @@ Prerequisites: Docker + Docker Compose v2. **Выдерживается:** race на регистрацию username; атомарность создания чата с rollback; деградация при падении Redis (без ложного "valid") и при падении Postgres (503, не анонимный доступ); персистентность данных на уровне схемы (обычные таблицы в volume, не in-memory структуры). -**Известное осознанное ограничение:** инвалидация кэша при logout (`cache.del`) не атомарна относительно `revoked_at` в Postgres при временной недоступности Redis — отозванный токен теоретически может ещё немного отвечать из кэша как «валиден». Это не может продлить жизнь токена дольше его реального `SESSION_TTL_SECONDS` (TTL записи в кэше всегда ограничен *оставшимся* сроком жизни сессии, не фиксированным TTL), и описано здесь явно, а не скрыто. +**Отзыв токена не зависит от успеха операций с Redis.** Порядок logout: (1) `revoked_at` в PostgreSQL (источник истины); (2) инвалидация кэша — `DEL`; если `DEL` не прошёл (отказ связи, ACL `-del`) — запись заменяется «надгробием» (`revoked=true`) обычным `SET`, и чтение, увидев надгробие, не доверяет кэшу, а идёт в PostgreSQL; (3) если не прошёл и `SET` — токен попадает в локальный in-memory deny-list `Store` и отклоняется с `401` до конца срока сессии. Дополнительно TTL записи кэша ограничен `min(остаток сессии, 1 минута)`, поэтому даже при отказе всех трёх шагов (другая реплика с тем же Redis) окно устаревания не превышает минуту. Прежняя формулировка «осознанного ограничения» (отозванный токен может отвечать из кэша) снята: она была ошибкой, проверяющий воспроизвёл её сценарием `ACL SETUSER default -del`. + +**Остаточный риск, который остаётся:** гонка «запрос прочитал валидную сессию из PostgreSQL → параллельный logout отозвал и инвалидировал кэш → запрос записал в кэш устаревшую запись». Её окно ограничено `cacheMaxTTL` (1 минута), надгробие её не закрывает. **Не реализовано (вне скоупа лабы 2, ожидается в следующих лабах по контракту):** `X-Instance-Id`, `Idempotency-Key`, балансировка нескольких реплик (с лабы 3); вложения (с лабы 4); фоновая обработка (с лабы 5); HTTPS (обязателен с лабы 7). diff --git a/src/api_test.go b/src/api_test.go index fb831166..131ee95e 100644 --- a/src/api_test.go +++ b/src/api_test.go @@ -871,3 +871,116 @@ func TestEmptyListsAreJSONArraysNotNull(t *testing.T) { t.Fatalf(`GET /messages без сообщений: ожидали "items":[] в сыром JSON, получили: %s`, data) } } + +// --- замечания проверяющего: отзыв токена и отказ PostgreSQL ---------------- + +// denyRedisCommands запрещает команды default-пользователю Redis (как в +// сценарии проверяющего: ACL SETUSER default -del) и возвращает их при Cleanup. +func denyRedisCommands(t *testing.T, e *testEnv, cmds ...string) { + t.Helper() + addr := os.Getenv("TEST_CACHE_URL") + if addr == "" { + addr = "redis://localhost:6379/0" + } + opt, err := redis.ParseURL(addr) + if err != nil { + t.Fatal(err) + } + admin := redis.NewClient(opt) + args := []any{"ACL", "SETUSER", "default"} + restore := []any{"ACL", "SETUSER", "default"} + for _, c := range cmds { + args = append(args, "-"+c) + restore = append(restore, "+"+c) + } + if err := admin.Do(context.Background(), args...).Err(); err != nil { + t.Fatalf("ACL SETUSER: %v", err) + } + t.Cleanup(func() { + admin.Do(context.Background(), restore...) + admin.Close() + }) +} + +func assertRevoked(t *testing.T, e *testEnv, a actor, chatID string) { + t.Helper() + e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/users/me", a.token, nil) + e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/chats/"+chatID+"/messages", a.token, nil) + e.expectErr(http.StatusUnauthorized, "unauthorized", "POST", "/api/v1/chats/"+chatID+"/messages", a.token, map[string]string{"text": "после logout"}) +} + +// Logout при запрещённом DEL: Postgres отозван, а кэш не должен отдавать +// токен как валидный (чтение и запись -> 401). +func TestRevokedTokenRejectedWhenRedisDelFails(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) // прогрев кэша + + denyRedisCommands(t, e, "del") + status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil) + if status != http.StatusNoContent { + t.Fatalf("logout: статус %d", status) + } + assertRevoked(t, e, alice, c.ID) +} + +// Худший случай: Redis не даёт ни DEL, ни SET (надгробие) — токен всё равно +// закрыт локальным deny-list. +func TestRevokedTokenRejectedWhenRedisDelAndSetFail(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) + + denyRedisCommands(t, e, "del", "set") + status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil) + if status != http.StatusNoContent { + t.Fatalf("logout: статус %d", status) + } + assertRevoked(t, e, alice, c.ID) +} + +// Отказ PostgreSQL при прогретой (из кэша валидной) сессии: любой защищённый +// endpoint отдаёт 503 unavailable, а не 404/500; анонимного доступа нет. +func TestPostgresDownWithWarmSessionReturns503(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) // кэш прогрет + + // Тот же кэш, но Postgres недоступен. + badDB, err := pgxpool.New(context.Background(), + "postgres://messenger:messenger@127.0.0.1:1/messenger?sslmode=disable&connect_timeout=1") + if err != nil { + t.Fatal(err) + } + t.Cleanup(badDB.Close) + addr := os.Getenv("TEST_CACHE_URL") + if addr == "" { + addr = "redis://localhost:6379/0" + } + cache, err := newSessionCache(addr) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cache.Close() }) + srv := httptest.NewServer((&api{store: NewStore(badDB, cache, time.Hour)}).routes()) + t.Cleanup(srv.Close) + down := &testEnv{t: t, url: srv.URL} + + down.expectErr(http.StatusServiceUnavailable, "unavailable", "GET", "/api/v1/chats/"+c.ID+"/messages", alice.token, nil) + down.expectErr(http.StatusServiceUnavailable, "unavailable", "POST", "/api/v1/chats/"+c.ID+"/messages", alice.token, map[string]string{"text": "x"}) + down.expectErr(http.StatusServiceUnavailable, "unavailable", "GET", "/api/v1/chats", alice.token, nil) + down.expectErr(http.StatusServiceUnavailable, "unavailable", "GET", "/api/v1/chats/"+c.ID, alice.token, nil) + + // Вход (Basic) при недоступной БД — тоже 503, не 500. + status, _, _, err := down.send("POST", "/api/v1/auth/sessions", "", nil, + basicAuthHeader(alice.user.Username, "любой-пароль-12+")) + if err != nil { + t.Fatal(err) + } + if status != http.StatusServiceUnavailable { + t.Fatalf("вход при недоступной БД: статус %d, ожидали 503", status) + } +} diff --git a/src/cache.go b/src/cache.go index 319f8122..6a8e07ac 100644 --- a/src/cache.go +++ b/src/cache.go @@ -29,8 +29,16 @@ type cachedSession struct { DisplayName string `json:"display_name"` CreatedAt string `json:"created_at"` ExpiresAt time.Time `json:"expires_at"` + // Revoked — надгробие, которое ставит logout, если DEL не удался: + // запись нельзя использовать как подтверждение сессии. + Revoked bool `json:"revoked,omitempty"` } +// cacheMaxTTL ограничивает срок жизни записи независимо от срока сессии: +// даже в худшем случае (отказ и DEL, и SET при logout, другая реплика) кэш +// не может дольше этого окна отдавать уже отозванный токен как валидный. +const cacheMaxTTL = time.Minute + func newSessionCache(addr string) (*sessionCache, error) { opt, err := redis.ParseURL(addr) if err != nil { @@ -80,9 +88,8 @@ func (c *sessionCache) get(ctx context.Context, tokenHash []byte) (*cachedSessio return &s, true } -// set пишет запись с TTL, равным ОСТАВШЕМУСЯ сроку жизни сессии (не -// фиксированному SESSION_TTL_SECONDS) — кэш не может продлить сессию -// дольше, чем она реально действует в Postgres. +// set пишет запись с TTL = min(ОСТАВШИЙСЯ срок сессии, cacheMaxTTL) — кэш +// не может продлить сессию дольше, чем она реально действует в Postgres. func (c *sessionCache) set(ctx context.Context, tokenHash []byte, u User, expiresAt time.Time) { if c == nil { return @@ -91,6 +98,9 @@ func (c *sessionCache) set(ctx context.Context, tokenHash []byte, u User, expire if ttl <= 0 { return } + if ttl > cacheMaxTTL { + ttl = cacheMaxTTL + } data, err := json.Marshal(cachedSession{ UserID: u.ID, Username: u.Username, @@ -106,20 +116,34 @@ func (c *sessionCache) set(ctx context.Context, tokenHash []byte, u User, expire } } -// del — явная инвалидация при logout. Если Redis в этот момент недоступен, -// запись просто не удалится из кэша немедленно, но она не переживёт logout -// "навечно": Postgres (источник истины) уже отмечен revoked, а TTL записи -// в Redis всё равно не больше исходного срока сессии — на отозванный токен -// кэш может ответить "валиден" не дольше, чем он был бы валиден и без -// отзыва. Переживший revoke-окно риск — известное и осознанное ограничение, -// описанное в REPORT.md. -func (c *sessionCache) del(ctx context.Context, tokenHash []byte) { +// invalidate — инвалидация записи при logout (Postgres к этому моменту уже +// отмечен revoked). Возвращает true, только если кэш гарантированно больше +// не отдаст токен как «валидный»: +// 1. DEL ключа; если DEL не прошёл (ошибка связи, ACL запрещает DEL...) — +// 2. запись-надгробие (revoked=true) поверх ключа обычным SET: чтение +// видит надгробие и идёт в Postgres, а не доверяет кэшу. +// +// Если не прошло и это — false: вызывающий код обязан закрыть токен иначе +// (локальный deny-list в Store), а не молча оставить кэш «валидным». +func (c *sessionCache) invalidate(ctx context.Context, tokenHash []byte, ttl time.Duration) bool { if c == nil { - return + return true } - if err := c.rdb.Del(ctx, cacheKey(tokenHash)).Err(); err != nil { - slog.Warn("redis del недоступен при logout", "err", err) + key := cacheKey(tokenHash) + err := c.rdb.Del(ctx, key).Err() + if err == nil { + return true } + slog.Warn("redis del не прошёл при logout, ставим надгробие", "err", err) + if ttl <= 0 { + ttl = time.Minute + } + data, _ := json.Marshal(cachedSession{Revoked: true}) + if err := c.rdb.Set(ctx, key, data, ttl).Err(); err != nil { + slog.Error("redis: не удалось ни удалить, ни пометить запись отозванной", "err", err) + return false + } + return true } func (c *sessionCache) Ping(ctx context.Context) error { diff --git a/src/handlers.go b/src/handlers.go index ea49d0bf..ea74efea 100644 --- a/src/handlers.go +++ b/src/handlers.go @@ -1,14 +1,62 @@ package main import ( + "context" "errors" + "io" + "net" "net/http" "strconv" "strings" + + "github.com/jackc/pgx/v5/pgconn" ) type api struct{ store *Store } +// isUnavailable: ошибка означает «зависимость недоступна» (обрыв/отказ +// соединения, таймаут, остановка сервера PostgreSQL), а не логическую +// ошибку запроса или баг. Такие ошибки отдаются как 503, не 404/500. +func isUnavailable(err error) bool { + if err == nil { + return false + } + if errors.Is(err, context.DeadlineExceeded) || + errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) { + return true + } + var netErr net.Error + if errors.As(err, &netErr) { + return true + } + var connErr *pgconn.ConnectError + if errors.As(err, &connErr) { + return true + } + if pgconn.SafeToRetry(err) || pgconn.Timeout(err) { + return true + } + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + // 08 — connection exception, 57P — admin shutdown/crash/cannot connect now, + // 53 — нехватка ресурсов сервера. + c := pgErr.Code + return strings.HasPrefix(c, "08") || strings.HasPrefix(c, "57P") || strings.HasPrefix(c, "53") + } + msg := err.Error() + return strings.Contains(msg, "conn closed") || strings.Contains(msg, "closed pool") +} + +// writeStoreError превращает неожиданную ошибку хранилища в ответ: +// недоступность БД -> 503 unavailable, всё прочее -> 500. +func writeStoreError(w http.ResponseWriter, err error) { + if isUnavailable(err) { + writeError(w, http.StatusServiceUnavailable, "unavailable", "Хранилище недоступно") + return + } + writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") +} + func (a *api) routes() http.Handler { mux := http.NewServeMux() mux.HandleFunc("GET /health/live", a.live) @@ -127,7 +175,7 @@ func (a *api) registerUser(w http.ResponseWriter, r *http.Request) { } hash, err := hashPassword(req.Password) if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } u, err := a.store.CreateUser(r.Context(), req.Username, req.DisplayName, hash) @@ -136,7 +184,7 @@ func (a *api) registerUser(w http.ResponseWriter, r *http.Request) { return } if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } writeJSON(w, http.StatusCreated, u) @@ -161,12 +209,12 @@ func (a *api) createSession(w http.ResponseWriter, r *http.Request) { return } if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } session, err := a.store.CreateSession(r.Context(), u) if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } writeJSON(w, http.StatusCreated, session) @@ -180,7 +228,7 @@ func (a *api) revokeSession(w http.ResponseWriter, r *http.Request) { } token, _ := bearerToken(r) // уже проверен в auth() if err := a.store.RevokeSession(r.Context(), token); err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } w.WriteHeader(http.StatusNoContent) @@ -227,7 +275,7 @@ func (a *api) createChat(w http.ResponseWriter, r *http.Request) { return } if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } writeJSON(w, http.StatusCreated, c) @@ -244,7 +292,7 @@ func (a *api) listChats(w http.ResponseWriter, r *http.Request) { } items, more, err := a.store.ListChats(r.Context(), me.ID, after, limit) if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } var next *string @@ -271,7 +319,7 @@ func (a *api) getChat(w http.ResponseWriter, r *http.Request) { return } if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } writeJSON(w, http.StatusOK, c) @@ -288,7 +336,11 @@ func (a *api) createMessage(w http.ResponseWriter, r *http.Request) { } // Порядок из контракта: аутентификация -> доступ к ресурсу -> валидация тела. if _, err := a.store.GetChat(r.Context(), me.ID, id); err != nil { - writeError(w, http.StatusNotFound, "not_found", "Чат не найден") + if errors.Is(err, errNotFound) { + writeError(w, http.StatusNotFound, "not_found", "Чат не найден") + } else { + writeStoreError(w, err) // отказ БД — 503/500, а не «чата нет» + } return } var req struct { @@ -307,7 +359,7 @@ func (a *api) createMessage(w http.ResponseWriter, r *http.Request) { return } if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } writeJSON(w, http.StatusCreated, m) @@ -323,7 +375,11 @@ func (a *api) listMessages(w http.ResponseWriter, r *http.Request) { return } if _, err := a.store.GetChat(r.Context(), me.ID, id); err != nil { - writeError(w, http.StatusNotFound, "not_found", "Чат не найден") + if errors.Is(err, errNotFound) { + writeError(w, http.StatusNotFound, "not_found", "Чат не найден") + } else { + writeStoreError(w, err) // отказ БД — 503/500, а не «чата нет» + } return } limit, after, ok := pageParams(w, r, "m:"+id) @@ -336,7 +392,7 @@ func (a *api) listMessages(w http.ResponseWriter, r *http.Request) { return } if err != nil { - writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") + writeStoreError(w, err) return } var next *string diff --git a/src/store.go b/src/store.go index 025b8551..50559f6a 100644 --- a/src/store.go +++ b/src/store.go @@ -5,6 +5,7 @@ import ( "encoding/base64" "errors" "strings" + "sync" "time" "github.com/jackc/pgx/v5" @@ -60,6 +61,7 @@ type Store struct { db *pgxpool.Pool cache *sessionCache // nil => кэш не настроен, работаем только с Postgres sessionTTL time.Duration + revoked sync.Map // string(token_hash) -> time.Time: см. denyLocally } func NewStore(db *pgxpool.Pool, cache *sessionCache, sessionTTL time.Duration) *Store { @@ -426,7 +428,13 @@ func (s *Store) ValidateSession(ctx context.Context, token string) (User, bool, defer cancel() hash := hashToken(token) - if cached, hit := s.cache.get(ctx, hash); hit { + // Локальный deny-list: токен, который logout не смог инвалидировать в Redis. + if s.locallyRevoked(hash) { + return User{}, false, nil + } + + // Надгробие (Revoked) не подтверждает сессию — решает Postgres. + if cached, hit := s.cache.get(ctx, hash); hit && !cached.Revoked { if time.Now().UTC().Before(cached.ExpiresAt) { return User{ ID: cached.UserID, @@ -465,10 +473,40 @@ func (s *Store) RevokeSession(ctx context.Context, token string) error { hash); err != nil { return err } - s.cache.del(ctx, hash) + // Postgres уже отозвал токен. Если кэш не удалось инвалидировать ни DEL, + // ни надгробием — закрываем токен локально, а не оставляем «валидным». + if !s.cache.invalidate(ctx, hash, s.sessionTTL) { + s.denyLocally(hash, time.Now().Add(s.sessionTTL)) + } return nil } +// denyLocally/locallyRevoked — in-memory deny-list отозванных токенов на +// случай, когда Redis не позволил инвалидировать запись. Записи живут не +// дольше срока сессии и вычищаются при добавлении новых. +func (s *Store) denyLocally(hash []byte, until time.Time) { + now := time.Now() + s.revoked.Range(func(k, v any) bool { + if now.After(v.(time.Time)) { + s.revoked.Delete(k) + } + return true + }) + s.revoked.Store(string(hash), until) +} + +func (s *Store) locallyRevoked(hash []byte) bool { + v, ok := s.revoked.Load(string(hash)) + if !ok { + return false + } + if time.Now().After(v.(time.Time)) { + s.revoked.Delete(string(hash)) + return false + } + return true +} + // Ready — критична только доступность Postgres: это единственная // зависимость обязательного синхронного пути (без БД ни один endpoint не // может правильно ответить). Redis — не критичен: его отсутствие замедляет