Files
upandown/internal/catalog/catalog.go
T
claude BotandClaude Opus 5.5 40c0c4d758 Lot 1 (suite) : paquet catalog et liaison Store <-> PostgreSQL
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
2026-11-20 17:21:46 +01:00

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
}