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
This commit is contained in:
1 parent
f8801f00f9
commit
40c0c4d758
3 files changed
+694
No files matched your search
@@ -0,0 +1,196 @@
|
||||
// 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
|
||||
}
|
||||
@@ -0,0 +1,336 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/vblogio/upandown/internal/catalog"
|
||||
)
|
||||
|
||||
// Catalogue PostgreSQL : quand il est configuré, les métadonnées (tags,
|
||||
// icônes, auteurs) et les liens de partage d'un Store sont lus et écrits en
|
||||
// base au lieu de .meta.json et .shares.json, ce qui permet à plusieurs
|
||||
// instances de servir la même arborescence. Chaque modification se fait dans
|
||||
// une transaction protégée par un verrou consultatif par racine : deux
|
||||
// instances qui modifient la même racine passent l'une après l'autre.
|
||||
|
||||
// opTimeout borne une opération sur le catalogue.
|
||||
const opTimeout = 30 * time.Second
|
||||
|
||||
type catalogRef struct {
|
||||
db *catalog.DB
|
||||
root string // "main", "home/<id>", "s3"
|
||||
}
|
||||
|
||||
// UseCatalog branche le Store sur le catalogue sous la clé root. Au premier
|
||||
// branchement d'une racine, ses anciens fichiers .meta.json et .shares.json
|
||||
// sont repris en base puis renommés en *.imported.
|
||||
func (s *Store) UseCatalog(db *catalog.DB, root string) error {
|
||||
c := &catalogRef{db: db, root: root}
|
||||
if err := c.importJSON(s.root); err != nil {
|
||||
return fmt.Errorf("reprise des métadonnées de %s : %w", root, err)
|
||||
}
|
||||
s.metaMu.Lock()
|
||||
s.cat, s.meta = c, nil
|
||||
s.metaMu.Unlock()
|
||||
return nil
|
||||
}
|
||||
|
||||
func ctxOp() (context.Context, context.CancelFunc) {
|
||||
return context.WithTimeout(context.Background(), opTimeout)
|
||||
}
|
||||
|
||||
// --- Métadonnées -------------------------------------------------------------
|
||||
|
||||
func loadMetaTx(ctx context.Context, q pgx.Tx, root string) (map[string]itemMeta, error) {
|
||||
rows, err := q.Query(ctx, `SELECT path, tags, favorite, icon, created, created_by, edited_by
|
||||
FROM item_meta WHERE root = $1`, root)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := map[string]itemMeta{}
|
||||
for rows.Next() {
|
||||
var p string
|
||||
var m itemMeta
|
||||
var created *time.Time
|
||||
if err := rows.Scan(&p, &m.Tags, &m.Favorite, &m.Icon, &created, &m.CreatedBy, &m.EditedBy); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
if len(m.Tags) == 0 {
|
||||
m.Tags = nil
|
||||
}
|
||||
if created != nil {
|
||||
t := created.UTC()
|
||||
m.Created = &t
|
||||
}
|
||||
out[p] = m
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
func (c *catalogRef) readMeta() (map[string]itemMeta, error) {
|
||||
ctx, cancel := ctxOp()
|
||||
defer cancel()
|
||||
var out map[string]itemMeta
|
||||
err := c.db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
var err error
|
||||
out, err = loadMetaTx(ctx, tx, c.root)
|
||||
return err
|
||||
})
|
||||
return out, err
|
||||
}
|
||||
|
||||
func sameMeta(a, b itemMeta) bool {
|
||||
return slices.Equal(a.Tags, b.Tags) && a.Favorite == b.Favorite && a.Icon == b.Icon &&
|
||||
a.CreatedBy == b.CreatedBy && a.EditedBy == b.EditedBy &&
|
||||
((a.Created == nil) == (b.Created == nil)) && (a.Created == nil || a.Created.Equal(*b.Created))
|
||||
}
|
||||
|
||||
func (c *catalogRef) updateMeta(fn func(map[string]itemMeta) (bool, error)) error {
|
||||
ctx, cancel := ctxOp()
|
||||
defer cancel()
|
||||
return c.db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
if err := catalog.Lock(ctx, tx, "meta:"+c.root); err != nil {
|
||||
return err
|
||||
}
|
||||
cur, err := loadMetaTx(ctx, tx, c.root)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
next := make(map[string]itemMeta, len(cur))
|
||||
for k, v := range cur {
|
||||
next[k] = v
|
||||
}
|
||||
changed, err := fn(next)
|
||||
if err != nil || !changed {
|
||||
return err
|
||||
}
|
||||
return writeMetaDiff(ctx, tx, c.root, cur, next)
|
||||
})
|
||||
}
|
||||
|
||||
func writeMetaDiff(ctx context.Context, tx pgx.Tx, root string, cur, next map[string]itemMeta) error {
|
||||
b := &pgx.Batch{}
|
||||
for k := range cur {
|
||||
if m, ok := next[k]; !ok || m.empty() {
|
||||
b.Queue("DELETE FROM item_meta WHERE root = $1 AND path = $2", root, k)
|
||||
}
|
||||
}
|
||||
for k, m := range next {
|
||||
if m.empty() {
|
||||
continue
|
||||
}
|
||||
if old, ok := cur[k]; ok && sameMeta(old, m) {
|
||||
continue
|
||||
}
|
||||
tags := m.Tags
|
||||
if tags == nil {
|
||||
tags = []string{}
|
||||
}
|
||||
b.Queue(`INSERT INTO item_meta (root, path, tags, favorite, icon, created, created_by, edited_by)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
||||
ON CONFLICT (root, path) DO UPDATE SET tags = EXCLUDED.tags, favorite = EXCLUDED.favorite,
|
||||
icon = EXCLUDED.icon, created = EXCLUDED.created, created_by = EXCLUDED.created_by,
|
||||
edited_by = EXCLUDED.edited_by`,
|
||||
root, k, tags, m.Favorite, m.Icon, m.Created, m.CreatedBy, m.EditedBy)
|
||||
}
|
||||
if b.Len() == 0 {
|
||||
return nil
|
||||
}
|
||||
return tx.SendBatch(ctx, b).Close()
|
||||
}
|
||||
|
||||
// --- Liens de partage --------------------------------------------------------
|
||||
|
||||
func loadSharesTx(ctx context.Context, tx pgx.Tx, root string) (map[string]shareDisk, error) {
|
||||
rows, err := tx.Query(ctx, "SELECT id, data FROM shares WHERE root = $1", root)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := map[string]shareDisk{}
|
||||
for rows.Next() {
|
||||
var id string
|
||||
var d shareDisk
|
||||
if err := rows.Scan(&id, &d); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
out[id] = d
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
func (c *catalogRef) readShares() (map[string]shareDisk, error) {
|
||||
ctx, cancel := ctxOp()
|
||||
defer cancel()
|
||||
var out map[string]shareDisk
|
||||
err := c.db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
var err error
|
||||
out, err = loadSharesTx(ctx, tx, c.root)
|
||||
return err
|
||||
})
|
||||
return out, err
|
||||
}
|
||||
|
||||
func (c *catalogRef) editShares(edit func(map[string]shareDisk) (bool, error)) error {
|
||||
ctx, cancel := ctxOp()
|
||||
defer cancel()
|
||||
return c.db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
if err := catalog.Lock(ctx, tx, "shares:"+c.root); err != nil {
|
||||
return err
|
||||
}
|
||||
cur, err := loadSharesTx(ctx, tx, c.root)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
next := make(map[string]shareDisk, len(cur))
|
||||
for k, v := range cur {
|
||||
next[k] = v
|
||||
}
|
||||
changed, err := edit(next)
|
||||
if err != nil || !changed {
|
||||
return err
|
||||
}
|
||||
return writeSharesDiff(ctx, tx, c.root, cur, next)
|
||||
})
|
||||
}
|
||||
|
||||
func writeSharesDiff(ctx context.Context, tx pgx.Tx, root string, cur, next map[string]shareDisk) error {
|
||||
b := &pgx.Batch{}
|
||||
for id := range cur {
|
||||
if _, ok := next[id]; !ok {
|
||||
b.Queue("DELETE FROM shares WHERE id = $1", id)
|
||||
}
|
||||
}
|
||||
for id, d := range next {
|
||||
if old, ok := cur[id]; ok && sameShare(old, d) {
|
||||
continue
|
||||
}
|
||||
b.Queue(`INSERT INTO shares (id, root, data) VALUES ($1, $2, $3)
|
||||
ON CONFLICT (id) DO UPDATE SET root = EXCLUDED.root, data = EXCLUDED.data`, id, root, d)
|
||||
}
|
||||
if b.Len() == 0 {
|
||||
return nil
|
||||
}
|
||||
return tx.SendBatch(ctx, b).Close()
|
||||
}
|
||||
|
||||
func sameShare(a, b shareDisk) bool {
|
||||
ja, _ := json.Marshal(a)
|
||||
jb, _ := json.Marshal(b)
|
||||
return string(ja) == string(jb)
|
||||
}
|
||||
|
||||
// --- Reprise des anciens fichiers JSON --------------------------------------
|
||||
|
||||
// importJSON reprend .meta.json et .shares.json d'un dossier racine, une seule
|
||||
// fois par racine (table imports), sous verrou : deux instances qui démarrent
|
||||
// ensemble ne reprennent pas deux fois.
|
||||
func (c *catalogRef) importJSON(dir string) error {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
|
||||
defer cancel()
|
||||
var imported []string
|
||||
err := c.db.Tx(ctx, func(tx pgx.Tx) error {
|
||||
imported = imported[:0]
|
||||
if err := catalog.Lock(ctx, tx, "import:"+c.root); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, kind := range []string{"meta", "shares"} {
|
||||
var done bool
|
||||
if err := tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM imports WHERE root = $1 AND kind = $2)",
|
||||
c.root, kind).Scan(&done); err != nil {
|
||||
return err
|
||||
}
|
||||
if done {
|
||||
continue
|
||||
}
|
||||
file := metaFile
|
||||
if kind == "shares" {
|
||||
file = sharesFile
|
||||
}
|
||||
b, err := os.ReadFile(filepath.Join(dir, file))
|
||||
switch {
|
||||
case errors.Is(err, fs.ErrNotExist):
|
||||
b = nil
|
||||
case err != nil:
|
||||
return err
|
||||
}
|
||||
if b != nil {
|
||||
if err := importFile(ctx, tx, c.root, kind, file, b); err != nil {
|
||||
return err
|
||||
}
|
||||
imported = append(imported, file)
|
||||
}
|
||||
if _, err := tx.Exec(ctx, "INSERT INTO imports (root, kind) VALUES ($1, $2)", c.root, kind); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, f := range imported {
|
||||
p := filepath.Join(dir, f)
|
||||
if err := os.Rename(p, p+".imported"); err != nil && !errors.Is(err, fs.ErrNotExist) {
|
||||
slog.Warn("catalogue : fichier repris non renommé", "fichier", p, "err", err)
|
||||
}
|
||||
slog.Info("catalogue : fichier repris en base", "racine", c.root, "fichier", f)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func importFile(ctx context.Context, tx pgx.Tx, root, kind, file string, b []byte) error {
|
||||
if kind == "meta" {
|
||||
var d struct {
|
||||
Items map[string]itemMeta `json:"items"`
|
||||
}
|
||||
if err := json.Unmarshal(b, &d); err != nil {
|
||||
return fmt.Errorf("%s : %w", file, err)
|
||||
}
|
||||
cur, err := loadMetaTx(ctx, tx, root)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
next := make(map[string]itemMeta, len(cur)+len(d.Items))
|
||||
for k, v := range cur {
|
||||
next[k] = v
|
||||
}
|
||||
for k, v := range d.Items {
|
||||
if _, ok := next[k]; !ok {
|
||||
next[k] = v
|
||||
}
|
||||
}
|
||||
return writeMetaDiff(ctx, tx, root, cur, next)
|
||||
}
|
||||
var d struct {
|
||||
Links map[string]shareDisk `json:"links"`
|
||||
}
|
||||
if err := json.Unmarshal(b, &d); err != nil {
|
||||
return fmt.Errorf("%s : %w", file, err)
|
||||
}
|
||||
cur, err := loadSharesTx(ctx, tx, root)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
next := make(map[string]shareDisk, len(cur)+len(d.Links))
|
||||
for k, v := range cur {
|
||||
next[k] = v
|
||||
}
|
||||
for k, v := range d.Links {
|
||||
if _, ok := next[k]; !ok {
|
||||
next[k] = v
|
||||
}
|
||||
}
|
||||
return writeSharesDiff(ctx, tx, root, cur, next)
|
||||
}
|
||||
@@ -0,0 +1,162 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/vblogio/upandown/internal/catalog"
|
||||
)
|
||||
|
||||
// Les tests du catalogue PostgreSQL s'exécutent quand
|
||||
// UPANDOWN_TEST_DATABASE_URL est défini ; tous les tests du paquet passent
|
||||
// alors par la base (newStore branche chaque Store sur une racine unique).
|
||||
|
||||
var (
|
||||
testDBOnce sync.Once
|
||||
testDB *catalog.DB
|
||||
testDBErr error
|
||||
)
|
||||
|
||||
func testCatalog(t *testing.T) *catalog.DB {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("UPANDOWN_TEST_DATABASE_URL")
|
||||
if dsn == "" {
|
||||
return nil
|
||||
}
|
||||
testDBOnce.Do(func() {
|
||||
testDB, testDBErr = catalog.Open(context.Background(), dsn, 5*time.Second)
|
||||
})
|
||||
if testDBErr != nil {
|
||||
t.Fatal(testDBErr)
|
||||
}
|
||||
return testDB
|
||||
}
|
||||
|
||||
func uniqueRoot(prefix string) string {
|
||||
b := make([]byte, 6)
|
||||
_, _ = rand.Read(b)
|
||||
return prefix + "-" + hex.EncodeToString(b)
|
||||
}
|
||||
|
||||
func attachTestCatalog(t *testing.T, s *Store) {
|
||||
t.Helper()
|
||||
if db := testCatalog(t); db != nil {
|
||||
if err := s.UseCatalog(db, uniqueRoot("test")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func needCatalog(t *testing.T) *catalog.DB {
|
||||
t.Helper()
|
||||
db := testCatalog(t)
|
||||
if db == nil {
|
||||
t.Skip("UPANDOWN_TEST_DATABASE_URL non défini")
|
||||
}
|
||||
return db
|
||||
}
|
||||
|
||||
// Deux instances (deux Store sur le même dossier et la même racine du
|
||||
// catalogue) voient les modifications l'une de l'autre, sans perte en écriture
|
||||
// concurrente.
|
||||
func TestCatalogSharedBetweenInstances(t *testing.T) {
|
||||
db := needCatalog(t)
|
||||
dir := t.TempDir()
|
||||
root := uniqueRoot("cluster")
|
||||
a, _ := New(dir)
|
||||
b, _ := New(dir)
|
||||
if err := a.UseCatalog(db, root); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := b.UseCatalog(db, root); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for i := 0; i < 20; i++ {
|
||||
put(t, a, "f"+string(rune('a'+i))+".txt", "x", PutOptions{})
|
||||
}
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < 20; i++ {
|
||||
st := a
|
||||
if i%2 == 1 {
|
||||
st = b
|
||||
}
|
||||
wg.Add(1)
|
||||
go func(st *Store, p, tag string) {
|
||||
defer wg.Done()
|
||||
if err := st.EditTags([]string{p}, []string{tag}, nil); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}(st, "f"+string(rune('a'+i))+".txt", "t"+string(rune('a'+i)))
|
||||
}
|
||||
wg.Wait()
|
||||
tags, err := b.Tags()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(tags) != 20 {
|
||||
t.Errorf("%d tags vus par l'autre instance, 20 attendus : %v", len(tags), tags)
|
||||
}
|
||||
if _, err := a.Move("fa.txt", "dossier/fa.txt"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
e, err := b.Stat("dossier/fa.txt")
|
||||
if err != nil || !slices.Equal(e.Tags, []string{"ta"}) {
|
||||
t.Errorf("tags après déplacement vus par l'autre instance : %+v, %v", e, err)
|
||||
}
|
||||
sh, err := a.CreateShare("fb.txt", ShareOptions{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got, err := b.ResolveShare(sh.Token); err != nil || got.Path != "fb.txt" {
|
||||
t.Errorf("lien créé par a, résolu par b : %+v, %v", got, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCatalogImportsJSONOnce(t *testing.T) {
|
||||
db := needCatalog(t)
|
||||
dir := t.TempDir()
|
||||
s, _ := New(dir)
|
||||
put(t, s, "a.txt", "a", PutOptions{By: "alice"})
|
||||
if err := s.EditTags([]string{"a.txt"}, []string{"Ancien"}, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
sh, err := s.CreateShare("a.txt", ShareOptions{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root := uniqueRoot("import")
|
||||
if err := s.UseCatalog(db, root); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
e, err := s.Stat("a.txt")
|
||||
if err != nil || !slices.Equal(e.Tags, []string{"Ancien"}) || e.EditedBy != "alice" {
|
||||
t.Errorf("métadonnées reprises : %+v, %v", e, err)
|
||||
}
|
||||
if _, err := s.ResolveShare(sh.Token); err != nil {
|
||||
t.Errorf("lien repris : %v", err)
|
||||
}
|
||||
for _, f := range []string{metaFile, sharesFile} {
|
||||
if _, err := os.Stat(filepath.Join(dir, f)); err == nil {
|
||||
t.Errorf("%s non renommé", f)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(dir, f+".imported")); err != nil {
|
||||
t.Errorf("%s.imported absent : %v", f, err)
|
||||
}
|
||||
}
|
||||
// Un .meta.json réapparu n'est pas repris une seconde fois.
|
||||
_ = os.WriteFile(filepath.Join(dir, metaFile), []byte(`{"items":{"a.txt":{"tags":["Autre"]}}}`), 0o644)
|
||||
s2, _ := New(dir)
|
||||
if err := s2.UseCatalog(db, root); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if e, _ := s2.Stat("a.txt"); !slices.Equal(e.Tags, []string{"Ancien"}) {
|
||||
t.Errorf("reprise rejouée : %v", e.Tags)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user