diff --git a/internal/storage/s3config.go b/internal/storage/s3config.go new file mode 100644 index 0000000..a5e5559 --- /dev/null +++ b/internal/storage/s3config.go @@ -0,0 +1,453 @@ +package storage + +import ( + "context" + "crypto/aes" + "crypto/cipher" + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "log/slog" + "strings" + "sync" + "time" + + "github.com/jackc/pgx/v5" +) + +// Configuration de la racine S3 : variables d'environnement (S3_*) et +// interface d'administration, champ par champ. Une variable définie verrouille +// son champ ; la clé secrète n'est jamais renvoyée au navigateur. La +// configuration saisie est rangée dans le catalogue (table s3_config) et +// chaque instance la relit périodiquement : toutes basculent sur la nouvelle +// connexion sans redémarrage. + +// ErrS3NotEmpty : changement refusé tant que la racine S3 contient des éléments. +var ErrS3NotEmpty = errors.New("la racine S3 n'est pas vide") + +// S3Status décrit la configuration pour l'interface d'administration. +type S3Status struct { + Available bool `json:"available"` // catalogue PostgreSQL présent (condition de la racine S3) + Active bool `json:"active"` // racine S3 branchée + Error string `json:"error,omitempty"` + Endpoint string `json:"endpoint"` + Region string `json:"region"` + Bucket string `json:"bucket"` + AccessKey string `json:"accessKey"` + SecretSet bool `json:"secretSet"` + Insecure bool `json:"insecure"` + Locked []string `json:"locked"` // champs fixés par l'environnement + Empty bool `json:"empty"` // racine vide : endpoint et bucket modifiables +} + +// S3Patch : modification de la configuration (champs nil : inchangés ; une +// clé secrète vide est conservée). +type S3Patch struct { + Endpoint *string `json:"endpoint"` + Region *string `json:"region"` + Bucket *string `json:"bucket"` + AccessKey *string `json:"accessKey"` + SecretKey *string `json:"secretKey"` + Insecure *bool `json:"insecure"` +} + +// s3Stored : document de s3_config (clé secrète chiffrée). +type s3Stored struct { + Endpoint string `json:"endpoint,omitempty"` + Region string `json:"region,omitempty"` + Bucket string `json:"bucket,omitempty"` + AccessKey string `json:"accessKey,omitempty"` + Secret string `json:"secret,omitempty"` // base64(nonce || AES-GCM) + Insecure bool `json:"insecure,omitempty"` +} + +type s3Manager struct { + env S3Config + locked map[string]bool + cacheDir string + open func(context.Context, S3Config) (ObjectStore, error) // NewMinioObjects (tests : remplaçable) + + mu sync.Mutex // reconfigurations + seen time.Time // horodatage de s3_config appliqué + applied string // empreinte de la configuration branchée + lastErr string +} + +// s3RefreshEvery : délai de prise en compte d'une configuration modifiée +// par une autre instance (et de nouvelle tentative après une erreur). +const s3RefreshEvery = 30 * time.Second + +// ConfigureS3 prépare la racine S3 : env porte les valeurs des variables +// S3_* (un champ non vide est verrouillé), cacheDir le dossier local de ses +// miniatures. Sans catalogue, la racine S3 n'est pas disponible. La +// connexion est tentée tout de suite, puis toutes les 30 s jusqu'à ctx.Done. +func (sp *Spaces) ConfigureS3(ctx context.Context, env S3Config, cacheDir string) { + m := &s3Manager{env: env, cacheDir: cacheDir, open: NewMinioObjects, locked: map[string]bool{}} + for k, v := range map[string]string{"endpoint": env.Endpoint, "region": env.Region, "bucket": env.Bucket, + "accessKey": env.AccessKey, "secretKey": env.SecretKey} { + m.locked[k] = v != "" + } + m.locked["insecure"] = env.Insecure + sp.s3cf = m + if sp.Catalog == nil { + if env.Valid() { + slog.Warn("racine S3 ignorée : elle exige le catalogue PostgreSQL (DATABASE_URL)") + } + return + } + sp.RefreshS3(true) + go func() { + t := time.NewTicker(s3RefreshEvery) + defer t.Stop() + for { + select { + case <-ctx.Done(): + return + case <-t.C: + sp.RefreshS3(false) + } + } + }() +} + +// SetS3 branche directement une racine S3 (tests). +func (sp *Spaces) SetS3(st *Store) { + if st != nil { + st.keyFrom = sp.Main + } + sp.s3.Store(st) +} + +// s3Key : clé de chiffrement de la clé secrète, dérivée de la clé de signature +// des liens (SHARE_SECRET, commune à toutes les instances). +func (sp *Spaces) s3Key() ([]byte, error) { + k, err := sp.Main.lockedKey() + if err != nil { + return nil, err + } + h := sha256.Sum256(append([]byte("upandown-s3-config:"), k...)) + return h[:], nil +} + +func (sp *Spaces) sealSecret(plain string) (string, error) { + if plain == "" { + return "", nil + } + k, err := sp.s3Key() + if err != nil { + return "", err + } + b, _ := aes.NewCipher(k) + g, _ := cipher.NewGCM(b) + nonce := make([]byte, g.NonceSize()) + if _, err := rand.Read(nonce); err != nil { + return "", err + } + return base64.StdEncoding.EncodeToString(g.Seal(nonce, nonce, []byte(plain), nil)), nil +} + +func (sp *Spaces) openSecret(sealed string) (string, error) { + if sealed == "" { + return "", nil + } + k, err := sp.s3Key() + if err != nil { + return "", err + } + raw, err := base64.StdEncoding.DecodeString(sealed) + b, _ := aes.NewCipher(k) + g, _ := cipher.NewGCM(b) + if err != nil || len(raw) < g.NonceSize() { + return "", errors.New("clé secrète S3 illisible") + } + p, err := g.Open(nil, raw[:g.NonceSize()], raw[g.NonceSize():], nil) + if err != nil { + return "", errors.New("clé secrète S3 illisible (SHARE_SECRET changé ?) : à saisir de nouveau") + } + return string(p), nil +} + +// loadS3 lit la configuration enregistrée (zéro si aucune). +func (sp *Spaces) loadS3(ctx context.Context) (s3Stored, time.Time, error) { + var d s3Stored + var raw []byte + var at time.Time + err := sp.Catalog.Pool.QueryRow(ctx, "SELECT data, updated FROM s3_config WHERE id = 1").Scan(&raw, &at) + if errors.Is(err, pgx.ErrNoRows) { + return d, time.Time{}, nil + } + if err != nil { + return d, at, err + } + return d, at, json.Unmarshal(raw, &d) +} + +// effective fusionne l'environnement (prioritaire) et la configuration enregistrée. +func (sp *Spaces) effective(d s3Stored) (S3Config, error) { + m := sp.s3cf + pick := func(env, db string) string { + if env != "" { + return env + } + return db + } + c := S3Config{ + Endpoint: pick(m.env.Endpoint, d.Endpoint), + Region: pick(m.env.Region, d.Region), + Bucket: pick(m.env.Bucket, d.Bucket), + AccessKey: pick(m.env.AccessKey, d.AccessKey), + SecretKey: m.env.SecretKey, + Insecure: m.env.Insecure || d.Insecure, + } + if c.SecretKey == "" { + s, err := sp.openSecret(d.Secret) + if err != nil { + return c, err + } + c.SecretKey = s + } + return c, nil +} + +func fingerprint(c S3Config) string { + h := sha256.Sum256([]byte(strings.Join([]string{c.Endpoint, c.Region, c.Bucket, c.AccessKey, c.SecretKey, + fmt.Sprint(c.Insecure)}, "\x00"))) + return base64.StdEncoding.EncodeToString(h[:]) +} + +// RefreshS3 relit la configuration et rebranche la racine S3 si elle a changé +// (ou si la tentative précédente a échoué). force : relit même si rien n'a changé. +func (sp *Spaces) RefreshS3(force bool) { + m := sp.s3cf + if m == nil || sp.Catalog == nil { + return + } + m.mu.Lock() + defer m.mu.Unlock() + ctx, cancel := context.WithTimeout(context.Background(), opTimeout) + defer cancel() + d, at, err := sp.loadS3(ctx) + if err != nil { + m.lastErr = err.Error() + slog.Warn("racine S3 : lecture de la configuration", "err", err) + return + } + if !force && at.Equal(m.seen) && m.lastErr == "" { + return + } + m.seen = at + sp.applyS3(ctx, d) +} + +// applyS3 branche la racine décrite par d ; appelé sous m.mu. +func (sp *Spaces) applyS3(ctx context.Context, d s3Stored) { + m := sp.s3cf + cfg, err := sp.effective(d) + if err == nil && !cfg.Valid() { + if sp.s3.Load() != nil { + slog.Info("racine S3 débranchée") + } + sp.s3.Store(nil) + m.applied, m.lastErr = "", "" + return + } + fp := fingerprint(cfg) + if err == nil && fp == m.applied && sp.s3.Load() != nil { + m.lastErr = "" + return + } + var st *Store + if err == nil { + var objs ObjectStore + if objs, err = m.open(ctx, cfg); err == nil { + st, err = NewS3(m.cacheDir, sp.Catalog, objs) + } + } + if err != nil { + sp.s3.Store(nil) + m.applied, m.lastErr = "", err.Error() + slog.Error("racine S3 indisponible", "err", err) + return + } + sp.SetS3(st) + m.applied, m.lastErr = fp, "" + slog.Info("racine S3 branchée", "endpoint", cfg.Endpoint, "bucket", cfg.Bucket) +} + +// S3Status renvoie l'état de la configuration (sans la clé secrète). +func (sp *Spaces) S3Status() S3Status { + m := sp.s3cf + out := S3Status{Locked: []string{}} + if m == nil || sp.Catalog == nil { + return out + } + out.Available = true + ctx, cancel := context.WithTimeout(context.Background(), opTimeout) + defer cancel() + d, _, err := sp.loadS3(ctx) + m.mu.Lock() + out.Error = m.lastErr + m.mu.Unlock() + if err != nil { + out.Error = err.Error() + } + cfg := S3Config{Endpoint: m.env.Endpoint, Region: m.env.Region, Bucket: m.env.Bucket, AccessKey: m.env.AccessKey} + if cfg.Endpoint == "" { + cfg.Endpoint = d.Endpoint + } + if cfg.Region == "" { + cfg.Region = d.Region + } + if cfg.Bucket == "" { + cfg.Bucket = d.Bucket + } + if cfg.AccessKey == "" { + cfg.AccessKey = d.AccessKey + } + out.Endpoint, out.Region, out.Bucket, out.AccessKey = cfg.Endpoint, cfg.Region, cfg.Bucket, cfg.AccessKey + out.SecretSet = m.env.SecretKey != "" || d.Secret != "" + out.Insecure = m.env.Insecure || d.Insecure + for _, k := range []string{"endpoint", "region", "bucket", "accessKey", "secretKey", "insecure"} { + if m.locked[k] { + out.Locked = append(out.Locked, k) + } + } + out.Active = sp.s3.Load() != nil + out.Empty, _ = sp.s3CatalogEmpty(ctx) + return out +} + +func (sp *Spaces) s3CatalogEmpty(ctx context.Context) (bool, error) { + var n int + err := sp.Catalog.Pool.QueryRow(ctx, "SELECT (SELECT count(*) FROM s3_nodes) + (SELECT count(*) FROM s3_trash)").Scan(&n) + return n == 0, err +} + +// merge applique p à d ; refuse un champ verrouillé par l'environnement. +func (sp *Spaces) merge(d s3Stored, p S3Patch) (s3Stored, error) { + m := sp.s3cf + set := func(name string, dst *string, v *string) error { + if v == nil { + return nil + } + val := strings.TrimSpace(*v) + if m.locked[name] { + return fmt.Errorf("%w : %s est fixé par l'environnement", ErrInvalidPath, name) + } + *dst = val + return nil + } + errs := []error{ + set("endpoint", &d.Endpoint, p.Endpoint), + set("region", &d.Region, p.Region), + set("bucket", &d.Bucket, p.Bucket), + set("accessKey", &d.AccessKey, p.AccessKey), + } + if p.SecretKey != nil && *p.SecretKey != "" { + if m.locked["secretKey"] { + errs = append(errs, fmt.Errorf("%w : secretKey est fixé par l'environnement", ErrInvalidPath)) + } else if s, err := sp.sealSecret(*p.SecretKey); err != nil { + errs = append(errs, err) + } else { + d.Secret = s + } + } + if p.Insecure != nil { + if m.locked["insecure"] { + errs = append(errs, fmt.Errorf("%w : insecure est fixé par l'environnement", ErrInvalidPath)) + } + d.Insecure = *p.Insecure + } + return d, errors.Join(errs...) +} + +// check vérifie qu'une configuration peut être branchée : endpoint et bucket +// figés tant que la racine contient des éléments, connexion au bucket, et +// bucket vide si la racine l'est. +func (sp *Spaces) check(ctx context.Context, cur, next S3Config) error { + empty, err := sp.s3CatalogEmpty(ctx) + if err != nil { + return err + } + if !empty && (!next.Valid() || next.Endpoint != cur.Endpoint || next.Bucket != cur.Bucket) { + return fmt.Errorf("%w : endpoint et bucket ne peuvent changer (ni la racine être débranchée) qu'une fois la racine S3 vidée, corbeille comprise", ErrS3NotEmpty) + } + if !next.Valid() { + return nil + } + objs, err := sp.s3cf.open(ctx, next) + if err != nil { + return err + } + if empty { + ok, err := objs.Empty(ctx) + if err != nil { + return err + } + if !ok { + return fmt.Errorf("%w : le bucket %s contient déjà des objets (bucket vide attendu)", ErrS3NotEmpty, next.Bucket) + } + } + return nil +} + +// TestS3 vérifie la configuration modifiée par p sans l'enregistrer. +func (sp *Spaces) TestS3(p S3Patch) error { + _, err := sp.prepareS3(p) + return err +} + +func (sp *Spaces) prepareS3(p S3Patch) (s3Stored, error) { + if sp.s3cf == nil || sp.Catalog == nil { + return s3Stored{}, fmt.Errorf("%w : la racine S3 exige le catalogue PostgreSQL", ErrInvalidPath) + } + ctx, cancel := context.WithTimeout(context.Background(), opTimeout) + defer cancel() + d, _, err := sp.loadS3(ctx) + if err != nil { + return d, err + } + cur, _ := sp.effective(d) + nd, err := sp.merge(d, p) + if err != nil { + return nd, err + } + next, err := sp.effective(nd) + if err != nil { + return nd, err + } + if next.Endpoint != "" || next.Bucket != "" || next.AccessKey != "" || next.SecretKey != "" { + if !next.Valid() { + return nd, fmt.Errorf("%w : configuration S3 incomplète (endpoint, bucket, clés)", ErrInvalidPath) + } + } + return nd, sp.check(ctx, cur, next) +} + +// SaveS3 vérifie, enregistre et applique la configuration modifiée par p. +// Les autres instances la prennent en compte sous 30 s. +func (sp *Spaces) SaveS3(p S3Patch) (S3Status, error) { + nd, err := sp.prepareS3(p) + if err != nil { + return S3Status{}, err + } + b, err := json.Marshal(nd) + if err != nil { + return S3Status{}, err + } + ctx, cancel := context.WithTimeout(context.Background(), opTimeout) + defer cancel() + err = sp.Catalog.Tx(ctx, func(tx pgx.Tx) error { + _, err := tx.Exec(ctx, `INSERT INTO s3_config (id, data) VALUES (1, $1) + ON CONFLICT (id) DO UPDATE SET data = $1, updated = clock_timestamp()`, b) + return err + }) + if err != nil { + return S3Status{}, err + } + sp.RefreshS3(true) + return sp.S3Status(), nil +} diff --git a/internal/storage/s3config_test.go b/internal/storage/s3config_test.go new file mode 100644 index 0000000..ad5a3c0 --- /dev/null +++ b/internal/storage/s3config_test.go @@ -0,0 +1,89 @@ +package storage + +import ( + "context" + "errors" + "strings" + "testing" +) + +// s3Instance : une instance (Spaces) avec catalogue, racine S3 configurable +// sur des buckets en mémoire. +func s3Instance(t *testing.T, env S3Config, buckets map[string]*memObjects) *Spaces { + t.Helper() + db := needCatalog(t) + main := newStore(t) + if err := main.SetShareSecret("secret-commun-de-test-0123456789"); err != nil { + t.Fatal(err) + } + sp := NewSpaces(main) + sp.Catalog = db + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + sp.ConfigureS3(ctx, env, t.TempDir()) + sp.s3cf.open = func(_ context.Context, c S3Config) (ObjectStore, error) { + b := buckets[c.Bucket] + if b == nil || c.SecretKey != "bonne-cle" { + return nil, errors.New("accès refusé") + } + return b, nil + } + return sp +} + +func str(s string) *string { return &s } + +func TestS3ConfigAdmin(t *testing.T) { + newS3Store(t) // remet les tables S3 à zéro + buckets := map[string]*memObjects{"b1": newMemObjects(), "b2": newMemObjects(), "plein": newMemObjects()} + buckets["plein"].objs["autre"] = []byte("x") + env := S3Config{Endpoint: "https://garage:3900"} // endpoint verrouillé + a := s3Instance(t, env, buckets) + b := s3Instance(t, env, buckets) + + st := a.S3Status() + if !st.Available || st.Active || len(st.Locked) != 1 || st.Locked[0] != "endpoint" { + t.Fatalf("état initial : %+v", st) + } + if _, err := a.SaveS3(S3Patch{Endpoint: str("http://ailleurs")}); err == nil { + t.Error("champ verrouillé modifié") + } + if err := a.TestS3(S3Patch{Bucket: str("b1"), AccessKey: str("ak"), SecretKey: str("mauvaise")}); err == nil { + t.Error("mauvaise clé acceptée") + } + if err := a.TestS3(S3Patch{Bucket: str("plein"), AccessKey: str("ak"), SecretKey: str("bonne-cle")}); !errors.Is(err, ErrS3NotEmpty) { + t.Errorf("bucket non vide : %v", err) + } + st, err := a.SaveS3(S3Patch{Bucket: str("b1"), AccessKey: str("ak"), SecretKey: str("bonne-cle")}) + if err != nil || !st.Active || !st.SecretSet || st.Bucket != "b1" { + t.Fatalf("enregistrement : %+v %v", st, err) + } + // La clé secrète n'est ni renvoyée ni stockée en clair. + var raw string + if err := a.Catalog.Pool.QueryRow(context.Background(), "SELECT data::text FROM s3_config").Scan(&raw); err != nil { + t.Fatal(err) + } + if strings.Contains(raw, "bonne-cle") { + t.Error("clé secrète en clair dans le catalogue") + } + + // L'autre instance suit sans redémarrer. + b.RefreshS3(false) + ub := space(t, b, "bob", false) + uput(t, ub, ".s3/f.txt", "F") + ua := space(t, a, "alice", false) + if e, err := ua.Stat(".s3/f.txt"); err != nil || e.Size != 1 { + t.Errorf("instance a : %+v %v", e, err) + } + + // Racine non vide : bucket figé, rotation des clés permise. + if _, err := a.SaveS3(S3Patch{Bucket: str("b2")}); !errors.Is(err, ErrS3NotEmpty) { + t.Errorf("changement de bucket : %v", err) + } + if _, err := a.SaveS3(S3Patch{Bucket: str(""), AccessKey: str(""), SecretKey: str("")}); err == nil { + t.Error("racine non vide débranchée") + } + if _, err := a.SaveS3(S3Patch{AccessKey: str("ak2"), SecretKey: str("bonne-cle")}); err != nil { + t.Errorf("rotation des clés : %v", err) + } +} diff --git a/internal/storage/spaces.go b/internal/storage/spaces.go index 24d25bc..ff63d7c 100644 --- a/internal/storage/spaces.go +++ b/internal/storage/spaces.go @@ -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-", // visibles de tous) et de l'espace personnel (".poubelle/p-"). +// +// 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-". 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- ou .poubelle/p- en Store et identifiant. +// trashItem traduit .poubelle/c-, p- ou s- 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 +}