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
|
||||
}
|
||||
Reference in new issue
Block a user