diff --git a/internal/catalog/catalog.go b/internal/catalog/catalog.go new file mode 100644 index 0000000..0b476d6 --- /dev/null +++ b/internal/catalog/catalog.go @@ -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<", "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) +} diff --git a/internal/storage/catalog_test.go b/internal/storage/catalog_test.go new file mode 100644 index 0000000..110ed60 --- /dev/null +++ b/internal/storage/catalog_test.go @@ -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) + } +}