- 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
204 lines
5.2 KiB
Go
204 lines
5.2 KiB
Go
package storage
|
|
|
|
import (
|
|
"image"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// Détails des fichiers et dossiers pour la vue Galerie et le panneau Détails
|
|
// (/api/list?details=1) : dimensions d'une image, versions, liens de partage
|
|
// actifs, création et dernier auteur ; contenu d'un dossier.
|
|
|
|
// Details complète une entrée.
|
|
type Details struct {
|
|
Width int `json:"width,omitempty"` // image : dimensions en pixels
|
|
Height int `json:"height,omitempty"`
|
|
|
|
Versions int `json:"versions,omitempty"` // versions dans l'historique
|
|
Shares int `json:"shares,omitempty"` // liens de partage actifs
|
|
Created *time.Time `json:"created,omitempty"` // création (ou plus ancienne version connue)
|
|
CreatedBy string `json:"createdBy,omitempty"` // vide si inconnu
|
|
|
|
Dirs int `json:"dirs,omitempty"` // dossier : sous-dossiers directs
|
|
Files int `json:"files,omitempty"` // dossier : fichiers directs
|
|
Total int64 `json:"total,omitempty"` // dossier : taille de tout le contenu (octets)
|
|
Count int `json:"count,omitempty"` // dossier : nombre de fichiers dans tout le contenu
|
|
}
|
|
|
|
// maxDirWalk borne le parcours qui totalise la taille d'un dossier.
|
|
const maxDirWalk = 20000
|
|
|
|
func (s *Store) fileDetails(rel string, meta map[string]itemMeta, shares map[string]int) (*Details, error) {
|
|
c, abs, err := s.resolve(rel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fi, err := os.Lstat(abs)
|
|
if err != nil {
|
|
return nil, mapErr(err)
|
|
}
|
|
d := &Details{Shares: shares[c]}
|
|
if isDecodableImage(c) && fi.Size() < 200<<20 {
|
|
if f, err := os.Open(abs); err == nil {
|
|
if cfg, _, err := image.DecodeConfig(f); err == nil {
|
|
d.Width, d.Height = cfg.Width, cfg.Height
|
|
}
|
|
f.Close()
|
|
}
|
|
}
|
|
var oldest string
|
|
d.Versions, oldest = s.versionCount(c)
|
|
if m := meta[c]; m.Created != nil {
|
|
d.Created, d.CreatedBy = m.Created, m.CreatedBy
|
|
} else if t, err := time.Parse(versionLayout, oldest); err == nil {
|
|
d.Created = &t
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
// versionCount compte les versions d'un fichier et renvoie l'identifiant de la
|
|
// plus ancienne, sans lire leurs métadonnées.
|
|
func (s *Store) versionCount(c string) (int, string) {
|
|
des, err := os.ReadDir(s.historyAbs(c))
|
|
if err != nil {
|
|
return 0, ""
|
|
}
|
|
n, oldest := 0, ""
|
|
for _, de := range des {
|
|
id := de.Name()
|
|
if de.IsDir() || !versionID.MatchString(id) {
|
|
continue
|
|
}
|
|
n++
|
|
if oldest == "" || id < oldest {
|
|
oldest = id
|
|
}
|
|
}
|
|
return n, oldest
|
|
}
|
|
|
|
// dirDetails compte le contenu d'un dossier : éléments directs, puis taille
|
|
// et nombre de fichiers de toute l'arborescence (borné à maxDirWalk entrées).
|
|
func (s *Store) dirDetails(rel string) (*Details, error) {
|
|
_, abs, err := s.resolve(rel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
des, err := os.ReadDir(abs)
|
|
if err != nil {
|
|
return nil, mapErr(err)
|
|
}
|
|
d := &Details{}
|
|
for _, de := range des {
|
|
if !visible(de.Name()) || de.Type()&os.ModeSymlink != 0 {
|
|
continue
|
|
}
|
|
if de.IsDir() {
|
|
d.Dirs++
|
|
} else {
|
|
d.Files++
|
|
}
|
|
}
|
|
seen := 0
|
|
_ = filepath.WalkDir(abs, func(p string, e os.DirEntry, err error) error {
|
|
if err != nil || p == abs {
|
|
return nil
|
|
}
|
|
if strings.HasPrefix(e.Name(), ".") {
|
|
if e.IsDir() {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
if seen++; seen > maxDirWalk {
|
|
return filepath.SkipAll
|
|
}
|
|
if e.Type().IsRegular() {
|
|
if fi, err := e.Info(); err == nil {
|
|
d.Total += fi.Size()
|
|
d.Count++
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
return d, nil
|
|
}
|
|
|
|
// shareCounts compte les liens de partage actifs par chemin.
|
|
func (s *Store) shareCounts() map[string]int {
|
|
s.sharesMu.Lock()
|
|
defer s.sharesMu.Unlock()
|
|
m, err := s.readShares()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
out := map[string]int{}
|
|
now := time.Now()
|
|
for _, d := range m {
|
|
if d.Expires == nil || now.Before(*d.Expires) {
|
|
out[d.Path]++
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// noteEdit retient le dernier utilisateur qui a déposé un fichier et, pour un
|
|
// fichier nouveau, sa date de création et son auteur. .meta.json n'est réécrit
|
|
// que si quelque chose change.
|
|
func (s *Store) noteEdit(c, by string, created bool) {
|
|
if c == "" {
|
|
return
|
|
}
|
|
_ = 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
|
|
// dossiers virtuels, favoris cassés et éléments de la poubelle sont laissés
|
|
// tels quels.
|
|
func (u *Space) AddDetails(es []*Entry) {
|
|
metas := map[*Store]map[string]itemMeta{}
|
|
shares := map[*Store]map[string]int{}
|
|
for _, e := range es {
|
|
if e.Special != "" || e.Broken || e.Origin != "" {
|
|
continue
|
|
}
|
|
st, rel, err := u.route(e.Path)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if _, ok := metas[st]; !ok {
|
|
metas[st], shares[st] = st.metaSnapshot(), st.shareCounts()
|
|
}
|
|
if e.IsDir {
|
|
if d, _ := st.dirDetails(rel); d != nil {
|
|
d.Shares = shares[st][cleanOr(rel)]
|
|
e.Details = d
|
|
}
|
|
continue
|
|
}
|
|
e.Details, _ = st.fileDetails(rel, metas[st], shares[st])
|
|
}
|
|
}
|
|
|
|
func cleanOr(rel string) string {
|
|
c, _ := Clean(rel)
|
|
return c
|
|
}
|