Lot 2 : comptes partagés dans le catalogue PostgreSQL
- internal/catalog/docs.go : collections de documents JSON (id, data jsonb) modifiées sous verrou consultatif par table, écriture du seul diff, reprise unique d'anciens fichiers (ImportFileOnce), petits blobs. - Migration 002 : tables accounts, tokens, app_settings, app_blobs. - auth.Accounts : UseCatalog ; toutes les modifications passent par une fonction atomique (fichier ou base), la règle du dernier administrateur et le premier administrateur restent vrais entre instances. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
This commit is contained in:
1 parent
40c0c4d758
commit
05edcd6b8e
3 files changed
+294
No files matched your search
@@ -0,0 +1,261 @@
|
||||
package catalog
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"log/slog"
|
||||
"os"
|
||||
"regexp"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
// Collections de documents JSON : tables (id text PRIMARY KEY, data jsonb)
|
||||
// pour les données globales de l'application (comptes, jetons, réglages).
|
||||
// Chaque modification charge la collection sous un verrou consultatif propre
|
||||
// à la table, applique la fonction de l'appelant, puis n'écrit que les
|
||||
// documents ajoutés, modifiés ou supprimés.
|
||||
|
||||
var fieldRe = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9_]*$`)
|
||||
|
||||
func ident(table string) string { return pgx.Identifier{table}.Sanitize() }
|
||||
|
||||
// loadDocs lit toute la collection ; raw reçoit l'encodage Go de chaque
|
||||
// document (pour détecter ensuite ce qui a changé).
|
||||
func loadDocs[T any](ctx context.Context, tx pgx.Tx, table string, raw map[string][]byte) (map[string]*T, error) {
|
||||
rows, err := tx.Query(ctx, "SELECT id, data FROM "+ident(table))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
out := map[string]*T{}
|
||||
for rows.Next() {
|
||||
var id string
|
||||
var b []byte
|
||||
if err := rows.Scan(&id, &b); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v := new(T)
|
||||
if err := json.Unmarshal(b, v); err != nil {
|
||||
return nil, fmt.Errorf("%s/%s : %w", table, id, err)
|
||||
}
|
||||
out[id] = v
|
||||
if raw != nil {
|
||||
if raw[id], err = json.Marshal(v); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// AllDocs renvoie toute la collection.
|
||||
func AllDocs[T any](ctx context.Context, db *DB, table string) (map[string]*T, error) {
|
||||
var out map[string]*T
|
||||
err := db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
var err error
|
||||
out, err = loadDocs[T](ctx, tx, table, nil)
|
||||
return err
|
||||
})
|
||||
return out, err
|
||||
}
|
||||
|
||||
// GetDoc renvoie le document id (nil s'il n'existe pas).
|
||||
func GetDoc[T any](ctx context.Context, db *DB, table, id string) (*T, error) {
|
||||
return findDoc[T](ctx, db, "SELECT data FROM "+ident(table)+" WHERE id = $1", id)
|
||||
}
|
||||
|
||||
// FindDoc renvoie le premier document dont le champ texte field vaut value
|
||||
// (nil si aucun). field est un nom de champ constant (index sur l'expression).
|
||||
func FindDoc[T any](ctx context.Context, db *DB, table, field, value string) (*T, error) {
|
||||
if !fieldRe.MatchString(field) {
|
||||
return nil, fmt.Errorf("champ %q invalide", field)
|
||||
}
|
||||
return findDoc[T](ctx, db, "SELECT data FROM "+ident(table)+" WHERE data->>'"+field+"' = $1 LIMIT 1", value)
|
||||
}
|
||||
|
||||
func findDoc[T any](ctx context.Context, db *DB, sql, arg string) (*T, error) {
|
||||
var b []byte
|
||||
err := db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
b = nil
|
||||
err := tx.QueryRow(ctx, sql, arg).Scan(&b)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
})
|
||||
if err != nil || b == nil {
|
||||
return nil, err
|
||||
}
|
||||
v := new(T)
|
||||
if err := json.Unmarshal(b, v); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// UpdateDocs modifie la collection : fn reçoit tous les documents (qu'elle
|
||||
// peut modifier, ajouter ou supprimer) sous le verrou de la table. Une
|
||||
// erreur de fn annule tout. fn peut être rejouée (voir DB.Tx).
|
||||
func UpdateDocs[T any](ctx context.Context, db *DB, table string, fn func(map[string]*T) error) error {
|
||||
return db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
if err := Lock(ctx, tx, "docs:"+table); err != nil {
|
||||
return err
|
||||
}
|
||||
before := map[string][]byte{}
|
||||
docs, err := loadDocs[T](ctx, tx, table, before)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := fn(docs); err != nil {
|
||||
return err
|
||||
}
|
||||
return writeDocs(ctx, tx, table, before, docs)
|
||||
})
|
||||
}
|
||||
|
||||
func writeDocs[T any](ctx context.Context, tx pgx.Tx, table string, before map[string][]byte, after map[string]*T) error {
|
||||
for id := range before {
|
||||
if _, ok := after[id]; !ok {
|
||||
if _, err := tx.Exec(ctx, "DELETE FROM "+ident(table)+" WHERE id = $1", id); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
for id, v := range after {
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if old, ok := before[id]; ok && bytes.Equal(old, b) {
|
||||
continue
|
||||
}
|
||||
if _, err := tx.Exec(ctx, "INSERT INTO "+ident(table)+" (id, data) VALUES ($1, $2) "+
|
||||
"ON CONFLICT (id) DO UPDATE SET data = EXCLUDED.data", id, b); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReplaceDoc remplace un document existant sans prendre le verrou de la
|
||||
// table (mise à jour légère, par exemple une date de dernière utilisation) ;
|
||||
// un document supprimé entre-temps n'est pas recréé.
|
||||
func ReplaceDoc(ctx context.Context, db *DB, table, id string, v any) error {
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
_, err := tx.Exec(ctx, "UPDATE "+ident(table)+" SET data = $2 WHERE id = $1", id, b)
|
||||
return err
|
||||
})
|
||||
}
|
||||
|
||||
// ImportFileOnce reprend une seule fois (table imports, clé root + kind)
|
||||
// l'ancien fichier file : fn reçoit son contenu dans la transaction, puis le
|
||||
// fichier est renommé en *.imported. Un fichier absent marque simplement la
|
||||
// reprise comme faite.
|
||||
func (db *DB) ImportFileOnce(ctx context.Context, root, kind, file string, fn func(context.Context, pgx.Tx, []byte) error) error {
|
||||
var found bool
|
||||
err := db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
found = false
|
||||
if err := Lock(ctx, tx, "import:"+root+":"+kind); err != nil {
|
||||
return err
|
||||
}
|
||||
var done bool
|
||||
if err := tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM imports WHERE root = $1 AND kind = $2)",
|
||||
root, kind).Scan(&done); err != nil || done {
|
||||
return err
|
||||
}
|
||||
b, err := os.ReadFile(file)
|
||||
switch {
|
||||
case errors.Is(err, fs.ErrNotExist):
|
||||
case err != nil:
|
||||
return err
|
||||
default:
|
||||
if err := fn(ctx, tx, b); err != nil {
|
||||
return fmt.Errorf("%s : %w", file, err)
|
||||
}
|
||||
found = true
|
||||
}
|
||||
_, err = tx.Exec(ctx, "INSERT INTO imports (root, kind) VALUES ($1, $2)", root, kind)
|
||||
return err
|
||||
})
|
||||
if err != nil || !found {
|
||||
return err
|
||||
}
|
||||
if err := os.Rename(file, file+".imported"); err != nil && !errors.Is(err, fs.ErrNotExist) {
|
||||
slog.Warn("catalogue : fichier repris non renommé", "fichier", file, "err", err)
|
||||
}
|
||||
slog.Info("catalogue : fichier repris en base", "fichier", file)
|
||||
return nil
|
||||
}
|
||||
|
||||
// InsertDocs ajoute des documents sans écraser ceux qui existent (reprise).
|
||||
func InsertDocs[T any](ctx context.Context, tx pgx.Tx, table string, docs map[string]*T) error {
|
||||
for id, v := range docs {
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.Exec(ctx, "INSERT INTO "+ident(table)+" (id, data) VALUES ($1, $2) ON CONFLICT (id) DO NOTHING", id, b); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Blobs : petits fichiers binaires partagés (logo).
|
||||
|
||||
// GetBlob renvoie le contenu et la version (horodatage) de key, ou nil.
|
||||
func (db *DB) GetBlob(ctx context.Context, key string) ([]byte, int64, error) {
|
||||
var b []byte
|
||||
var v int64
|
||||
err := db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
b, v = nil, 0
|
||||
err := tx.QueryRow(ctx, "SELECT data, (extract(epoch FROM updated) * 1e6)::bigint FROM app_blobs WHERE key = $1", key).Scan(&b, &v)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
})
|
||||
return b, v, err
|
||||
}
|
||||
|
||||
// BlobVersion renvoie la version de key (0 si absent), sans lire le contenu.
|
||||
func (db *DB) BlobVersion(ctx context.Context, key string) (int64, error) {
|
||||
var v int64
|
||||
err := db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
v = 0
|
||||
err := tx.QueryRow(ctx, "SELECT (extract(epoch FROM updated) * 1e6)::bigint FROM app_blobs WHERE key = $1", key).Scan(&v)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
})
|
||||
return v, err
|
||||
}
|
||||
|
||||
// PutBlob enregistre key (data nil : suppression).
|
||||
func (db *DB) PutBlob(ctx context.Context, key string, data []byte) error {
|
||||
return db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
if data == nil {
|
||||
_, err := tx.Exec(ctx, "DELETE FROM app_blobs WHERE key = $1", key)
|
||||
return err
|
||||
}
|
||||
_, err := tx.Exec(ctx, `INSERT INTO app_blobs (key, data, updated) VALUES ($1, $2, clock_timestamp())
|
||||
ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data, updated = EXCLUDED.updated`, key, data)
|
||||
return err
|
||||
})
|
||||
}
|
||||
|
||||
// PutBlobTx : PutBlob dans une transaction existante (reprise).
|
||||
func PutBlobTx(ctx context.Context, tx pgx.Tx, key string, data []byte) error {
|
||||
_, err := tx.Exec(ctx, `INSERT INTO app_blobs (key, data) VALUES ($1, $2) ON CONFLICT (key) DO NOTHING`, key, data)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
-- Données globales partagées par toutes les instances ; data reprend le
|
||||
-- format des anciens fichiers JSON de DATA_DIR.
|
||||
CREATE TABLE accounts (
|
||||
id text PRIMARY KEY,
|
||||
data jsonb NOT NULL
|
||||
);
|
||||
CREATE INDEX accounts_username ON accounts ((data->>'username'));
|
||||
CREATE INDEX accounts_sub ON accounts ((data->>'sub'));
|
||||
|
||||
-- Jetons d'accès (seul leur hachage est conservé).
|
||||
CREATE TABLE tokens (
|
||||
id text PRIMARY KEY,
|
||||
data jsonb NOT NULL
|
||||
);
|
||||
CREATE UNIQUE INDEX tokens_hash ON tokens ((data->>'hash'));
|
||||
|
||||
-- Réglages d'administration (document "settings", format de .settings.json).
|
||||
CREATE TABLE app_settings (
|
||||
id text PRIMARY KEY,
|
||||
data jsonb NOT NULL
|
||||
);
|
||||
|
||||
-- Petits fichiers binaires (logo).
|
||||
CREATE TABLE app_blobs (
|
||||
key text PRIMARY KEY,
|
||||
data bytea NOT NULL,
|
||||
updated timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
Reference in new issue
Block a user