Files
upandown/internal/storage/details.go
T
claude BotandClaude Opus 5.5 f8801f00f9 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
2026-11-20 17:20:16 +01:00

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
}