Lot 1 : catalogue PostgreSQL partagé pour les métadonnées et les partages
- 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
This commit is contained in:
1 parent
68885f7e6b
commit
f8801f00f9
16 files changed
+306
-110
No files matched your search
+15
-18
@@ -152,24 +152,21 @@ func (s *Store) noteEdit(c, by string, created bool) {
|
||||
if c == "" {
|
||||
return
|
||||
}
|
||||
s.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if s.loadMeta() != nil {
|
||||
return
|
||||
}
|
||||
m := s.meta[c]
|
||||
changed := false
|
||||
if by != "" && m.EditedBy != by {
|
||||
m.EditedBy, changed = by, true
|
||||
}
|
||||
if created && m.Created == nil {
|
||||
now := time.Now().UTC().Truncate(time.Second)
|
||||
m.Created, m.CreatedBy, changed = &now, by, true
|
||||
}
|
||||
if changed {
|
||||
s.meta[c] = m
|
||||
_ = s.saveMeta()
|
||||
}
|
||||
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
||||
m := meta[c]
|
||||
changed := false
|
||||
if by != "" && m.EditedBy != by {
|
||||
m.EditedBy, changed = by, true
|
||||
}
|
||||
if created && m.Created == nil {
|
||||
now := time.Now().UTC().Truncate(time.Second)
|
||||
m.Created, m.CreatedBy, changed = &now, by, true
|
||||
}
|
||||
if changed {
|
||||
meta[c] = m
|
||||
}
|
||||
return changed, nil
|
||||
})
|
||||
}
|
||||
|
||||
// AddDetails complète des entrées (chemins virtuels) de leurs détails. Les
|
||||
|
||||
+94
-68
@@ -94,18 +94,62 @@ func (s *Store) saveMeta() error {
|
||||
return atomicWrite(filepath.Join(s.root, metaFile), b)
|
||||
}
|
||||
|
||||
// metaSnapshot renvoie une copie des métadonnées (pour List et Search).
|
||||
// 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 s.loadMeta() != nil {
|
||||
return map[string]itemMeta{}
|
||||
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
|
||||
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) {
|
||||
@@ -147,20 +191,17 @@ func (s *Store) editMeta(paths []string, edit func(*itemMeta) error) error {
|
||||
}
|
||||
cs = append(cs, c)
|
||||
}
|
||||
s.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if err := s.loadMeta(); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, c := range cs {
|
||||
m := s.meta[c]
|
||||
m.Tags = append([]string(nil), m.Tags...)
|
||||
if err := edit(&m); err != nil {
|
||||
return err
|
||||
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
|
||||
}
|
||||
s.meta[c] = m
|
||||
}
|
||||
return s.saveMeta()
|
||||
return true, nil
|
||||
})
|
||||
}
|
||||
|
||||
// SetFavorite ajoute ou retire des éléments des favoris.
|
||||
@@ -209,19 +250,17 @@ func (s *Store) EditTags(paths, add, remove []string) error {
|
||||
drop[fold(strings.TrimSpace(t))] = true
|
||||
}
|
||||
canon := map[string]string{} // écriture existante de chaque tag
|
||||
s.metaMu.Lock()
|
||||
err := s.loadMeta()
|
||||
for _, m := range s.meta {
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
s.metaMu.Unlock()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return s.editMeta(paths, func(m *itemMeta) error {
|
||||
kept := m.Tags[:0]
|
||||
has := map[string]bool{}
|
||||
@@ -252,14 +291,13 @@ func (s *Store) EditTags(paths, add, remove []string) error {
|
||||
|
||||
// Tags liste les tags utilisés, triés par nom, avec leur nombre d'éléments.
|
||||
func (s *Store) Tags() ([]TagCount, error) {
|
||||
s.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if err := s.loadMeta(); err != nil {
|
||||
all, err := s.readMeta()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
idx := map[string]int{}
|
||||
out := []TagCount{}
|
||||
for _, m := range s.meta {
|
||||
for _, m := range all {
|
||||
for _, t := range m.Tags {
|
||||
k := fold(t)
|
||||
if i, ok := idx[k]; ok {
|
||||
@@ -279,52 +317,40 @@ func (s *Store) Tags() ([]TagCount, error) {
|
||||
func under(k, c string) bool { return k == c || strings.HasPrefix(k, c+"/") }
|
||||
|
||||
func (s *Store) moveMeta(from, to string) {
|
||||
s.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if s.loadMeta() != nil {
|
||||
return
|
||||
}
|
||||
moved := map[string]itemMeta{}
|
||||
for k, m := range s.meta {
|
||||
if under(k, from) {
|
||||
delete(s.meta, k)
|
||||
moved[to+k[len(from):]] = m
|
||||
_ = 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 {
|
||||
s.meta[k] = m
|
||||
}
|
||||
if len(moved) > 0 {
|
||||
_ = s.saveMeta()
|
||||
}
|
||||
for k, m := range moved {
|
||||
meta[k] = m
|
||||
}
|
||||
return len(moved) > 0, nil
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Store) copyMeta(from, to string) {
|
||||
s.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if s.loadMeta() != nil {
|
||||
return
|
||||
}
|
||||
if m, ok := s.meta[from]; ok && len(m.Tags) > 0 {
|
||||
s.meta[to] = itemMeta{Tags: append([]string(nil), m.Tags...)} // pas le favori
|
||||
_ = s.saveMeta()
|
||||
}
|
||||
_ = 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.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if s.loadMeta() != nil {
|
||||
return
|
||||
}
|
||||
changed := false
|
||||
for k := range s.meta {
|
||||
if under(k, c) {
|
||||
delete(s.meta, k)
|
||||
changed = true
|
||||
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
||||
changed := false
|
||||
for k := range meta {
|
||||
if under(k, c) {
|
||||
delete(meta, k)
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
}
|
||||
if changed {
|
||||
_ = s.saveMeta()
|
||||
}
|
||||
return changed, nil
|
||||
})
|
||||
}
|
||||
@@ -127,6 +127,9 @@ func sign(key []byte, id string) string {
|
||||
}
|
||||
|
||||
func (s *Store) readShares() (map[string]shareDisk, error) {
|
||||
if s.cat != nil {
|
||||
return s.cat.readShares()
|
||||
}
|
||||
out := map[string]shareDisk{}
|
||||
b, err := os.ReadFile(filepath.Join(s.root, sharesFile))
|
||||
switch {
|
||||
@@ -164,6 +167,9 @@ func (s *Store) writeShares(m map[string]shareDisk) error {
|
||||
func (s *Store) editShares(edit func(map[string]shareDisk) (bool, error)) error {
|
||||
s.sharesMu.Lock()
|
||||
defer s.sharesMu.Unlock()
|
||||
if s.cat != nil {
|
||||
return s.cat.editShares(edit)
|
||||
}
|
||||
m, err := s.readShares()
|
||||
if err != nil {
|
||||
return err
|
||||
|
||||
+26
-22
@@ -14,6 +14,8 @@ import (
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/vblogio/upandown/internal/catalog"
|
||||
)
|
||||
|
||||
// Espaces personnels et favoris par utilisateur :
|
||||
@@ -79,6 +81,10 @@ type Spaces struct {
|
||||
// MaxUpload borne la taille d'un fichier déposé (octets ; 0 : illimité).
|
||||
MaxUpload int64
|
||||
|
||||
// Catalog : catalogue PostgreSQL partagé (nil : métadonnées en fichiers
|
||||
// JSON). Les espaces personnels y sont rangés sous « home/<id> ».
|
||||
Catalog *catalog.DB
|
||||
|
||||
mu sync.Mutex
|
||||
homes map[string]*Store
|
||||
|
||||
@@ -116,6 +122,11 @@ func (sp *Spaces) home(id string) (*Store, error) {
|
||||
}
|
||||
st.History = sp.Main.History
|
||||
st.keyFrom = sp.Main
|
||||
if sp.Catalog != nil {
|
||||
if err := st.UseCatalog(sp.Catalog, "home/"+id); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
sp.homes[id] = st
|
||||
return st, nil
|
||||
}
|
||||
@@ -1044,21 +1055,17 @@ func (u *Space) RevokeAllShares() error {
|
||||
// takeMeta retire et renvoie les métadonnées de c et de son contenu (clés
|
||||
// relatives à c).
|
||||
func (s *Store) takeMeta(c string) map[string]itemMeta {
|
||||
s.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if s.loadMeta() != nil {
|
||||
return nil
|
||||
}
|
||||
out := map[string]itemMeta{}
|
||||
for k, m := range s.meta {
|
||||
if under(k, c) {
|
||||
out[k[len(c):]] = m
|
||||
delete(s.meta, k)
|
||||
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
||||
clear(out)
|
||||
for k, m := range meta {
|
||||
if under(k, c) {
|
||||
out[k[len(c):]] = m
|
||||
delete(meta, k)
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(out) > 0 {
|
||||
_ = s.saveMeta()
|
||||
}
|
||||
return len(out) > 0, nil
|
||||
})
|
||||
return out
|
||||
}
|
||||
|
||||
@@ -1066,15 +1073,12 @@ func (s *Store) putMeta(c string, m map[string]itemMeta) {
|
||||
if len(m) == 0 {
|
||||
return
|
||||
}
|
||||
s.metaMu.Lock()
|
||||
defer s.metaMu.Unlock()
|
||||
if s.loadMeta() != nil {
|
||||
return
|
||||
}
|
||||
for suffix, v := range m {
|
||||
s.meta[c+suffix] = v
|
||||
}
|
||||
_ = s.saveMeta()
|
||||
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
|
||||
for suffix, v := range m {
|
||||
meta[c+suffix] = v
|
||||
}
|
||||
return true, nil
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Store) takeShares(c string) map[string]shareDisk {
|
||||
|
||||
@@ -86,6 +86,7 @@ type Store struct {
|
||||
thumbSem chan struct{}
|
||||
|
||||
metaMu sync.Mutex // tags, favoris, auteurs (meta.go)
|
||||
cat *catalogRef // catalogue PostgreSQL (catalog.go) ; nil : fichiers JSON
|
||||
meta map[string]itemMeta // nil : pas encore chargé
|
||||
|
||||
sharesMu sync.Mutex // liens de partage (share.go)
|
||||
|
||||
@@ -21,6 +21,7 @@ func newStore(t *testing.T) *Store {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
attachTestCatalog(t, s)
|
||||
return s
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user