Fichiers nouveaux du commit précédent : internal/catalog/catalog.go, internal/storage/catalog.go et ses tests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
197 lines
5.7 KiB
Go
197 lines
5.7 KiB
Go
// Package catalog donne accès à la base PostgreSQL partagée par les instances
|
|
// d'Upandown : pool de connexions, migrations du schéma et transactions
|
|
// rejouées après un conflit ou une bascule du serveur.
|
|
//
|
|
// Compatibilité haute disponibilité : le DSN peut lister plusieurs hôtes
|
|
// (postgres://u:p@pg1,pg2,pg3/upandown?target_session_attrs=read-write) ; pgx
|
|
// se connecte alors au primaire. Après une bascule, les connexions vers
|
|
// l'ancien primaire échouent ou deviennent en lecture seule : le pool est
|
|
// vidé et la transaction est rejouée sur le nouveau primaire.
|
|
package catalog
|
|
|
|
import (
|
|
"context"
|
|
"embed"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"log/slog"
|
|
"net"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgconn"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
//go:embed migrations/*.sql
|
|
var migrations embed.FS
|
|
|
|
// DB est la base du catalogue.
|
|
type DB struct {
|
|
Pool *pgxpool.Pool
|
|
|
|
// Attempts borne le nombre d'essais d'une transaction (5 par défaut).
|
|
Attempts int
|
|
}
|
|
|
|
// migrationLock : clé du verrou consultatif qui sérialise les migrations
|
|
// entre instances qui démarrent en même temps.
|
|
const migrationLock = 0x75706e64 // "upnd"
|
|
|
|
// Open se connecte (en réessayant pendant wait, le temps que le serveur
|
|
// démarre) puis applique les migrations manquantes.
|
|
func Open(ctx context.Context, dsn string, wait time.Duration) (*DB, error) {
|
|
cfg, err := pgxpool.ParseConfig(dsn)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("DATABASE_URL : %w", err)
|
|
}
|
|
pool, err := pgxpool.NewWithConfig(ctx, cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
deadline := time.Now().Add(wait)
|
|
for {
|
|
err = pool.Ping(ctx)
|
|
if err == nil || time.Now().After(deadline) || ctx.Err() != nil {
|
|
break
|
|
}
|
|
slog.Info("catalogue : PostgreSQL injoignable, nouvel essai", "err", err)
|
|
time.Sleep(2 * time.Second)
|
|
}
|
|
if err != nil {
|
|
pool.Close()
|
|
return nil, fmt.Errorf("connexion à PostgreSQL : %w", err)
|
|
}
|
|
db := &DB{Pool: pool, Attempts: 5}
|
|
if err := db.migrate(ctx); err != nil {
|
|
pool.Close()
|
|
return nil, err
|
|
}
|
|
return db, nil
|
|
}
|
|
|
|
// Close ferme le pool.
|
|
func (db *DB) Close() { db.Pool.Close() }
|
|
|
|
// Tx exécute fn dans une transaction, rejouée (avec une attente croissante)
|
|
// après un conflit de sérialisation, un interblocage ou une perte du
|
|
// primaire. fn peut donc être appelée plusieurs fois : elle ne doit pas avoir
|
|
// d'effet hors de la base.
|
|
func (db *DB) Tx(ctx context.Context, fn func(pgx.Tx) error) error {
|
|
attempts := db.Attempts
|
|
if attempts < 1 {
|
|
attempts = 1
|
|
}
|
|
var err error
|
|
for i := 0; i < attempts; i++ {
|
|
if i > 0 {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
case <-time.After(time.Duration(100<<i) * time.Millisecond):
|
|
}
|
|
}
|
|
err = pgx.BeginFunc(ctx, db.Pool, fn)
|
|
if err == nil || !Retryable(err) {
|
|
return err
|
|
}
|
|
if failover(err) {
|
|
db.Pool.Reset() // connexions vers l'ancien primaire
|
|
}
|
|
slog.Warn("catalogue : transaction rejouée", "essai", i+1, "err", err)
|
|
}
|
|
return err
|
|
}
|
|
|
|
// Retryable indique si une erreur justifie de rejouer la transaction.
|
|
func Retryable(err error) bool {
|
|
var pg *pgconn.PgError
|
|
if errors.As(err, &pg) {
|
|
switch {
|
|
case pg.Code == "40001", pg.Code == "40P01": // sérialisation, interblocage
|
|
return true
|
|
case pg.Code == "25006": // lecture seule : on parle à un secondaire
|
|
return true
|
|
case strings.HasPrefix(pg.Code, "57P"), strings.HasPrefix(pg.Code, "08"): // arrêt, connexion
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
return failover(err)
|
|
}
|
|
|
|
// failover reconnaît une connexion perdue ou dirigée vers un secondaire.
|
|
func failover(err error) bool {
|
|
var pg *pgconn.PgError
|
|
if errors.As(err, &pg) {
|
|
return pg.Code == "25006" || strings.HasPrefix(pg.Code, "57P") || strings.HasPrefix(pg.Code, "08")
|
|
}
|
|
var ne net.Error
|
|
return errors.As(err, &ne) || errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) ||
|
|
pgconn.SafeToRetry(err) || pgconn.Timeout(err)
|
|
}
|
|
|
|
// Lock prend, dans la transaction, un verrou consultatif nommé : les
|
|
// transactions qui modifient la même ressource s'exécutent l'une après
|
|
// l'autre, quelle que soit l'instance.
|
|
func Lock(ctx context.Context, tx pgx.Tx, name string) error {
|
|
_, err := tx.Exec(ctx, "SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", name)
|
|
return err
|
|
}
|
|
|
|
func (db *DB) migrate(ctx context.Context) error {
|
|
conn, err := db.Pool.Acquire(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer conn.Release()
|
|
if _, err := conn.Exec(ctx, "SELECT pg_advisory_lock($1)", migrationLock); err != nil {
|
|
return err
|
|
}
|
|
defer conn.Exec(context.Background(), "SELECT pg_advisory_unlock($1)", migrationLock) //nolint:errcheck
|
|
if _, err := conn.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
|
|
version int PRIMARY KEY, applied timestamptz NOT NULL DEFAULT now())`); err != nil {
|
|
return err
|
|
}
|
|
files, err := fs.Glob(migrations, "migrations/*.sql")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sort.Strings(files)
|
|
for _, f := range files {
|
|
base := strings.TrimPrefix(f, "migrations/")
|
|
v, err := strconv.Atoi(strings.SplitN(base, "_", 2)[0])
|
|
if err != nil {
|
|
return fmt.Errorf("migration %s : numéro attendu", base)
|
|
}
|
|
var done bool
|
|
if err := conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM schema_migrations WHERE version = $1)", v).Scan(&done); err != nil {
|
|
return err
|
|
}
|
|
if done {
|
|
continue
|
|
}
|
|
sql, err := migrations.ReadFile(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = pgx.BeginFunc(ctx, conn, func(tx pgx.Tx) error {
|
|
if _, err := tx.Exec(ctx, string(sql)); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.Exec(ctx, "INSERT INTO schema_migrations (version) VALUES ($1)", v)
|
|
return err
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("migration %s : %w", base, err)
|
|
}
|
|
slog.Info("catalogue : migration appliquée", "version", v)
|
|
}
|
|
return nil
|
|
}
|