Files
mtusi2026lab3/internal/platform/postgres/postgres.go
T

146 lines
4.8 KiB
Go

// Package postgres opens the connection pool and applies the schema.
//
// Server-side timeouts are constants rather than settings: they bound how
// long one request can hold a connection, and the request deadline of the API
// is chosen against them. The pool size is a setting, because the scaling
// study varies it.
package postgres
import (
"context"
"errors"
"fmt"
"io"
"net"
"strconv"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgtype"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/jackc/pgx/v5/stdlib"
"github.com/pressly/goose/v3"
"github.com/pressly/goose/v3/lock"
"messenger/internal/platform/apperr"
"messenger/migrations"
)
const (
connectTimeout = time.Second
statementTimeout = 5 * time.Second
idleInTxTimeout = 10 * time.Second
)
const codeUniqueViolation = "23505"
func NewPool(ctx context.Context, dsn string, maxConns int32) (*pgxpool.Pool, error) {
cfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
return nil, fmt.Errorf("parse database url: %w", err)
}
cfg.MaxConns = maxConns
cfg.ConnConfig.ConnectTimeout = connectTimeout
// Unlike net.Dialer, pgx resolves the host before ConnectTimeout starts.
// Docker DNS takes seconds to give up on a stopped container: unbounded,
// every request would wait out its deadline and log only "context
// deadline exceeded" instead of the failed lookup.
cfg.ConnConfig.LookupFunc = func(ctx context.Context, host string) ([]string, error) {
ctx, cancel := context.WithTimeout(ctx, connectTimeout)
defer cancel()
return net.DefaultResolver.LookupHost(ctx, host)
}
cfg.ConnConfig.RuntimeParams["statement_timeout"] = strconv.FormatInt(statementTimeout.Milliseconds(), 10)
cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = strconv.FormatInt(idleInTxTimeout.Milliseconds(), 10)
// The application keeps every time in UTC; pgx would otherwise scan
// timestamptz into time.Local.
cfg.AfterConnect = func(_ context.Context, conn *pgx.Conn) error {
conn.TypeMap().RegisterType(&pgtype.Type{
Name: "timestamptz",
OID: pgtype.TimestamptzOID,
Codec: &pgtype.TimestamptzCodec{ScanLocation: time.UTC},
})
return nil
}
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, fmt.Errorf("create pool: %w", err)
}
if err := pool.Ping(ctx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping database: %w", err)
}
return pool, nil
}
// 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 nil, fmt.Errorf("migration lock: %w", err)
}
provider, err := goose.NewProvider(goose.DialectPostgres, db, migrations.FS, goose.WithSessionLocker(locker))
if err != nil {
return nil, fmt.Errorf("load migrations: %w", err)
}
results, err := provider.Up(ctx)
if err != nil {
return nil, fmt.Errorf("apply migrations: %w", err)
}
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,
// which the API answers with 503 instead of 500; any other error is returned
// unchanged. Unreachable means: the connection could not be made or broke,
// the request deadline passed, or the server refused work (PostgreSQL error
// classes 08 connection exception, 53 insufficient resources, 57 operator
// intervention such as shutdown or statement timeout).
func Classify(err error) error {
if err == nil || !unreachable(err) {
return err
}
return apperr.Wrap(apperr.KindUnavailable, "database unavailable", err)
}
func unreachable(err error) bool {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
switch class := pgErr.Code[:min(2, len(pgErr.Code))]; class {
case "08", "53", "57":
return true
}
return false
}
if _, ok := errors.AsType[*pgconn.ConnectError](err); ok {
return true
}
if _, ok := errors.AsType[net.Error](err); ok {
return true
}
return errors.Is(err, context.DeadlineExceeded) ||
errors.Is(err, context.Canceled) ||
errors.Is(err, io.EOF) ||
errors.Is(err, io.ErrUnexpectedEOF) ||
errors.Is(err, net.ErrClosed) ||
pgconn.Timeout(err) ||
pgconn.SafeToRetry(err)
}
// IsUniqueViolation reports whether err is a unique violation of the named
// constraint.
func IsUniqueViolation(err error, constraint string) bool {
pgErr, ok := errors.AsType[*pgconn.PgError](err)
return ok && pgErr.Code == codeUniqueViolation && pgErr.ConstraintName == constraint
}