diff --git a/cmd/server/main.go b/cmd/server/main.go index f3ac4f5c..305e4ff2 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -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 diff --git a/internal/auth/repository.go b/internal/auth/repository.go index 1893e795..4a168f59 100644 --- a/internal/auth/repository.go +++ b/internal/auth/repository.go @@ -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 diff --git a/internal/auth/service.go b/internal/auth/service.go index 15ef9abb..458a4744 100644 --- a/internal/auth/service.go +++ b/internal/auth/service.go @@ -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 { diff --git a/internal/auth/store/valkey.go b/internal/auth/store/valkey.go index ff56ad66..ad7a36e1 100644 --- a/internal/auth/store/valkey.go +++ b/internal/auth/store/valkey.go @@ -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) diff --git a/internal/platform/postgres/postgres.go b/internal/platform/postgres/postgres.go index e075fe29..41c61100 100644 --- a/internal/platform/postgres/postgres.go +++ b/internal/platform/postgres/postgres.go @@ -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, diff --git a/internal/platform/postgres/postgres_test.go b/internal/platform/postgres/postgres_test.go index 24ee4b48..4546b370 100644 --- a/internal/platform/postgres/postgres_test.go +++ b/internal/platform/postgres/postgres_test.go @@ -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) diff --git a/internal/testenv/testenv.go b/internal/testenv/testenv.go index 04c9f42d..980d191d 100644 --- a/internal/testenv/testenv.go +++ b/internal/testenv/testenv.go @@ -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 }