This commit is contained in:
@@ -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).
|
||||
|
||||
|
||||
+113
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
+38
-14
@@ -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 {
|
||||
|
||||
+68
-12
@@ -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
|
||||
|
||||
+40
-2
@@ -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 — не критичен: его отсутствие замедляет
|
||||
|
||||
Reference in New Issue
Block a user