.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
90 lines
3.1 KiB
Go
90 lines
3.1 KiB
Go
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)
|
|
}
|
|
}
|