- Nouveau paquet internal/catalog : pool pgx, migrations SQL embarquées (sérialisées entre instances par verrou consultatif), transactions rejouées après conflit, interblocage ou bascule du primaire (pool vidé sur erreur de lecture seule ou de connexion). DSN multi-hôtes accepté (target_session_attrs=read-write) pour une future HA. - Store.UseCatalog : tags, icônes, auteurs (item_meta) et liens de partage (shares) lus et écrits en base ; chaque modification se fait sous verrou consultatif par racine (« main », « home/<id> »), donc sans perte d'écriture entre instances. Sans DATABASE_URL, rien ne change (JSON). - Reprise unique de .meta.json et .shares.json au premier branchement (table imports), fichiers renommés en *.imported. - Serveur : DATABASE_URL / DATABASE_URL_FILE, DATABASE_WAIT (60 s). - Compose : service postgres:16 sur un réseau interne dédié ; Traefik inchangé. Dockerfile : go.sum et téléchargement des modules. - Tests : UPANDOWN_TEST_DATABASE_URL fait passer toute la suite storage par la base ; tests de partage entre deux instances et de reprise JSON. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
357 lines
8.8 KiB
Go
357 lines
8.8 KiB
Go
package storage
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// Tags et favoris des fichiers et dossiers, et icône des dossiers, dans
|
|
// .meta.json à la racine :
|
|
// {"items":{"a/b.pdf":{"tags":["NSX"],"favorite":true},"a":{"icon":"server"}}}.
|
|
// Ils suivent les renommages, déplacements et suppressions. Les fichiers y
|
|
// gardent aussi leur auteur et leur date de création, et le dernier
|
|
// utilisateur qui les a enregistrés (details.go).
|
|
|
|
const metaFile = ".meta.json"
|
|
|
|
const (
|
|
// MaxTagLen borne la longueur d'un tag (en caractères).
|
|
MaxTagLen = 40
|
|
// MaxTags borne le nombre de tags d'un élément.
|
|
MaxTags = 20
|
|
)
|
|
|
|
type itemMeta struct {
|
|
Tags []string `json:"tags,omitempty"`
|
|
Favorite bool `json:"favorite,omitempty"`
|
|
Icon string `json:"icon,omitempty"` // dossiers : nom d'icône du frontend
|
|
|
|
// Schémas (details.go) : création et dernier enregistrement.
|
|
Created *time.Time `json:"created,omitempty"`
|
|
CreatedBy string `json:"createdBy,omitempty"`
|
|
EditedBy string `json:"editedBy,omitempty"`
|
|
}
|
|
|
|
func (m itemMeta) empty() bool {
|
|
return len(m.Tags) == 0 && !m.Favorite && m.Icon == "" && m.Created == nil && m.CreatedBy == "" && m.EditedBy == ""
|
|
}
|
|
|
|
// iconName : nom d'icône accepté (le frontend affiche le dossier classique
|
|
// pour un nom qu'il ne connaît pas).
|
|
var iconName = regexp.MustCompile(`^[a-z0-9][a-z0-9-]{0,31}$`)
|
|
|
|
// TagCount est un tag utilisé et son nombre d'éléments.
|
|
type TagCount struct {
|
|
Name string `json:"name"`
|
|
Count int `json:"count"`
|
|
}
|
|
|
|
// loadMeta charge .meta.json au premier accès ; appelé sous metaMu.
|
|
func (s *Store) loadMeta() error {
|
|
if s.meta != nil {
|
|
return nil
|
|
}
|
|
var d struct {
|
|
Items map[string]itemMeta `json:"items"`
|
|
}
|
|
b, err := os.ReadFile(filepath.Join(s.root, metaFile))
|
|
switch {
|
|
case errors.Is(err, fs.ErrNotExist):
|
|
case err != nil:
|
|
return err
|
|
default:
|
|
if err := json.Unmarshal(b, &d); err != nil {
|
|
return fmt.Errorf("%s : %w", metaFile, err)
|
|
}
|
|
}
|
|
if d.Items == nil {
|
|
d.Items = map[string]itemMeta{}
|
|
}
|
|
s.meta = d.Items
|
|
return nil
|
|
}
|
|
|
|
// saveMeta écrit .meta.json ; appelé sous metaMu.
|
|
func (s *Store) saveMeta() error {
|
|
for k, m := range s.meta {
|
|
if m.empty() {
|
|
delete(s.meta, k)
|
|
}
|
|
}
|
|
b, err := json.Marshal(map[string]any{"items": s.meta})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return atomicWrite(filepath.Join(s.root, metaFile), b)
|
|
}
|
|
|
|
// metaSnapshot renvoie une copie des métadonnées (pour List et Search) ;
|
|
// vide en cas d'erreur de lecture.
|
|
func (s *Store) metaSnapshot() map[string]itemMeta {
|
|
m, err := s.readMeta()
|
|
if err != nil {
|
|
return map[string]itemMeta{}
|
|
}
|
|
return m
|
|
}
|
|
|
|
// readMeta renvoie une copie des métadonnées de la racine (fichier .meta.json
|
|
// ou catalogue PostgreSQL).
|
|
func (s *Store) readMeta() (map[string]itemMeta, error) {
|
|
if s.cat != nil {
|
|
return s.cat.readMeta()
|
|
}
|
|
s.metaMu.Lock()
|
|
defer s.metaMu.Unlock()
|
|
if err := s.loadMeta(); err != nil {
|
|
return nil, err
|
|
}
|
|
out := make(map[string]itemMeta, len(s.meta))
|
|
for k, v := range s.meta {
|
|
out[k] = v
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// updateMeta applique fn aux métadonnées de la racine sous verrou (verrou du
|
|
// processus, ou verrou consultatif PostgreSQL partagé par les instances) et
|
|
// enregistre le résultat si fn renvoie true. fn reçoit une copie : rien n'est
|
|
// enregistré en cas d'erreur.
|
|
func (s *Store) updateMeta(fn func(map[string]itemMeta) (bool, error)) error {
|
|
if s.cat != nil {
|
|
return s.cat.updateMeta(fn)
|
|
}
|
|
s.metaMu.Lock()
|
|
defer s.metaMu.Unlock()
|
|
if err := s.loadMeta(); err != nil {
|
|
return err
|
|
}
|
|
m := make(map[string]itemMeta, len(s.meta))
|
|
for k, v := range s.meta {
|
|
m[k] = v
|
|
}
|
|
changed, err := fn(m)
|
|
if err != nil || !changed {
|
|
return err
|
|
}
|
|
old := s.meta
|
|
s.meta = m
|
|
if err := s.saveMeta(); err != nil {
|
|
s.meta = old
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func decorate(e *Entry, meta map[string]itemMeta) {
|
|
if m, ok := meta[e.Path]; ok {
|
|
e.Tags, e.Favorite = m.Tags, m.Favorite
|
|
if e.IsDir {
|
|
e.Icon = m.Icon
|
|
} else {
|
|
e.EditedBy = m.EditedBy
|
|
}
|
|
}
|
|
}
|
|
|
|
func normTag(t string) (string, error) {
|
|
t = strings.Join(strings.Fields(strings.TrimPrefix(strings.TrimSpace(t), "#")), " ")
|
|
switch {
|
|
case t == "", !utf8.ValidString(t), strings.ContainsAny(t, ",\x00"):
|
|
return "", fmt.Errorf("%w : tag %q", ErrInvalidPath, t)
|
|
case utf8.RuneCountInString(t) > MaxTagLen:
|
|
return "", fmt.Errorf("%w : tag de %d caractères max", ErrInvalidPath, MaxTagLen)
|
|
}
|
|
return t, nil
|
|
}
|
|
|
|
// editMeta vérifie que chaque chemin existe puis applique edit à ses
|
|
// métadonnées, et enregistre le tout.
|
|
func (s *Store) editMeta(paths []string, edit func(*itemMeta) error) error {
|
|
cs := make([]string, 0, len(paths))
|
|
for _, p := range paths {
|
|
c, abs, err := s.resolve(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if c == "" {
|
|
return ErrInvalidPath
|
|
}
|
|
if _, err := os.Lstat(abs); err != nil {
|
|
return mapErr(err)
|
|
}
|
|
cs = append(cs, c)
|
|
}
|
|
return s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
|
for _, c := range cs {
|
|
m := meta[c]
|
|
m.Tags = append([]string(nil), m.Tags...)
|
|
if err := edit(&m); err != nil {
|
|
return false, err
|
|
}
|
|
meta[c] = m
|
|
}
|
|
return true, nil
|
|
})
|
|
}
|
|
|
|
// SetFavorite ajoute ou retire des éléments des favoris.
|
|
func (s *Store) SetFavorite(paths []string, favorite bool) error {
|
|
return s.editMeta(paths, func(m *itemMeta) error {
|
|
m.Favorite = favorite
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// SetIcon choisit l'icône de dossiers ; icon = "" rétablit l'icône par défaut.
|
|
func (s *Store) SetIcon(paths []string, icon string) error {
|
|
if icon != "" && !iconName.MatchString(icon) {
|
|
return fmt.Errorf("%w : icône %q", ErrInvalidPath, icon)
|
|
}
|
|
for _, p := range paths {
|
|
_, abs, err := s.resolve(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if fi, err := os.Lstat(abs); err != nil {
|
|
return mapErr(err)
|
|
} else if !fi.IsDir() {
|
|
return fmt.Errorf("%w : %q n'est pas un dossier", ErrInvalidPath, p)
|
|
}
|
|
}
|
|
return s.editMeta(paths, func(m *itemMeta) error {
|
|
m.Icon = icon
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// EditTags ajoute et retire des tags sur des éléments. Les tags sont comparés
|
|
// sans casse ni accents ; un tag déjà utilisé garde son écriture d'origine.
|
|
func (s *Store) EditTags(paths, add, remove []string) error {
|
|
var adds []string
|
|
for _, t := range add {
|
|
n, err := normTag(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
adds = append(adds, n)
|
|
}
|
|
drop := map[string]bool{}
|
|
for _, t := range remove {
|
|
drop[fold(strings.TrimSpace(t))] = true
|
|
}
|
|
canon := map[string]string{} // écriture existante de chaque tag
|
|
all, err := s.readMeta()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, m := range all {
|
|
for _, t := range m.Tags {
|
|
if _, ok := canon[fold(t)]; !ok {
|
|
canon[fold(t)] = t
|
|
}
|
|
}
|
|
}
|
|
return s.editMeta(paths, func(m *itemMeta) error {
|
|
kept := m.Tags[:0]
|
|
has := map[string]bool{}
|
|
for _, t := range m.Tags {
|
|
if !drop[fold(t)] && !has[fold(t)] {
|
|
kept = append(kept, t)
|
|
has[fold(t)] = true
|
|
}
|
|
}
|
|
for _, t := range adds {
|
|
if has[fold(t)] {
|
|
continue
|
|
}
|
|
if c, ok := canon[fold(t)]; ok {
|
|
t = c
|
|
}
|
|
kept = append(kept, t)
|
|
has[fold(t)] = true
|
|
}
|
|
if len(kept) > MaxTags {
|
|
return fmt.Errorf("%w : %d tags max par élément", ErrInvalidPath, MaxTags)
|
|
}
|
|
sort.Slice(kept, func(i, j int) bool { return fold(kept[i]) < fold(kept[j]) })
|
|
m.Tags = kept
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// Tags liste les tags utilisés, triés par nom, avec leur nombre d'éléments.
|
|
func (s *Store) Tags() ([]TagCount, error) {
|
|
all, err := s.readMeta()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
idx := map[string]int{}
|
|
out := []TagCount{}
|
|
for _, m := range all {
|
|
for _, t := range m.Tags {
|
|
k := fold(t)
|
|
if i, ok := idx[k]; ok {
|
|
out[i].Count++
|
|
} else {
|
|
idx[k] = len(out)
|
|
out = append(out, TagCount{Name: t, Count: 1})
|
|
}
|
|
}
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return fold(out[i].Name) < fold(out[j].Name) })
|
|
return out, nil
|
|
}
|
|
|
|
// Les opérations suivantes accompagnent Move/Copy/Delete (au mieux).
|
|
|
|
func under(k, c string) bool { return k == c || strings.HasPrefix(k, c+"/") }
|
|
|
|
func (s *Store) moveMeta(from, to string) {
|
|
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
|
moved := map[string]itemMeta{}
|
|
for k, m := range meta {
|
|
if under(k, from) {
|
|
delete(meta, k)
|
|
moved[to+k[len(from):]] = m
|
|
}
|
|
}
|
|
for k, m := range moved {
|
|
meta[k] = m
|
|
}
|
|
return len(moved) > 0, nil
|
|
})
|
|
}
|
|
|
|
func (s *Store) copyMeta(from, to string) {
|
|
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
|
if m, ok := meta[from]; ok && len(m.Tags) > 0 {
|
|
meta[to] = itemMeta{Tags: append([]string(nil), m.Tags...)} // pas le favori
|
|
return true, nil
|
|
}
|
|
return false, nil
|
|
})
|
|
}
|
|
|
|
func (s *Store) removeMeta(c string) {
|
|
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
|
changed := false
|
|
for k := range meta {
|
|
if under(k, c) {
|
|
delete(meta, k)
|
|
changed = true
|
|
}
|
|
}
|
|
return changed, nil
|
|
})
|
|
}
|