- 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
1244 lines
32 KiB
Go
1244 lines
32 KiB
Go
package storage
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"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>").
|
|
|
|
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"
|
|
|
|
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
|
|
|
|
// 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, 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
|
|
}
|
|
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
|
|
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)
|
|
}
|
|
return u.sp.Main, p, nil
|
|
}
|
|
|
|
// virt traduit un chemin relatif à st en chemin virtuel.
|
|
func (u *Space) virt(st *Store, rel string) string {
|
|
if st == u.sp.Main {
|
|
return rel
|
|
}
|
|
if rel == "" {
|
|
return PersoPrefix
|
|
}
|
|
return PersoPrefix + "/" + rel
|
|
}
|
|
|
|
// 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
|
|
}
|
|
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)+2)
|
|
if st == u.sp.Main && isRoot(rel) {
|
|
out = append(out,
|
|
Entry{Name: "Favoris", Path: FavPrefix, IsDir: true, Special: "favoris"},
|
|
Entry{Name: "Personnel", Path: PersoPrefix, IsDir: true, Special: "perso"},
|
|
Entry{Name: "Poubelle", Path: TrashPrefix, IsDir: true, Special: "poubelle",
|
|
Count: u.sp.Main.TrashCount() + u.home.TrashCount()})
|
|
}
|
|
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 []*Store{u.home, u.sp.Main} {
|
|
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 []*Store{u.sp.Main, u.home} {
|
|
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 st == u.sp.Main && !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 le contenu de abs (fichier ou dossier) tient dans le
|
|
// quota restant de l'espace st, si c'est un espace personnel.
|
|
func (u *Space) quotaFor(st *Store, abs string) error {
|
|
q := u.quota()
|
|
if st == u.sp.Main || q == 0 {
|
|
return nil
|
|
}
|
|
var size int64
|
|
_ = filepath.WalkDir(abs, 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 && st != u.sp.Main {
|
|
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, absOf(sf, cleanOr(rf))); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
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
|
|
}
|
|
|
|
// 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, ad, err := sd.resolve(rd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fi, err := os.Stat(ad)
|
|
if err != nil {
|
|
return nil, mapErr(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, af, err := sf.resolve(rf)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if cf == "" {
|
|
return Entry{}, ErrInvalidPath
|
|
}
|
|
if err := u.quotaFor(st, af); err != nil {
|
|
return Entry{}, err
|
|
}
|
|
var e Entry
|
|
if sf == st {
|
|
e, err = sf.Copy(rf, rt)
|
|
} else {
|
|
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
|
|
}
|
|
_, 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 := []*Store{u.sp.Main, u.home}
|
|
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 {
|
|
err := u.sp.Main.RevokeShare(id)
|
|
if errors.Is(err, ErrNotFound) {
|
|
err = u.home.RevokeShare(id)
|
|
}
|
|
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
|
|
}
|
|
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> ou .poubelle/p-<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
|
|
}
|
|
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 []*Store{u.sp.Main, u.home} {
|
|
items, err := st.TrashItems()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
prefix := "c-"
|
|
if st == u.home {
|
|
prefix = "p-"
|
|
}
|
|
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())
|
|
}
|
|
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)}
|
|
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")))
|
|
}
|