// 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<