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:
1 parent
1da55c7ad7
commit
53972f9762
3 files changed
+727
-42
No files matched your search
@@ -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
|
||||||
|
}
|
||||||
@@ -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)
|
||||||
|
}
|
||||||
|
}
|
||||||
+185
-42
@@ -13,6 +13,7 @@ import (
|
|||||||
"sort"
|
"sort"
|
||||||
"strings"
|
"strings"
|
||||||
"sync"
|
"sync"
|
||||||
|
"sync/atomic"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/vblogio/upandown/internal/catalog"
|
"github.com/vblogio/upandown/internal/catalog"
|
||||||
@@ -31,6 +32,10 @@ import (
|
|||||||
// renommages et déplacements et disparaît quand le fichier est supprimé. La
|
// 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>",
|
// poubelle réunit les corbeilles de l'arborescence commune (".poubelle/c-<id>",
|
||||||
// visibles de tous) et de l'espace personnel (".poubelle/p-<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 (
|
const (
|
||||||
// PersoPrefix est la racine virtuelle de l'espace personnel.
|
// PersoPrefix est la racine virtuelle de l'espace personnel.
|
||||||
@@ -39,6 +44,8 @@ const (
|
|||||||
FavPrefix = ".favoris"
|
FavPrefix = ".favoris"
|
||||||
// TrashPrefix est le dossier virtuel de la poubelle.
|
// TrashPrefix est le dossier virtuel de la poubelle.
|
||||||
TrashPrefix = ".poubelle"
|
TrashPrefix = ".poubelle"
|
||||||
|
// S3Prefix est la racine virtuelle du stockage objet (si configuré).
|
||||||
|
S3Prefix = ".s3"
|
||||||
|
|
||||||
usersDir = ".users"
|
usersDir = ".users"
|
||||||
homeName = "home"
|
homeName = "home"
|
||||||
@@ -78,6 +85,11 @@ func UserID(raw string) string {
|
|||||||
type Spaces struct {
|
type Spaces struct {
|
||||||
Main *Store
|
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 borne la taille d'un fichier déposé (octets ; 0 : illimité).
|
||||||
MaxUpload int64
|
MaxUpload int64
|
||||||
|
|
||||||
@@ -137,7 +149,7 @@ func (sp *Spaces) For(id string, admin bool) (*Space, error) {
|
|||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
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.
|
// 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) {
|
if !errors.Is(err, ErrNotFound) {
|
||||||
return sh, sp.Main, err
|
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() {
|
for _, id := range sp.users() {
|
||||||
st, herr := sp.home(id)
|
st, herr := sp.home(id)
|
||||||
if herr != nil {
|
if herr != nil {
|
||||||
@@ -281,7 +298,8 @@ type Space struct {
|
|||||||
sp *Spaces
|
sp *Spaces
|
||||||
id string
|
id string
|
||||||
home *Store
|
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.
|
// 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)
|
return nil, "", fmt.Errorf("%w : le dossier Favoris ne contient que des liens", ErrInvalidPath)
|
||||||
case c == TrashPrefix || strings.HasPrefix(c, TrashPrefix+"/"):
|
case c == TrashPrefix || strings.HasPrefix(c, TrashPrefix+"/"):
|
||||||
return nil, "", fmt.Errorf("%w : élément de la poubelle (à restaurer d'abord)", ErrInvalidPath)
|
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
|
return u.sp.Main, p, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// virt traduit un chemin relatif à st en chemin virtuel.
|
// virt traduit un chemin relatif à st en chemin virtuel.
|
||||||
func (u *Space) virt(st *Store, rel string) string {
|
func (u *Space) virt(st *Store, rel string) string {
|
||||||
if st == u.sp.Main {
|
prefix := PersoPrefix
|
||||||
|
switch {
|
||||||
|
case st == u.sp.Main:
|
||||||
return rel
|
return rel
|
||||||
|
case st == u.s3 && st != nil:
|
||||||
|
prefix = S3Prefix
|
||||||
}
|
}
|
||||||
if rel == "" {
|
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.
|
// 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 {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
if st.IsS3() {
|
||||||
|
return fmt.Errorf("%w : pas de favoris sur la racine S3", ErrInvalidPath)
|
||||||
|
}
|
||||||
c, abs, err := st.resolve(rel)
|
c, abs, err := st.resolve(rel)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
@@ -464,13 +508,19 @@ func (u *Space) List(p string) ([]Entry, error) {
|
|||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
favs := u.favSet()
|
favs := u.favSet()
|
||||||
out := make([]Entry, 0, len(es)+2)
|
out := make([]Entry, 0, len(es)+4)
|
||||||
if st == u.sp.Main && isRoot(rel) {
|
if st == u.sp.Main && isRoot(rel) {
|
||||||
|
n := 0
|
||||||
|
for _, s := range u.stores() {
|
||||||
|
n += s.TrashCount()
|
||||||
|
}
|
||||||
out = append(out,
|
out = append(out,
|
||||||
Entry{Name: "Favoris", Path: FavPrefix, IsDir: true, Special: "favoris"},
|
Entry{Name: "Favoris", Path: FavPrefix, IsDir: true, Special: "favoris"},
|
||||||
Entry{Name: "Personnel", Path: PersoPrefix, IsDir: true, Special: "perso"},
|
Entry{Name: "Personnel", Path: PersoPrefix, IsDir: true, Special: "perso"})
|
||||||
Entry{Name: "Poubelle", Path: TrashPrefix, IsDir: true, Special: "poubelle",
|
if u.s3 != nil {
|
||||||
Count: u.sp.Main.TrashCount() + u.home.TrashCount()})
|
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 {
|
for _, e := range es {
|
||||||
out = append(out, u.entry(st, e, favs))
|
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
|
lim = 1 << 30 // filtrés ensuite
|
||||||
}
|
}
|
||||||
var all []Hit
|
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)
|
hs, err := st.Search(q, inner, lim)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
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) {
|
func (u *Space) Tags() ([]TagCount, error) {
|
||||||
idx := map[string]int{}
|
idx := map[string]int{}
|
||||||
out := []TagCount{}
|
out := []TagCount{}
|
||||||
for _, st := range []*Store{u.sp.Main, u.home} {
|
for _, st := range u.stores() {
|
||||||
ts, err := st.Tags()
|
ts, err := st.Tags()
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
@@ -598,7 +648,7 @@ func (u *Space) canWriteMain() bool {
|
|||||||
// writable refuse la modification de l'arborescence commune en lecture seule.
|
// writable refuse la modification de l'arborescence commune en lecture seule.
|
||||||
func (u *Space) writable(stores ...*Store) error {
|
func (u *Space) writable(stores ...*Store) error {
|
||||||
for _, st := range stores {
|
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)
|
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
|
return st.QuotaMB << 20
|
||||||
}
|
}
|
||||||
|
|
||||||
// quotaFor vérifie que le contenu de abs (fichier ou dossier) tient dans le
|
// quotaFor vérifie que rel de src (fichier ou dossier) tient dans le quota
|
||||||
// quota restant de l'espace st, si c'est un espace personnel.
|
// restant de l'espace st, si c'est un espace personnel.
|
||||||
func (u *Space) quotaFor(st *Store, abs string) error {
|
func (u *Space) quotaFor(st, src *Store, rel string) error {
|
||||||
q := u.quota()
|
q := u.quota()
|
||||||
if st == u.sp.Main || q == 0 {
|
if u.common(st) || q == 0 {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
var size int64
|
var size int64
|
||||||
_ = filepath.WalkDir(abs, func(_ string, d fs.DirEntry, err error) error {
|
if src.IsS3() {
|
||||||
if err == nil && d.Type().IsRegular() {
|
_ = src.Walk(rel, func(_ string, e Entry) error {
|
||||||
if fi, err := d.Info(); err == nil {
|
size += e.Size
|
||||||
size += fi.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 {
|
if st.Usage()+size > q {
|
||||||
return ErrQuota
|
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.By = u.id
|
||||||
o.Limit, o.LimitErr = u.sp.MaxUpload, ErrTooLarge
|
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()
|
rem := q - st.Usage()
|
||||||
if rem <= 0 {
|
if rem <= 0 {
|
||||||
return Entry{}, ErrQuota
|
return Entry{}, ErrQuota
|
||||||
@@ -720,10 +777,15 @@ func (u *Space) Move(from, to string) (Entry, error) {
|
|||||||
return Entry{}, err
|
return Entry{}, err
|
||||||
}
|
}
|
||||||
if sf != st {
|
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
|
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
|
return u.entry(st, e, nil), err
|
||||||
}
|
}
|
||||||
cf, _ := Clean(rf)
|
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
|
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).
|
// moveAside déplace src vers dst s'il existe (miniatures, historique).
|
||||||
func moveAside(src, dst string) {
|
func moveAside(src, dst string) {
|
||||||
if _, err := os.Stat(src); err != nil {
|
if _, err := os.Stat(src); err != nil {
|
||||||
@@ -795,14 +887,10 @@ func (u *Space) MoveMany(paths []string, dir string) ([]MoveResult, error) {
|
|||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
cd, ad, err := sd.resolve(rd)
|
cd, fi, err := sd.statDir(rd)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
fi, err := os.Stat(ad)
|
|
||||||
if err != nil {
|
|
||||||
return nil, mapErr(err)
|
|
||||||
}
|
|
||||||
if !fi.IsDir() {
|
if !fi.IsDir() {
|
||||||
return nil, fmt.Errorf("%w : la destination n'est pas un dossier", ErrInvalidPath)
|
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 {
|
if err := u.writable(st); err != nil {
|
||||||
return Entry{}, err
|
return Entry{}, err
|
||||||
}
|
}
|
||||||
cf, af, err := sf.resolve(rf)
|
cf, _, err := sf.lstat(rf)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return Entry{}, err
|
return Entry{}, err
|
||||||
}
|
}
|
||||||
if cf == "" {
|
if cf == "" {
|
||||||
return Entry{}, ErrInvalidPath
|
return Entry{}, ErrInvalidPath
|
||||||
}
|
}
|
||||||
if err := u.quotaFor(st, af); err != nil {
|
if err := u.quotaFor(st, sf, rf); err != nil {
|
||||||
return Entry{}, err
|
return Entry{}, err
|
||||||
}
|
}
|
||||||
|
af := absOf(sf, cf)
|
||||||
var e Entry
|
var e Entry
|
||||||
if sf == st {
|
switch {
|
||||||
|
case sf == st:
|
||||||
e, err = sf.Copy(rf, rt)
|
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)
|
ct, at, rerr := st.resolve(rt)
|
||||||
if rerr != nil {
|
if rerr != nil {
|
||||||
return Entry{}, rerr
|
return Entry{}, rerr
|
||||||
@@ -921,6 +1016,9 @@ func (u *Space) Delete(p string, recursive bool) error {
|
|||||||
if err := u.writable(st); err != nil {
|
if err := u.writable(st); err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
if st.IsS3() {
|
||||||
|
return st.deleteAs(rel, recursive, u.id)
|
||||||
|
}
|
||||||
_, abs, err := st.resolve(rel)
|
_, abs, err := st.resolve(rel)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
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
|
// Shares liste les liens d'un élément, ou tous ceux visibles (arborescence
|
||||||
// commune et espace personnel) si p est vide.
|
// commune et espace personnel) si p est vide.
|
||||||
func (u *Space) Shares(p string) ([]Share, error) {
|
func (u *Space) Shares(p string) ([]Share, error) {
|
||||||
stores := []*Store{u.sp.Main, u.home}
|
stores := u.stores()
|
||||||
rel := ""
|
rel := ""
|
||||||
if p != "" {
|
if p != "" {
|
||||||
st, r, err := u.route(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.
|
// RevokeShare supprime un lien de l'arborescence commune ou de l'espace personnel.
|
||||||
func (u *Space) RevokeShare(id string) error {
|
func (u *Space) RevokeShare(id string) error {
|
||||||
err := u.sp.Main.RevokeShare(id)
|
var err error
|
||||||
if errors.Is(err, ErrNotFound) {
|
for _, st := range u.stores() {
|
||||||
err = u.home.RevokeShare(id)
|
if st.IsS3() && !u.canWriteMain() {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if err = st.RevokeShare(id); !errors.Is(err, ErrNotFound) {
|
||||||
|
return err
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
@@ -1040,6 +1143,11 @@ func (u *Space) RevokeAllShares() error {
|
|||||||
if err := u.sp.Main.RevokeAllShares(); err != nil {
|
if err := u.sp.Main.RevokeAllShares(); err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
if u.s3 != nil {
|
||||||
|
if err := u.s3.RevokeAllShares(); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
for _, id := range u.sp.users() {
|
for _, id := range u.sp.users() {
|
||||||
if st, err := u.sp.home(id); err == nil {
|
if st, err := u.sp.home(id); err == nil {
|
||||||
if err := st.RevokeAllShares(); err != nil {
|
if err := st.RevokeAllShares(); err != nil {
|
||||||
@@ -1111,7 +1219,7 @@ func (s *Store) putShares(c string, add map[string]shareDisk) {
|
|||||||
|
|
||||||
// --- Poubelle ---------------------------------------------------------------------
|
// --- 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) {
|
func (u *Space) trashItem(p string) (*Store, string, bool) {
|
||||||
key, ok := strings.CutPrefix(cleanVirtual(p), TrashPrefix+"/")
|
key, ok := strings.CutPrefix(cleanVirtual(p), TrashPrefix+"/")
|
||||||
if !ok {
|
if !ok {
|
||||||
@@ -1122,6 +1230,8 @@ func (u *Space) trashItem(p string) (*Store, string, bool) {
|
|||||||
return u.sp.Main, key[2:], true
|
return u.sp.Main, key[2:], true
|
||||||
case strings.HasPrefix(key, "p-"):
|
case strings.HasPrefix(key, "p-"):
|
||||||
return u.home, key[2:], true
|
return u.home, key[2:], true
|
||||||
|
case strings.HasPrefix(key, "s-") && u.s3 != nil:
|
||||||
|
return u.s3, key[2:], true
|
||||||
}
|
}
|
||||||
return nil, "", false
|
return nil, "", false
|
||||||
}
|
}
|
||||||
@@ -1131,14 +1241,17 @@ func (u *Space) trashItem(p string) (*Store, string, bool) {
|
|||||||
// suppression, Origin le chemin d'origine.
|
// suppression, Origin le chemin d'origine.
|
||||||
func (u *Space) Trash() ([]Entry, error) {
|
func (u *Space) Trash() ([]Entry, error) {
|
||||||
out := []Entry{}
|
out := []Entry{}
|
||||||
for _, st := range []*Store{u.sp.Main, u.home} {
|
for _, st := range u.stores() {
|
||||||
items, err := st.TrashItems()
|
items, err := st.TrashItems()
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
prefix := "c-"
|
prefix := "c-"
|
||||||
if st == u.home {
|
switch {
|
||||||
|
case st == u.home:
|
||||||
prefix = "p-"
|
prefix = "p-"
|
||||||
|
case st.IsS3():
|
||||||
|
prefix = "s-"
|
||||||
}
|
}
|
||||||
for _, it := range items {
|
for _, it := range items {
|
||||||
out = append(out, Entry{
|
out = append(out, Entry{
|
||||||
@@ -1182,6 +1295,9 @@ func (u *Space) EmptyTrash() error {
|
|||||||
errs := []error{u.home.EmptyTrash()}
|
errs := []error{u.home.EmptyTrash()}
|
||||||
if u.canWriteMain() {
|
if u.canWriteMain() {
|
||||||
errs = append(errs, u.sp.Main.EmptyTrash())
|
errs = append(errs, u.sp.Main.EmptyTrash())
|
||||||
|
if u.s3 != nil {
|
||||||
|
errs = append(errs, u.s3.EmptyTrash())
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return errors.Join(errs...)
|
return errors.Join(errs...)
|
||||||
}
|
}
|
||||||
@@ -1210,6 +1326,9 @@ func (sp *Spaces) PurgeTrash() error {
|
|||||||
}
|
}
|
||||||
maxAge := time.Duration(st.TrashDays) * 24 * time.Hour
|
maxAge := time.Duration(st.TrashDays) * 24 * time.Hour
|
||||||
errs := []error{sp.Main.PurgeTrashOlder(maxAge)}
|
errs := []error{sp.Main.PurgeTrashOlder(maxAge)}
|
||||||
|
if s3 := sp.s3.Load(); s3 != nil {
|
||||||
|
errs = append(errs, s3.PurgeTrashOlder(maxAge))
|
||||||
|
}
|
||||||
for _, id := range sp.users() {
|
for _, id := range sp.users() {
|
||||||
h, err := sp.home(id)
|
h, err := sp.home(id)
|
||||||
if err == nil {
|
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")))
|
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
|
||||||
|
}
|
||||||
Reference in new issue
Block a user