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 }