Упростить ошибки сессий, логировать миграции и тестировать с рабочим клиентом Valkey

This commit is contained in:
2026-10-06 15:46:01 +03:00
parent 405fb07608
commit f9850a36c4
7 changed files with 39 additions and 34 deletions
+3 -1
View File
@@ -42,9 +42,11 @@ func run(ctx context.Context, log *slog.Logger, cfg config.Config) error {
return err
}
defer pool.Close()
if err := postgres.Migrate(ctx, pool); err != nil {
applied, err := postgres.Migrate(ctx, pool)
if err != nil {
return err
}
log.Info("schema ready", "applied_migrations", applied)
sessions, err := valkey.NewClient(ctx, cfg.SessionStoreURL)
if err != nil {
return err
+3 -6
View File
@@ -2,19 +2,16 @@ package auth
import (
"context"
"errors"
"github.com/google/uuid"
)
// ErrSessionNotFound means the token is unknown, expired or revoked; the
// store cannot tell these apart, and the client must not either.
var ErrSessionNotFound = errors.New("session not found")
type Repository interface {
// Create stores the session until its absolute ExpiresAt.
Create(ctx context.Context, s Session) error
// UserID returns the owner of a live session or ErrSessionNotFound.
// UserID returns the owner of a live session, or ErrUnauthenticated when
// the token is unknown, expired or revoked: the store cannot tell these
// apart, and the client must not either.
UserID(ctx context.Context, tokenHash string) (uuid.UUID, error)
// Delete revokes the session; deleting a missing one is not an error.
Delete(ctx context.Context, tokenHash string) error
+4 -9
View File
@@ -2,7 +2,6 @@ package auth
import (
"context"
"errors"
"time"
"github.com/google/uuid"
@@ -53,15 +52,11 @@ func (s *Service) Login(ctx context.Context, username, password string) (Issued,
return Issued{Token: token, ExpiresAt: expiresAt, User: u}, nil
}
// Authenticate returns the owner of the token's live session. A store
// failure is returned as is, never as ErrUnauthenticated: an outage must not
// look like a bad token to the client.
// Authenticate returns the owner of the token's live session or
// ErrUnauthenticated. A store failure stays an unavailability, never
// ErrUnauthenticated: an outage must not look like a bad token to the client.
func (s *Service) Authenticate(ctx context.Context, token string) (uuid.UUID, error) {
id, err := s.sessions.UserID(ctx, HashToken(token))
if errors.Is(err, ErrSessionNotFound) {
return uuid.Nil, ErrUnauthenticated
}
return id, err
return s.sessions.UserID(ctx, HashToken(token))
}
func (s *Service) Logout(ctx context.Context, token string) error {
+4 -4
View File
@@ -27,10 +27,10 @@ func NewSessions(client *redis.Client) *Sessions {
return &Sessions{client: client}
}
// Create sets an absolute expiry (PXAT): a restart of the store replays it
// from the append-only file and does not extend the session.
// Create sets an absolute expiry (EXAT/PXAT): a restart of the store replays
// it from the append-only file and does not extend the session.
func (r *Sessions) Create(ctx context.Context, s auth.Session) error {
err := r.client.Do(ctx, "SET", keyPrefix+s.TokenHash, s.UserID.String(), "PXAT", s.ExpiresAt.UnixMilli()).Err()
err := r.client.SetArgs(ctx, keyPrefix+s.TokenHash, s.UserID.String(), redis.SetArgs{ExpireAt: s.ExpiresAt}).Err()
if err != nil {
return unavailable(err)
}
@@ -40,7 +40,7 @@ func (r *Sessions) Create(ctx context.Context, s auth.Session) error {
func (r *Sessions) UserID(ctx context.Context, tokenHash string) (uuid.UUID, error) {
raw, err := r.client.Get(ctx, keyPrefix+tokenHash).Result()
if errors.Is(err, redis.Nil) {
return uuid.Nil, auth.ErrSessionNotFound
return uuid.Nil, auth.ErrUnauthenticated
}
if err != nil {
return uuid.Nil, unavailable(err)
+15 -9
View File
@@ -54,24 +54,30 @@ func NewPool(ctx context.Context, dsn string) (*pgxpool.Pool, error) {
return pool, nil
}
// Migrate applies pending migrations. A session advisory lock serialises
// concurrent starts, so several API replicas may call it at once; applied
// versions are recorded, which makes a repeated run a no-op.
func Migrate(ctx context.Context, pool *pgxpool.Pool) error {
// Migrate applies pending migrations and returns the versions it applied. A
// session advisory lock serialises concurrent starts, so several API
// replicas may call it at once; applied versions are recorded, which makes a
// repeated run a no-op.
func Migrate(ctx context.Context, pool *pgxpool.Pool) ([]int64, error) {
db := stdlib.OpenDBFromPool(pool)
defer db.Close()
locker, err := lock.NewPostgresSessionLocker()
if err != nil {
return fmt.Errorf("migration lock: %w", err)
return nil, fmt.Errorf("migration lock: %w", err)
}
provider, err := goose.NewProvider(goose.DialectPostgres, db, migrations.FS, goose.WithSessionLocker(locker))
if err != nil {
return fmt.Errorf("load migrations: %w", err)
return nil, fmt.Errorf("load migrations: %w", err)
}
if _, err := provider.Up(ctx); err != nil {
return fmt.Errorf("apply migrations: %w", err)
results, err := provider.Up(ctx)
if err != nil {
return nil, fmt.Errorf("apply migrations: %w", err)
}
return nil
applied := make([]int64, 0, len(results))
for _, r := range results {
applied = append(applied, r.Source.Version)
}
return applied, nil
}
// Classify marks a failure to reach the database as apperr.KindUnavailable,
+5 -1
View File
@@ -32,9 +32,13 @@ func TestMain(m *testing.M) {
func TestMigrateIsRepeatable(t *testing.T) {
ctx := context.Background()
if err := postgres.Migrate(ctx, db.Pool); err != nil {
applied, err := postgres.Migrate(ctx, db.Pool)
if err != nil {
t.Fatalf("second migrate: %v", err)
}
if len(applied) != 0 {
t.Fatalf("second migrate applied %v, want nothing", applied)
}
var version int64
if err := db.Pool.QueryRow(ctx, `SELECT max(version_id) FROM goose_db_version`).Scan(&version); err != nil {
t.Fatal(err)
+5 -4
View File
@@ -19,6 +19,7 @@ import (
tcvalkey "github.com/testcontainers/testcontainers-go/modules/valkey"
"messenger/internal/platform/postgres"
"messenger/internal/platform/valkey"
)
const (
@@ -66,7 +67,7 @@ func StartPostgres(ctx context.Context) (*DB, error) {
db.Close()
return nil, err
}
if err := postgres.Migrate(ctx, db.Pool); err != nil {
if _, err := postgres.Migrate(ctx, db.Pool); err != nil {
db.Close()
return nil, err
}
@@ -150,12 +151,12 @@ func StartValkey(ctx context.Context) (*KV, error) {
kv.Close()
return nil, fmt.Errorf("valkey address: %w", err)
}
opts, err := redis.ParseURL(kv.URL)
// The production client, so outage tests see its fail-fast settings.
kv.Client, err = valkey.NewClient(ctx, kv.URL)
if err != nil {
kv.Close()
return nil, fmt.Errorf("valkey url: %w", err)
return nil, err
}
kv.Client = redis.NewClient(opts)
return kv, nil
}