.s3 dans la vue utilisateur (mêmes droits que le commun), poubelle s-<id>, partages, déplacements et copies entre disque et S3 (transfer + reprise des tags et liens), pas de favoris sur S3. Configuration : variables S3_* prioritaires champ par champ, sinon table s3_config (clé secrète chiffrée avec SHARE_SECRET), relue toutes les 30 s par chaque instance. Endpoint et bucket figés tant que la racine n'est pas vide. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
1387 lines
36 KiB
Go
1387 lines
36 KiB
Go
package storage
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/vblogio/upandown/internal/catalog"
|
|
)
|
|
|
|
// Espaces personnels et favoris par utilisateur :
|
|
//
|
|
// DATA_DIR/.users/<id>/home espace personnel, un Store complet (historique,
|
|
// miniatures, corbeille, tags, partages)
|
|
// DATA_DIR/.users/<id>/favoris liens symboliques relatifs vers des fichiers ou dossiers
|
|
//
|
|
// Côté API, l'arborescence commune garde ses chemins. L'espace personnel est
|
|
// exposé sous le préfixe virtuel ".perso", les favoris sous ".favoris" et la
|
|
// poubelle sous ".poubelle" : un préfixe caché ne peut pas entrer en conflit
|
|
// avec un dossier réel. Un favori pointe vers le fichier d'origine ; il suit ses
|
|
// renommages et déplacements et disparaît quand le fichier est supprimé. La
|
|
// poubelle réunit les corbeilles de l'arborescence commune (".poubelle/c-<id>",
|
|
// visibles de tous) et de l'espace personnel (".poubelle/p-<id>").
|
|
//
|
|
// La racine S3 facultative (".s3") suit les règles de l'arborescence commune
|
|
// (lecture seule possible, l'administrateur écrit toujours) ; sa corbeille
|
|
// apparaît sous ".poubelle/s-<id>". Pas de favoris ni d'historique sur S3.
|
|
|
|
const (
|
|
// PersoPrefix est la racine virtuelle de l'espace personnel.
|
|
PersoPrefix = ".perso"
|
|
// FavPrefix est le dossier virtuel des favoris.
|
|
FavPrefix = ".favoris"
|
|
// TrashPrefix est le dossier virtuel de la poubelle.
|
|
TrashPrefix = ".poubelle"
|
|
// S3Prefix est la racine virtuelle du stockage objet (si configuré).
|
|
S3Prefix = ".s3"
|
|
|
|
usersDir = ".users"
|
|
homeName = "home"
|
|
favName = "favoris"
|
|
)
|
|
|
|
// LocalUser est l'utilisateur unique hors OIDC.
|
|
const LocalUser = "local"
|
|
|
|
// UserID transforme un identifiant (email, sub) en nom de dossier : minuscules,
|
|
// caractères hors [a-z0-9._@+-] remplacés par « _ », jamais caché.
|
|
func UserID(raw string) string {
|
|
s := strings.ToLower(strings.TrimSpace(raw))
|
|
var b strings.Builder
|
|
for _, r := range s {
|
|
if r >= 'a' && r <= 'z' || r >= '0' && r <= '9' || strings.ContainsRune("._@+-", r) {
|
|
b.WriteRune(r)
|
|
} else {
|
|
b.WriteByte('_')
|
|
}
|
|
}
|
|
id := b.String()
|
|
if strings.HasPrefix(id, ".") {
|
|
id = "_" + id[1:]
|
|
}
|
|
if id == "" {
|
|
return LocalUser
|
|
}
|
|
if len(id) > 80 {
|
|
h := sha256.Sum256([]byte(s))
|
|
id = id[:60] + "-" + hex.EncodeToString(h[:8])
|
|
}
|
|
return id
|
|
}
|
|
|
|
// Spaces réunit l'arborescence commune et les espaces des utilisateurs.
|
|
type Spaces struct {
|
|
Main *Store
|
|
|
|
// s3 : racine commune sur stockage objet (nil : non configurée) ; voir
|
|
// ConfigureS3. Remplacée à chaud quand sa configuration change.
|
|
s3 atomic.Pointer[Store]
|
|
s3cf *s3Manager
|
|
|
|
// 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
|
|
|
|
favMu sync.Mutex // dossiers de favoris (tous utilisateurs)
|
|
|
|
purgeMu sync.Mutex
|
|
lastPurge time.Time // dernière purge automatique de la corbeille
|
|
}
|
|
|
|
// NewSpaces crée le gestionnaire d'espaces autour du Store principal.
|
|
func NewSpaces(main *Store) *Spaces {
|
|
return &Spaces{Main: main, homes: map[string]*Store{}}
|
|
}
|
|
|
|
func (sp *Spaces) usersRoot() string { return filepath.Join(sp.Main.root, usersDir) }
|
|
func (sp *Spaces) userDir(id string) string { return filepath.Join(sp.usersRoot(), id) }
|
|
func (sp *Spaces) favDir(id string) string { return filepath.Join(sp.userDir(id), favName) }
|
|
|
|
// home renvoie l'espace personnel de id, créé au premier accès.
|
|
func (sp *Spaces) home(id string) (*Store, error) {
|
|
if id == "" || UserID(id) != id {
|
|
return nil, fmt.Errorf("%w : utilisateur %q", ErrInvalidPath, id)
|
|
}
|
|
sp.mu.Lock()
|
|
defer sp.mu.Unlock()
|
|
if st := sp.homes[id]; st != nil {
|
|
return st, nil
|
|
}
|
|
if err := os.MkdirAll(sp.favDir(id), 0o755); err != nil {
|
|
return nil, err
|
|
}
|
|
st, err := New(filepath.Join(sp.userDir(id), homeName))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
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
|
|
}
|
|
|
|
// For renvoie la vue de l'utilisateur id.
|
|
func (sp *Spaces) For(id string, admin bool) (*Space, error) {
|
|
h, err := sp.home(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Space{sp: sp, id: id, home: h, s3: sp.s3.Load(), admin: admin}, nil
|
|
}
|
|
|
|
// users liste les utilisateurs qui ont un espace.
|
|
func (sp *Spaces) users() []string {
|
|
des, _ := os.ReadDir(sp.usersRoot())
|
|
var out []string
|
|
for _, de := range des {
|
|
if de.IsDir() && UserID(de.Name()) == de.Name() {
|
|
out = append(out, de.Name())
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// ResolveShare résout un lien de partage, de l'arborescence commune ou d'un
|
|
// espace personnel, et renvoie le Store qui le porte.
|
|
func (sp *Spaces) ResolveShare(token string) (Share, *Store, error) {
|
|
sh, err := sp.Main.ResolveShare(token)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
return sh, sp.Main, err
|
|
}
|
|
if s3 := sp.s3.Load(); s3 != nil {
|
|
if sh, serr := s3.ResolveShare(token); !errors.Is(serr, ErrNotFound) {
|
|
return sh, s3, serr
|
|
}
|
|
}
|
|
for _, id := range sp.users() {
|
|
st, herr := sp.home(id)
|
|
if herr != nil {
|
|
continue
|
|
}
|
|
if sh, herr := st.ResolveShare(token); !errors.Is(herr, ErrNotFound) {
|
|
return sh, st, herr
|
|
}
|
|
}
|
|
return Share{}, nil, err
|
|
}
|
|
|
|
// --- Liens des favoris -------------------------------------------------------
|
|
|
|
type favLink struct {
|
|
name string // nom du lien dans le dossier des favoris
|
|
target string // chemin absolu visé
|
|
}
|
|
|
|
// links lit les liens du dossier des favoris de id ; appelé sous favMu.
|
|
func (sp *Spaces) links(id string) []favLink {
|
|
dir := sp.favDir(id)
|
|
des, _ := os.ReadDir(dir)
|
|
var out []favLink
|
|
for _, de := range des {
|
|
if de.Type()&fs.ModeSymlink == 0 {
|
|
continue
|
|
}
|
|
t, err := os.Readlink(filepath.Join(dir, de.Name()))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if !filepath.IsAbs(t) {
|
|
t = filepath.Join(dir, t)
|
|
}
|
|
out = append(out, favLink{name: de.Name(), target: filepath.Clean(t)})
|
|
}
|
|
return out
|
|
}
|
|
|
|
// visibleTo indique si l'utilisateur id peut viser abs : arborescence commune
|
|
// ou son propre espace personnel.
|
|
func (sp *Spaces) visibleTo(id, abs string) bool {
|
|
sep := string(os.PathSeparator)
|
|
if strings.HasPrefix(abs, sp.usersRoot()+sep) {
|
|
return strings.HasPrefix(abs, filepath.Join(sp.userDir(id), homeName)+sep)
|
|
}
|
|
return strings.HasPrefix(abs, sp.Main.root+sep)
|
|
}
|
|
|
|
// addLink crée un lien vers abs (nom du fichier, suffixé en cas de doublon) ;
|
|
// appelé sous favMu.
|
|
func (sp *Spaces) addLink(id, abs string) error {
|
|
for _, l := range sp.links(id) {
|
|
if l.target == abs {
|
|
return nil
|
|
}
|
|
}
|
|
dir := sp.favDir(id)
|
|
rel, err := filepath.Rel(dir, abs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
base := filepath.Base(abs)
|
|
stem, ext := strings.TrimSuffix(base, filepath.Ext(base)), filepath.Ext(base)
|
|
name := base
|
|
for i := 2; ; i++ {
|
|
if _, err := os.Lstat(filepath.Join(dir, name)); errors.Is(err, fs.ErrNotExist) {
|
|
break
|
|
}
|
|
name = fmt.Sprintf("%s (%d)%s", stem, i, ext)
|
|
}
|
|
return os.Symlink(rel, filepath.Join(dir, name))
|
|
}
|
|
|
|
// relink fait suivre aux favoris de tous les utilisateurs un élément déplacé
|
|
// de from vers to (chemins absolus, fichier ou dossier). Un favori qui
|
|
// deviendrait invisible pour son utilisateur (fichier passé dans l'espace
|
|
// personnel d'un autre) est retiré.
|
|
func (sp *Spaces) relink(from, to string) {
|
|
sp.favMu.Lock()
|
|
defer sp.favMu.Unlock()
|
|
for _, id := range sp.users() {
|
|
dir := sp.favDir(id)
|
|
for _, l := range sp.links(id) {
|
|
if l.target != from && !strings.HasPrefix(l.target, from+string(os.PathSeparator)) {
|
|
continue
|
|
}
|
|
nt := to + l.target[len(from):]
|
|
lp := filepath.Join(dir, l.name)
|
|
_ = os.Remove(lp)
|
|
if sp.visibleTo(id, nt) {
|
|
if rel, err := filepath.Rel(dir, nt); err == nil {
|
|
_ = os.Symlink(rel, lp)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// unlink retire, chez tous les utilisateurs, les favoris visant abs ou son contenu.
|
|
func (sp *Spaces) unlink(abs string) {
|
|
sp.favMu.Lock()
|
|
defer sp.favMu.Unlock()
|
|
for _, id := range sp.users() {
|
|
for _, l := range sp.links(id) {
|
|
if l.target == abs || strings.HasPrefix(l.target, abs+string(os.PathSeparator)) {
|
|
_ = os.Remove(filepath.Join(sp.favDir(id), l.name))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Vue d'un utilisateur ------------------------------------------------------
|
|
|
|
// Space est la vue d'un utilisateur : arborescence commune, espace personnel
|
|
// (préfixe .perso) et favoris (.favoris). Ses méthodes prennent et renvoient
|
|
// des chemins virtuels.
|
|
type Space struct {
|
|
sp *Spaces
|
|
id string
|
|
home *Store
|
|
s3 *Store // racine S3 au moment de la requête (nil : absente)
|
|
admin bool // administrateur : écrit toujours dans l'arborescence commune
|
|
}
|
|
|
|
// ID renvoie l'identifiant de l'utilisateur.
|
|
func (u *Space) ID() string { return u.id }
|
|
|
|
func cleanVirtual(p string) string { return strings.TrimPrefix(path.Clean("/"+p), "/") }
|
|
|
|
func favLinkName(p string) (string, bool) {
|
|
name, ok := strings.CutPrefix(cleanVirtual(p), FavPrefix+"/")
|
|
return name, ok && name != "" && !strings.Contains(name, "/")
|
|
}
|
|
|
|
// route traduit un chemin virtuel en Store et chemin relatif à ce Store.
|
|
func (u *Space) route(p string) (*Store, string, error) {
|
|
c := cleanVirtual(p)
|
|
switch {
|
|
case c == PersoPrefix:
|
|
return u.home, "", nil
|
|
case strings.HasPrefix(c, PersoPrefix+"/"):
|
|
return u.home, c[len(PersoPrefix)+1:], nil
|
|
case c == FavPrefix || strings.HasPrefix(c, FavPrefix+"/"):
|
|
return nil, "", fmt.Errorf("%w : le dossier Favoris ne contient que des liens", ErrInvalidPath)
|
|
case c == TrashPrefix || strings.HasPrefix(c, TrashPrefix+"/"):
|
|
return nil, "", fmt.Errorf("%w : élément de la poubelle (à restaurer d'abord)", ErrInvalidPath)
|
|
case c == S3Prefix || strings.HasPrefix(c, S3Prefix+"/"):
|
|
if u.s3 == nil {
|
|
return nil, "", ErrNotFound
|
|
}
|
|
return u.s3, strings.TrimPrefix(c[len(S3Prefix):], "/"), nil
|
|
}
|
|
return u.sp.Main, p, nil
|
|
}
|
|
|
|
// virt traduit un chemin relatif à st en chemin virtuel.
|
|
func (u *Space) virt(st *Store, rel string) string {
|
|
prefix := PersoPrefix
|
|
switch {
|
|
case st == u.sp.Main:
|
|
return rel
|
|
case st == u.s3 && st != nil:
|
|
prefix = S3Prefix
|
|
}
|
|
if rel == "" {
|
|
return prefix
|
|
}
|
|
return prefix + "/" + rel
|
|
}
|
|
|
|
// common indique si st est une racine commune (arborescence ou S3).
|
|
func (u *Space) common(st *Store) bool {
|
|
return st == u.sp.Main || (st != nil && st == u.s3)
|
|
}
|
|
|
|
// stores renvoie les racines visibles : commune, personnelle, puis S3.
|
|
func (u *Space) stores() []*Store {
|
|
out := []*Store{u.sp.Main, u.home}
|
|
if u.s3 != nil {
|
|
out = append(out, u.s3)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// fromAbs traduit un chemin absolu en chemin virtuel, s'il est visible.
|
|
func (u *Space) fromAbs(abs string) (string, bool) {
|
|
for _, st := range []*Store{u.home, u.sp.Main} {
|
|
rel, err := filepath.Rel(st.root, abs)
|
|
if err != nil || rel == "." || strings.HasPrefix(rel, "..") {
|
|
continue
|
|
}
|
|
c, err := Clean(filepath.ToSlash(rel))
|
|
if err != nil || c == "" {
|
|
return "", false // .users, .trash, .history...
|
|
}
|
|
return u.virt(st, c), true
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
func absOf(st *Store, c string) string { return filepath.Join(st.root, filepath.FromSlash(c)) }
|
|
|
|
func (u *Space) favSet() map[string]bool {
|
|
u.sp.favMu.Lock()
|
|
links := u.sp.links(u.id)
|
|
u.sp.favMu.Unlock()
|
|
out := make(map[string]bool, len(links))
|
|
for _, l := range links {
|
|
if p, ok := u.fromAbs(l.target); ok {
|
|
out[p] = true
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (u *Space) entry(st *Store, e Entry, favs map[string]bool) Entry {
|
|
e.Path = u.virt(st, e.Path)
|
|
e.Favorite = favs[e.Path]
|
|
return e
|
|
}
|
|
|
|
// Favorites liste les favoris de l'utilisateur ; Path est le chemin du fichier
|
|
// d'origine (ou .favoris/<lien> si l'original a disparu).
|
|
func (u *Space) Favorites() ([]Entry, error) {
|
|
u.sp.favMu.Lock()
|
|
links := u.sp.links(u.id)
|
|
u.sp.favMu.Unlock()
|
|
meta := map[*Store]map[string]itemMeta{u.sp.Main: u.sp.Main.metaSnapshot(), u.home: u.home.metaSnapshot()}
|
|
out := make([]Entry, 0, len(links))
|
|
for _, l := range links {
|
|
e := Entry{Name: l.name, Path: FavPrefix + "/" + l.name, Link: l.name, Broken: true}
|
|
if p, ok := u.fromAbs(l.target); ok {
|
|
if fi, err := os.Stat(l.target); err == nil && (fi.Mode().IsRegular() || fi.IsDir()) {
|
|
st, rel, _ := u.route(p)
|
|
e = toEntry(rel, fi)
|
|
decorate(&e, meta[st])
|
|
e.Path, e.Link, e.Favorite = p, l.name, true
|
|
}
|
|
}
|
|
out = append(out, e)
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return fold(out[i].Name) < fold(out[j].Name) })
|
|
return out, nil
|
|
}
|
|
|
|
// SetFavorite ajoute ou retire des fichiers des favoris. Un chemin
|
|
// .favoris/<lien> désigne directement un lien (favori dont l'original a disparu).
|
|
func (u *Space) SetFavorite(paths []string, favorite bool) error {
|
|
var targets []string
|
|
var names []string
|
|
for _, p := range paths {
|
|
if name, ok := favLinkName(p); ok {
|
|
if !favorite {
|
|
names = append(names, name)
|
|
}
|
|
continue
|
|
}
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if st.IsS3() {
|
|
return fmt.Errorf("%w : pas de favoris sur la racine S3", ErrInvalidPath)
|
|
}
|
|
c, abs, err := st.resolve(rel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if c == "" {
|
|
return ErrInvalidPath
|
|
}
|
|
fi, err := os.Lstat(abs)
|
|
if err != nil {
|
|
return mapErr(err)
|
|
}
|
|
if !fi.Mode().IsRegular() && !fi.IsDir() {
|
|
return fmt.Errorf("%w : %s", ErrInvalidPath, p)
|
|
}
|
|
targets = append(targets, abs)
|
|
}
|
|
u.sp.favMu.Lock()
|
|
defer u.sp.favMu.Unlock()
|
|
dir := u.sp.favDir(u.id)
|
|
for _, name := range names {
|
|
if fi, err := os.Lstat(filepath.Join(dir, name)); err == nil && fi.Mode()&fs.ModeSymlink != 0 {
|
|
_ = os.Remove(filepath.Join(dir, name))
|
|
}
|
|
}
|
|
for _, abs := range targets {
|
|
if favorite {
|
|
if err := u.sp.addLink(u.id, abs); err != nil {
|
|
return err
|
|
}
|
|
continue
|
|
}
|
|
for _, l := range u.sp.links(u.id) {
|
|
if l.target == abs {
|
|
_ = os.Remove(filepath.Join(dir, l.name))
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// --- Opérations sur les fichiers, en chemins virtuels -----------------------------
|
|
|
|
func isRoot(rel string) bool {
|
|
c, err := Clean(rel)
|
|
return err == nil && c == ""
|
|
}
|
|
|
|
// List renvoie le contenu d'un dossier. La racine commune commence par les
|
|
// dossiers virtuels Favoris, Personnel et Poubelle.
|
|
func (u *Space) List(p string) ([]Entry, error) {
|
|
u.sp.autoPurge()
|
|
switch cleanVirtual(p) {
|
|
case FavPrefix:
|
|
return u.Favorites()
|
|
case TrashPrefix:
|
|
return u.Trash()
|
|
}
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
es, err := st.List(rel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
favs := u.favSet()
|
|
out := make([]Entry, 0, len(es)+4)
|
|
if st == u.sp.Main && isRoot(rel) {
|
|
n := 0
|
|
for _, s := range u.stores() {
|
|
n += s.TrashCount()
|
|
}
|
|
out = append(out,
|
|
Entry{Name: "Favoris", Path: FavPrefix, IsDir: true, Special: "favoris"},
|
|
Entry{Name: "Personnel", Path: PersoPrefix, IsDir: true, Special: "perso"})
|
|
if u.s3 != nil {
|
|
out = append(out, Entry{Name: "S3", Path: S3Prefix, IsDir: true, Special: "s3"})
|
|
}
|
|
out = append(out, Entry{Name: "Poubelle", Path: TrashPrefix, IsDir: true, Special: "poubelle", Count: n})
|
|
}
|
|
for _, e := range es {
|
|
out = append(out, u.entry(st, e, favs))
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// Search cherche dans l'espace personnel puis l'arborescence commune.
|
|
func (u *Space) Search(q string, f Filter, limit int) ([]Hit, error) {
|
|
favs := u.favSet()
|
|
inner := Filter{Tag: f.Tag}
|
|
tag := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(f.Tag), "#"))
|
|
if f.Favorite && strings.TrimSpace(q) == "" && tag == "" {
|
|
es, err := u.Favorites()
|
|
out := []Hit{}
|
|
for _, e := range es {
|
|
if !e.Broken && len(out) < limit {
|
|
out = append(out, Hit{Entry: e})
|
|
}
|
|
}
|
|
return out, err
|
|
}
|
|
lim := limit
|
|
if f.Favorite {
|
|
lim = 1 << 30 // filtrés ensuite
|
|
}
|
|
var all []Hit
|
|
for _, st := range append([]*Store{u.home}, u.commons()...) {
|
|
hs, err := st.Search(q, inner, lim)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, h := range hs {
|
|
h.Entry = u.entry(st, h.Entry, favs)
|
|
if !f.Favorite || h.Favorite {
|
|
all = append(all, h)
|
|
}
|
|
}
|
|
}
|
|
// Correspondances sur le nom (sans extrait) d'abord, comme Store.Search.
|
|
sort.SliceStable(all, func(i, j int) bool { return all[i].Snippet == "" && all[j].Snippet != "" })
|
|
if len(all) > limit {
|
|
all = all[:limit]
|
|
}
|
|
if all == nil {
|
|
all = []Hit{}
|
|
}
|
|
return all, nil
|
|
}
|
|
|
|
// Tags réunit les tags de l'arborescence commune et de l'espace personnel.
|
|
func (u *Space) Tags() ([]TagCount, error) {
|
|
idx := map[string]int{}
|
|
out := []TagCount{}
|
|
for _, st := range u.stores() {
|
|
ts, err := st.Tags()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, t := range ts {
|
|
if i, ok := idx[fold(t.Name)]; ok {
|
|
out[i].Count += t.Count
|
|
} else {
|
|
idx[fold(t.Name)] = len(out)
|
|
out = append(out, t)
|
|
}
|
|
}
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return fold(out[i].Name) < fold(out[j].Name) })
|
|
return out, nil
|
|
}
|
|
|
|
// EditTags ajoute et retire des tags (voir Store.EditTags).
|
|
func (u *Space) EditTags(paths, add, remove []string) error {
|
|
groups := map[*Store][]string{}
|
|
for _, p := range paths {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return err
|
|
}
|
|
groups[st] = append(groups[st], rel)
|
|
}
|
|
for st, rels := range groups {
|
|
if err := st.EditTags(rels, add, remove); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetIcon choisit l'icône de dossiers (voir Store.SetIcon).
|
|
func (u *Space) SetIcon(paths []string, icon string) error {
|
|
groups := map[*Store][]string{}
|
|
for _, p := range paths {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return err
|
|
}
|
|
groups[st] = append(groups[st], rel)
|
|
}
|
|
for st, rels := range groups {
|
|
if err := st.SetIcon(rels, icon); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// canWriteMain indique si l'utilisateur peut modifier l'arborescence commune :
|
|
// toujours pour un administrateur, sinon sauf si elle est en lecture seule.
|
|
func (u *Space) canWriteMain() bool {
|
|
if u.admin {
|
|
return true
|
|
}
|
|
st, err := u.sp.Main.ReadSettings()
|
|
return err != nil || !st.CommonReadonly
|
|
}
|
|
|
|
// writable refuse la modification de l'arborescence commune en lecture seule.
|
|
func (u *Space) writable(stores ...*Store) error {
|
|
for _, st := range stores {
|
|
if u.common(st) && !u.canWriteMain() {
|
|
return fmt.Errorf("%w : l'arborescence commune est en lecture seule", ErrForbidden)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// quota renvoie le quota de l'espace personnel en octets (0 : illimité).
|
|
func (u *Space) quota() int64 {
|
|
st, err := u.sp.Main.ReadSettings()
|
|
if err != nil || st.QuotaMB <= 0 {
|
|
return 0
|
|
}
|
|
return st.QuotaMB << 20
|
|
}
|
|
|
|
// quotaFor vérifie que rel de src (fichier ou dossier) tient dans le quota
|
|
// restant de l'espace st, si c'est un espace personnel.
|
|
func (u *Space) quotaFor(st, src *Store, rel string) error {
|
|
q := u.quota()
|
|
if u.common(st) || q == 0 {
|
|
return nil
|
|
}
|
|
var size int64
|
|
if src.IsS3() {
|
|
_ = src.Walk(rel, func(_ string, e Entry) error {
|
|
size += e.Size
|
|
return nil
|
|
})
|
|
} else {
|
|
_ = filepath.WalkDir(absOf(src, cleanOr(rel)), func(_ string, d fs.DirEntry, err error) error {
|
|
if err == nil && d.Type().IsRegular() {
|
|
if fi, err := d.Info(); err == nil {
|
|
size += fi.Size()
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
if st.Usage()+size > q {
|
|
return ErrQuota
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Usage renvoie l'occupation de l'espace personnel et son quota (0 : illimité).
|
|
func (u *Space) Usage() (used, quota int64) { return u.home.Usage(), u.quota() }
|
|
|
|
// Stat décrit un élément (chemin virtuel).
|
|
func (u *Space) Stat(p string) (Entry, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
e, err := st.Stat(rel)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
return u.entry(st, e, u.favSet()), nil
|
|
}
|
|
|
|
// Open ouvre un fichier en lecture (chemin virtuel).
|
|
func (u *Space) Open(p string) (File, fs.FileInfo, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return st.Open(rel)
|
|
}
|
|
|
|
// Put dépose un fichier (voir Store.Put). size est la taille annoncée par le
|
|
// client (-1 : inconnue) : elle permet de refuser tout de suite un fichier qui
|
|
// dépasse la limite d'envoi ou le quota.
|
|
func (u *Space) Put(p string, r io.Reader, size int64, o PutOptions) (Entry, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
o.By = u.id
|
|
o.Limit, o.LimitErr = u.sp.MaxUpload, ErrTooLarge
|
|
if q := u.quota(); q > 0 && !u.common(st) {
|
|
rem := q - st.Usage()
|
|
if rem <= 0 {
|
|
return Entry{}, ErrQuota
|
|
}
|
|
if o.Limit == 0 || rem < o.Limit {
|
|
o.Limit, o.LimitErr = rem, ErrQuota
|
|
}
|
|
}
|
|
if size > 0 && o.Limit > 0 && size > o.Limit {
|
|
return Entry{}, o.LimitErr
|
|
}
|
|
e, err := st.Put(rel, r, o)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
return u.entry(st, e, nil), nil
|
|
}
|
|
|
|
func (u *Space) Mkdir(p string) (Entry, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
e, err := st.Mkdir(rel)
|
|
return u.entry(st, e, nil), err
|
|
}
|
|
|
|
// Move renomme ou déplace un élément, y compris entre l'arborescence commune
|
|
// et l'espace personnel. Les favoris suivent.
|
|
func (u *Space) Move(from, to string) (Entry, error) {
|
|
sf, rf, err := u.route(from)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
st, rt, err := u.route(to)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if err := u.writable(sf, st); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if sf != st {
|
|
if err := u.quotaFor(st, sf, rf); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
var e Entry
|
|
if sf.IsS3() || st.IsS3() {
|
|
e, err = u.sp.moveObjects(sf, rf, st, rt, u.id)
|
|
} else {
|
|
e, err = u.sp.moveAcross(sf, rf, st, rt)
|
|
}
|
|
return u.entry(st, e, nil), err
|
|
}
|
|
cf, _ := Clean(rf)
|
|
e, err := sf.Move(rf, rt)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
u.sp.relink(absOf(sf, cf), absOf(sf, e.Path))
|
|
return u.entry(st, e, nil), nil
|
|
}
|
|
|
|
// moveAcross déplace un élément d'un Store à un autre (même volume) avec ses
|
|
// miniatures, son historique, ses tags et ses liens de partage.
|
|
func (sp *Spaces) moveAcross(src *Store, from string, dst *Store, to string) (Entry, error) {
|
|
cf, af, err := src.resolve(from)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
ct, at, err := dst.resolve(to)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if cf == "" || ct == "" {
|
|
return Entry{}, ErrInvalidPath
|
|
}
|
|
fi, err := os.Lstat(af)
|
|
if err != nil {
|
|
return Entry{}, mapErr(err)
|
|
}
|
|
if fi.IsDir() && (at == af || strings.HasPrefix(at, af+string(os.PathSeparator))) {
|
|
return Entry{}, ErrInvalidPath
|
|
}
|
|
if _, err := os.Lstat(at); err == nil {
|
|
return Entry{}, ErrExists
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(at), 0o755); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if err := os.Rename(af, at); err != nil {
|
|
return Entry{}, mapErr(err)
|
|
}
|
|
src.usageDirty()
|
|
dst.usageDirty()
|
|
moveAside(src.thumbAbs(cf, fi.IsDir()), dst.thumbAbs(ct, fi.IsDir()))
|
|
moveAside(src.historyAbs(cf), dst.historyAbs(ct))
|
|
dst.putMeta(ct, src.takeMeta(cf))
|
|
dst.putShares(ct, src.takeShares(cf))
|
|
sp.relink(af, at)
|
|
if fi, err = os.Stat(at); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
return toEntry(ct, fi), nil
|
|
}
|
|
|
|
// moveObjects déplace un élément entre la racine S3 et un Store disque (ou
|
|
// l'inverse) : copie en flux, reprise des tags et des liens de partage, puis
|
|
// suppression de l'original. Les favoris visant l'original disparaissent.
|
|
func (sp *Spaces) moveObjects(src *Store, from string, dst *Store, to string, by string) (Entry, error) {
|
|
cf, fi, err := src.lstat(from)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
ct, err := Clean(to)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if cf == "" || ct == "" || !(fi.IsDir() || fi.Mode().IsRegular()) {
|
|
return Entry{}, ErrInvalidPath
|
|
}
|
|
e, err := transfer(src, cf, dst, ct, by)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
dst.putMeta(ct, src.takeMeta(cf))
|
|
dst.putShares(ct, src.takeShares(cf))
|
|
if !src.IsS3() {
|
|
sp.unlink(absOf(src, cf))
|
|
}
|
|
if err := src.Remove(cf); err != nil {
|
|
return e, fmt.Errorf("copié vers %s, mais l'original n'a pas pu être supprimé : %w", ct, err)
|
|
}
|
|
return e, nil
|
|
}
|
|
|
|
// moveAside déplace src vers dst s'il existe (miniatures, historique).
|
|
func moveAside(src, dst string) {
|
|
if _, err := os.Stat(src); err != nil {
|
|
return
|
|
}
|
|
_ = os.RemoveAll(dst)
|
|
if err := os.MkdirAll(filepath.Dir(dst), 0o755); err == nil {
|
|
_ = os.Rename(src, dst)
|
|
}
|
|
}
|
|
|
|
// MoveMany déplace plusieurs éléments dans le dossier dir (voir Store.MoveMany).
|
|
func (u *Space) MoveMany(paths []string, dir string) ([]MoveResult, error) {
|
|
sd, rd, err := u.route(dir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cd, fi, err := sd.statDir(rd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !fi.IsDir() {
|
|
return nil, fmt.Errorf("%w : la destination n'est pas un dossier", ErrInvalidPath)
|
|
}
|
|
vd := u.virt(sd, cd)
|
|
out := make([]MoveResult, 0, len(paths))
|
|
for _, p := range paths {
|
|
r := MoveResult{From: p}
|
|
sf, rf, err := u.route(p)
|
|
var c string
|
|
if err == nil {
|
|
c, err = Clean(rf)
|
|
}
|
|
switch {
|
|
case err != nil || c == "":
|
|
r.err = ErrInvalidPath
|
|
case sf == sd && strings.TrimPrefix(path.Dir("/"+c), "/") == cd:
|
|
r.From = u.virt(sf, c)
|
|
r.To = r.From // déjà dans le dossier cible
|
|
default:
|
|
r.From = u.virt(sf, c)
|
|
var e Entry
|
|
if e, r.err = u.Move(r.From, path.Join(vd, path.Base(c))); r.err == nil {
|
|
r.To = e.Path
|
|
}
|
|
}
|
|
if r.err != nil {
|
|
r.Error = r.err.Error()
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// Copy duplique un fichier ou un dossier, éventuellement vers l'autre espace.
|
|
func (u *Space) Copy(from, to string) (Entry, error) {
|
|
sf, rf, err := u.route(from)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
st, rt, err := u.route(to)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
cf, _, err := sf.lstat(rf)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if cf == "" {
|
|
return Entry{}, ErrInvalidPath
|
|
}
|
|
if err := u.quotaFor(st, sf, rf); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
af := absOf(sf, cf)
|
|
var e Entry
|
|
switch {
|
|
case sf == st:
|
|
e, err = sf.Copy(rf, rt)
|
|
case sf.IsS3() || st.IsS3():
|
|
var ct string
|
|
if ct, err = Clean(rt); err == nil {
|
|
e, err = transfer(sf, cf, st, ct, u.id)
|
|
}
|
|
default:
|
|
ct, at, rerr := st.resolve(rt)
|
|
if rerr != nil {
|
|
return Entry{}, rerr
|
|
}
|
|
fi, serr := os.Lstat(af)
|
|
if serr != nil {
|
|
return Entry{}, mapErr(serr)
|
|
}
|
|
if _, serr := os.Lstat(at); serr == nil {
|
|
return Entry{}, ErrExists
|
|
}
|
|
if fi.IsDir() {
|
|
err = copyTree(af, at)
|
|
} else if fi.Mode().IsRegular() {
|
|
err = copyFile(af, at)
|
|
} else {
|
|
err = ErrNotFound
|
|
}
|
|
if err != nil {
|
|
_ = os.RemoveAll(at)
|
|
return Entry{}, err
|
|
}
|
|
st.usageDirty()
|
|
nfi, serr := os.Stat(at)
|
|
if serr != nil {
|
|
return Entry{}, serr
|
|
}
|
|
e = toEntry(ct, nfi)
|
|
}
|
|
st.noteEdit(e.Path, u.id, true)
|
|
e.EditedBy = u.id
|
|
return u.entry(st, e, nil), nil
|
|
}
|
|
|
|
// Delete met un élément à la corbeille de son espace ; les favoris qui le
|
|
// visent disparaissent. Sur .favoris/<lien>, seul le lien est retiré. Dans la
|
|
// poubelle, l'élément est supprimé définitivement (.poubelle seul : la vide).
|
|
func (u *Space) Delete(p string, recursive bool) error {
|
|
if _, ok := favLinkName(p); ok {
|
|
return u.SetFavorite([]string{p}, false)
|
|
}
|
|
if cleanVirtual(p) == TrashPrefix {
|
|
return u.EmptyTrash()
|
|
}
|
|
|
|
if st, id, ok := u.trashItem(p); ok {
|
|
if err := u.writable(st); err != nil {
|
|
return err
|
|
}
|
|
return st.DropTrash(id)
|
|
}
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return err
|
|
}
|
|
if st.IsS3() {
|
|
return st.deleteAs(rel, recursive, u.id)
|
|
}
|
|
_, abs, err := st.resolve(rel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := st.deleteAs(rel, recursive, u.id); err != nil {
|
|
return err
|
|
}
|
|
u.sp.unlink(abs)
|
|
return nil
|
|
}
|
|
|
|
// Thumb renvoie la miniature d'une image (voir Store.Thumb).
|
|
func (u *Space) Thumb(p string) ([]byte, string, time.Time, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return nil, "", time.Time{}, err
|
|
}
|
|
return st.Thumb(rel)
|
|
}
|
|
|
|
func (u *Space) Versions(p string) ([]Version, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return st.Versions(rel)
|
|
}
|
|
|
|
// OpenVersion ouvre une version d'un fichier en lecture.
|
|
func (u *Space) OpenVersion(p, id string) (File, fs.FileInfo, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return st.OpenVersion(rel, id)
|
|
}
|
|
|
|
func (u *Space) Snapshot(p string) (Version, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return Version{}, err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return Version{}, err
|
|
}
|
|
return st.Snapshot(rel)
|
|
}
|
|
|
|
func (u *Space) Restore(p, id string) (Entry, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if err := u.writable(st); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
e, err := st.Restore(rel, id)
|
|
if err == nil {
|
|
st.noteEdit(e.Path, u.id, false)
|
|
e.EditedBy = u.id
|
|
}
|
|
return u.entry(st, e, nil), err
|
|
}
|
|
|
|
// Shares liste les liens d'un élément, ou tous ceux visibles (arborescence
|
|
// commune et espace personnel) si p est vide.
|
|
func (u *Space) Shares(p string) ([]Share, error) {
|
|
stores := u.stores()
|
|
rel := ""
|
|
if p != "" {
|
|
st, r, err := u.route(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stores, rel = []*Store{st}, r
|
|
}
|
|
out := []Share{}
|
|
for _, st := range stores {
|
|
l, err := st.Shares(rel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, sh := range l {
|
|
sh.Path = u.virt(st, sh.Path)
|
|
out = append(out, sh)
|
|
}
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return out[i].Created.After(out[j].Created) })
|
|
return out, nil
|
|
}
|
|
|
|
func (u *Space) CreateShare(p string, o ShareOptions) (Share, error) {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return Share{}, err
|
|
}
|
|
sh, err := st.CreateShare(rel, o)
|
|
sh.Path = u.virt(st, sh.Path)
|
|
return sh, err
|
|
}
|
|
|
|
// RevokeShare supprime un lien de l'arborescence commune ou de l'espace personnel.
|
|
func (u *Space) RevokeShare(id string) error {
|
|
var err error
|
|
for _, st := range u.stores() {
|
|
if st.IsS3() && !u.canWriteMain() {
|
|
continue
|
|
}
|
|
if err = st.RevokeShare(id); !errors.Is(err, ErrNotFound) {
|
|
return err
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
// RevokeAllShares révoque tous les liens, espaces personnels compris
|
|
// (réservé aux administrateurs).
|
|
func (u *Space) RevokeAllShares() error {
|
|
if !u.admin {
|
|
return ErrForbidden
|
|
}
|
|
if err := u.sp.Main.RevokeAllShares(); err != nil {
|
|
return err
|
|
}
|
|
if u.s3 != nil {
|
|
if err := u.s3.RevokeAllShares(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, id := range u.sp.users() {
|
|
if st, err := u.sp.home(id); err == nil {
|
|
if err := st.RevokeAllShares(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// --- Transferts de métadonnées entre Stores ----------------------------------------
|
|
|
|
// 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 {
|
|
out := map[string]itemMeta{}
|
|
_ = 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)
|
|
}
|
|
}
|
|
return len(out) > 0, nil
|
|
})
|
|
return out
|
|
}
|
|
|
|
func (s *Store) putMeta(c string, m map[string]itemMeta) {
|
|
if len(m) == 0 {
|
|
return
|
|
}
|
|
_ = 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 {
|
|
out := map[string]shareDisk{}
|
|
_ = s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
for id, d := range m {
|
|
if under(d.Path, c) {
|
|
d.Path = d.Path[len(c):] // suffixe relatif à c
|
|
out[id] = d
|
|
delete(m, id)
|
|
}
|
|
}
|
|
return len(out) > 0, nil
|
|
})
|
|
return out
|
|
}
|
|
|
|
func (s *Store) putShares(c string, add map[string]shareDisk) {
|
|
if len(add) == 0 {
|
|
return
|
|
}
|
|
_ = s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
for id, d := range add {
|
|
d.Path = c + d.Path
|
|
m[id] = d
|
|
}
|
|
return true, nil
|
|
})
|
|
}
|
|
|
|
// --- Poubelle ---------------------------------------------------------------------
|
|
|
|
// trashItem traduit .poubelle/c-<id>, p-<id> ou s-<id> en Store et identifiant.
|
|
func (u *Space) trashItem(p string) (*Store, string, bool) {
|
|
key, ok := strings.CutPrefix(cleanVirtual(p), TrashPrefix+"/")
|
|
if !ok {
|
|
return nil, "", false
|
|
}
|
|
switch {
|
|
case strings.HasPrefix(key, "c-"):
|
|
return u.sp.Main, key[2:], true
|
|
case strings.HasPrefix(key, "p-"):
|
|
return u.home, key[2:], true
|
|
case strings.HasPrefix(key, "s-") && u.s3 != nil:
|
|
return u.s3, key[2:], true
|
|
}
|
|
return nil, "", false
|
|
}
|
|
|
|
// Trash liste la poubelle : suppressions de l'arborescence commune et de
|
|
// l'espace personnel, les plus récentes en premier. ModTime est la date de
|
|
// suppression, Origin le chemin d'origine.
|
|
func (u *Space) Trash() ([]Entry, error) {
|
|
out := []Entry{}
|
|
for _, st := range u.stores() {
|
|
items, err := st.TrashItems()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
prefix := "c-"
|
|
switch {
|
|
case st == u.home:
|
|
prefix = "p-"
|
|
case st.IsS3():
|
|
prefix = "s-"
|
|
}
|
|
for _, it := range items {
|
|
out = append(out, Entry{
|
|
Name: it.Name,
|
|
Path: TrashPrefix + "/" + prefix + it.ID,
|
|
IsDir: it.IsDir,
|
|
Size: it.Size,
|
|
ModTime: it.Deleted,
|
|
Origin: u.virt(st, it.Path),
|
|
By: it.By,
|
|
})
|
|
}
|
|
}
|
|
sort.SliceStable(out, func(i, j int) bool { return out[i].ModTime.After(out[j].ModTime) })
|
|
return out, nil
|
|
}
|
|
|
|
// RestoreTrash remet des éléments de la poubelle à leur emplacement d'origine ;
|
|
// To est le chemin restauré (renommé si la place était prise).
|
|
func (u *Space) RestoreTrash(paths []string) []MoveResult {
|
|
out := make([]MoveResult, 0, len(paths))
|
|
for _, p := range paths {
|
|
r := MoveResult{From: p}
|
|
st, id, ok := u.trashItem(p)
|
|
if !ok {
|
|
r.Error = ErrInvalidPath.Error()
|
|
} else if err := u.writable(st); err != nil {
|
|
r.Error = err.Error()
|
|
} else if e, err := st.RestoreTrash(id); err != nil {
|
|
r.Error = err.Error()
|
|
} else {
|
|
r.To = u.virt(st, e.Path)
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// EmptyTrash vide la poubelle (corbeille commune comprise).
|
|
func (u *Space) EmptyTrash() error {
|
|
errs := []error{u.home.EmptyTrash()}
|
|
if u.canWriteMain() {
|
|
errs = append(errs, u.sp.Main.EmptyTrash())
|
|
if u.s3 != nil {
|
|
errs = append(errs, u.s3.EmptyTrash())
|
|
}
|
|
}
|
|
return errors.Join(errs...)
|
|
}
|
|
|
|
// purgeEvery espace les purges automatiques déclenchées par List.
|
|
const purgeEvery = 10 * time.Minute
|
|
|
|
func (sp *Spaces) autoPurge() {
|
|
sp.purgeMu.Lock()
|
|
due := time.Since(sp.lastPurge) >= purgeEvery
|
|
if due {
|
|
sp.lastPurge = time.Now()
|
|
}
|
|
sp.purgeMu.Unlock()
|
|
if due {
|
|
_ = sp.PurgeTrash()
|
|
}
|
|
}
|
|
|
|
// PurgeTrash supprime définitivement, dans toutes les corbeilles, les éléments
|
|
// plus anciens que Settings.TrashDays (rien si 0).
|
|
func (sp *Spaces) PurgeTrash() error {
|
|
st, err := sp.Main.ReadSettings()
|
|
if err != nil || st.TrashDays <= 0 {
|
|
return err
|
|
}
|
|
maxAge := time.Duration(st.TrashDays) * 24 * time.Hour
|
|
errs := []error{sp.Main.PurgeTrashOlder(maxAge)}
|
|
if s3 := sp.s3.Load(); s3 != nil {
|
|
errs = append(errs, s3.PurgeTrashOlder(maxAge))
|
|
}
|
|
for _, id := range sp.users() {
|
|
h, err := sp.home(id)
|
|
if err == nil {
|
|
err = h.PurgeTrashOlder(maxAge)
|
|
}
|
|
errs = append(errs, err)
|
|
}
|
|
return errors.Join(errs...)
|
|
}
|
|
|
|
// RetireUser met de côté l'espace personnel d'un compte supprimé :
|
|
// .users/<id> devient .users-removed/<id>-<date> (l'administrateur peut le
|
|
// récupérer ou le supprimer à la main), pour qu'un compte recréé sous le même
|
|
// identifiant n'hérite pas de ses fichiers.
|
|
func (sp *Spaces) RetireUser(id string) error {
|
|
if id == "" || UserID(id) != id {
|
|
return fmt.Errorf("%w : utilisateur %q", ErrInvalidPath, id)
|
|
}
|
|
sp.mu.Lock()
|
|
delete(sp.homes, id)
|
|
sp.mu.Unlock()
|
|
src := sp.userDir(id)
|
|
if _, err := os.Stat(src); err != nil {
|
|
return nil
|
|
}
|
|
root := filepath.Join(sp.Main.root, ".users-removed")
|
|
if err := os.MkdirAll(root, 0o755); err != nil {
|
|
return err
|
|
}
|
|
return os.Rename(src, filepath.Join(root, id+"-"+time.Now().UTC().Format("20060102T150405")))
|
|
}
|
|
|
|
// commons renvoie les racines communes : arborescence, puis S3.
|
|
func (u *Space) commons() []*Store {
|
|
if u.s3 != nil {
|
|
return []*Store{u.sp.Main, u.s3}
|
|
}
|
|
return []*Store{u.sp.Main}
|
|
}
|
|
|
|
// statDir décrit rel (suit les liens sur disque) : chemin nettoyé et infos.
|
|
func (s *Store) statDir(rel string) (string, fs.FileInfo, error) {
|
|
if s.s3 != nil {
|
|
return s.lstat(rel)
|
|
}
|
|
c, abs, err := s.resolve(rel)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
fi, err := os.Stat(abs)
|
|
if err != nil {
|
|
return "", nil, mapErr(err)
|
|
}
|
|
return c, fi, nil
|
|
}
|