Lot 3 (3/4) : racine S3 dans les espaces, configuration env + admin

.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
This commit is contained in:
claude BotandClaude Opus 5.5 committed 2026-11-20 18:04:37 +01:00
1 parent 1da55c7ad7
commit 53972f9762
3 files changed
+727 -42

No files matched your search

+185 -42
View File
@@ -13,6 +13,7 @@ import (
"sort"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/vblogio/upandown/internal/catalog"
@@ -31,6 +32,10 @@ import (
// 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.
@@ -39,6 +44,8 @@ const (
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"
@@ -78,6 +85,11 @@ func UserID(raw string) string {
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
@@ -137,7 +149,7 @@ func (sp *Spaces) For(id string, admin bool) (*Space, error) {
if err != nil {
return nil, err
}
return &Space{sp: sp, id: id, home: h, admin: admin}, nil
return &Space{sp: sp, id: id, home: h, s3: sp.s3.Load(), admin: admin}, nil
}
// users liste les utilisateurs qui ont un espace.
@@ -159,6 +171,11 @@ func (sp *Spaces) ResolveShare(token string) (Share, *Store, error) {
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 {
@@ -281,7 +298,8 @@ type Space struct {
sp *Spaces
id string
home *Store
admin bool // administrateur : écrit toujours dans l'arborescence commune
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.
@@ -306,19 +324,42 @@ func (u *Space) route(p string) (*Store, string, error) {
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 {
if st == u.sp.Main {
prefix := PersoPrefix
switch {
case st == u.sp.Main:
return rel
case st == u.s3 && st != nil:
prefix = S3Prefix
}
if rel == "" {
return PersoPrefix
return prefix
}
return PersoPrefix + "/" + rel
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.
@@ -398,6 +439,9 @@ func (u *Space) SetFavorite(paths []string, favorite bool) error {
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
@@ -464,13 +508,19 @@ func (u *Space) List(p string) ([]Entry, error) {
return nil, err
}
favs := u.favSet()
out := make([]Entry, 0, len(es)+2)
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"},
Entry{Name: "Poubelle", Path: TrashPrefix, IsDir: true, Special: "poubelle",
Count: u.sp.Main.TrashCount() + u.home.TrashCount()})
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))
@@ -498,7 +548,7 @@ func (u *Space) Search(q string, f Filter, limit int) ([]Hit, error) {
lim = 1 << 30 // filtrés ensuite
}
var all []Hit
for _, st := range []*Store{u.home, u.sp.Main} {
for _, st := range append([]*Store{u.home}, u.commons()...) {
hs, err := st.Search(q, inner, lim)
if err != nil {
return nil, err
@@ -525,7 +575,7 @@ func (u *Space) Search(q string, f Filter, limit int) ([]Hit, error) {
func (u *Space) Tags() ([]TagCount, error) {
idx := map[string]int{}
out := []TagCount{}
for _, st := range []*Store{u.sp.Main, u.home} {
for _, st := range u.stores() {
ts, err := st.Tags()
if err != nil {
return nil, err
@@ -598,7 +648,7 @@ func (u *Space) canWriteMain() bool {
// 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() {
if u.common(st) && !u.canWriteMain() {
return fmt.Errorf("%w : l'arborescence commune est en lecture seule", ErrForbidden)
}
}
@@ -614,22 +664,29 @@ func (u *Space) quota() int64 {
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 {
// 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 st == u.sp.Main || q == 0 {
if u.common(st) || 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()
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
})
return nil
})
}
if st.Usage()+size > q {
return ErrQuota
}
@@ -674,7 +731,7 @@ func (u *Space) Put(p string, r io.Reader, size int64, o PutOptions) (Entry, err
}
o.By = u.id
o.Limit, o.LimitErr = u.sp.MaxUpload, ErrTooLarge
if q := u.quota(); q > 0 && st != u.sp.Main {
if q := u.quota(); q > 0 && !u.common(st) {
rem := q - st.Usage()
if rem <= 0 {
return Entry{}, ErrQuota
@@ -720,10 +777,15 @@ func (u *Space) Move(from, to string) (Entry, error) {
return Entry{}, err
}
if sf != st {
if err := u.quotaFor(st, absOf(sf, cleanOr(rf))); err != nil {
if err := u.quotaFor(st, sf, rf); err != nil {
return Entry{}, err
}
e, err := u.sp.moveAcross(sf, rf, st, rt)
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)
@@ -778,6 +840,36 @@ func (sp *Spaces) moveAcross(src *Store, from string, dst *Store, to string) (En
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 {
@@ -795,14 +887,10 @@ func (u *Space) MoveMany(paths []string, dir string) ([]MoveResult, error) {
if err != nil {
return nil, err
}
cd, ad, err := sd.resolve(rd)
cd, fi, err := sd.statDir(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)
}
@@ -849,20 +937,27 @@ func (u *Space) Copy(from, to string) (Entry, error) {
if err := u.writable(st); err != nil {
return Entry{}, err
}
cf, af, err := sf.resolve(rf)
cf, _, err := sf.lstat(rf)
if err != nil {
return Entry{}, err
}
if cf == "" {
return Entry{}, ErrInvalidPath
}
if err := u.quotaFor(st, af); err != nil {
if err := u.quotaFor(st, sf, rf); err != nil {
return Entry{}, err
}
af := absOf(sf, cf)
var e Entry
if sf == st {
switch {
case sf == st:
e, err = sf.Copy(rf, rt)
} else {
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
@@ -921,6 +1016,9 @@ func (u *Space) Delete(p string, recursive bool) error {
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
@@ -988,7 +1086,7 @@ func (u *Space) Restore(p, id string) (Entry, error) {
// 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}
stores := u.stores()
rel := ""
if p != "" {
st, r, err := u.route(p)
@@ -1024,9 +1122,14 @@ func (u *Space) CreateShare(p string, o ShareOptions) (Share, error) {
// 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)
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
}
@@ -1040,6 +1143,11 @@ func (u *Space) RevokeAllShares() error {
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 {
@@ -1111,7 +1219,7 @@ func (s *Store) putShares(c string, add map[string]shareDisk) {
// --- Poubelle ---------------------------------------------------------------------
// trashItem traduit .poubelle/c-<id> ou .poubelle/p-<id> en Store et identifiant.
// 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 {
@@ -1122,6 +1230,8 @@ func (u *Space) trashItem(p string) (*Store, string, bool) {
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
}
@@ -1131,14 +1241,17 @@ func (u *Space) trashItem(p string) (*Store, string, bool) {
// suppression, Origin le chemin d'origine.
func (u *Space) Trash() ([]Entry, error) {
out := []Entry{}
for _, st := range []*Store{u.sp.Main, u.home} {
for _, st := range u.stores() {
items, err := st.TrashItems()
if err != nil {
return nil, err
}
prefix := "c-"
if st == u.home {
switch {
case st == u.home:
prefix = "p-"
case st.IsS3():
prefix = "s-"
}
for _, it := range items {
out = append(out, Entry{
@@ -1182,6 +1295,9 @@ 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...)
}
@@ -1210,6 +1326,9 @@ func (sp *Spaces) PurgeTrash() error {
}
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 {
@@ -1241,3 +1360,27 @@ func (sp *Spaces) RetireUser(id string) error {
}
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
}