From e79a813272adc1359104a94a544e0872cc67dd1e Mon Sep 17 00:00:00 2001 From: claude Date: Fri, 20 Nov 2026 18:05:17 +0100 Subject: [PATCH] Lot 3 (4/5) : API admin S3, variables S3_*, tests et documentation GET/PUT /api/admin/s3 et POST /api/admin/s3/test (administrateurs) ; S3_ENDPOINT, S3_REGION, S3_BUCKET, S3_ACCESS_KEY, S3_SECRET_KEY (_FILE), S3_INSECURE ; miniatures S3 sous DATA_DIR/.s3cache. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB --- .env.example | 7 +++++ README.md | 4 +++ cmd/server/main.go | 11 +++++++ internal/api/api.go | 4 +++ internal/api/api_test.go | 4 +++ internal/api/s3.go | 65 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 95 insertions(+) create mode 100644 internal/api/s3.go diff --git a/.env.example b/.env.example index 1ad9b24..05196b0 100644 --- a/.env.example +++ b/.env.example @@ -30,3 +30,10 @@ SHARE_SECRET= # spécial d'URL (@ : / ? #), sinon fournir DATABASE_URL complète et encodée. POSTGRES_PASSWORD= DATABASE_URL= +# Racine S3 (facultatif, exige DATABASE_URL ; aussi réglable dans Administration). +# À reporter dans le bloc environment du service si utilisé. +S3_ENDPOINT= +S3_REGION= +S3_BUCKET= +S3_ACCESS_KEY= +S3_SECRET_KEY= diff --git a/README.md b/README.md index 508bfad..cc63197 100644 --- a/README.md +++ b/README.md @@ -47,9 +47,13 @@ Pour imposer l'administrateur : `ADMIN_USER` et `ADMIN_PASSWORD` dans `.env`. Le | `SESSION_TTL` / `SESSION_SECRET` | `24h` / aléatoire | Session ; clé de signature (sinon `DATA_DIR/.session-secret`). Obligatoire avec `DATABASE_URL` ; `hex:` garde les sessions ouvertes | | `SHARE_SECRET` | aléatoire | Clé de signature des liens de partage. Obligatoire avec `DATABASE_URL` ; `hex:` garde valides les liens existants | | `PUBLIC_URL` | | URL publique (cookies `Secure`) | +| `S3_ENDPOINT` / `S3_REGION` / `S3_BUCKET` | / `garage` / | Racine S3 (Garage ou S3 compatible), exige `DATABASE_URL`. Configurable aussi dans Administration ; une variable définie verrouille son champ | +| `S3_ACCESS_KEY` / `S3_SECRET_KEY` (ou `_FILE`) / `S3_INSECURE` | / / `false` | Clés du bucket ; `S3_INSECURE=true` : HTTP pour un endpoint sans schéma. Clé saisie dans l'interface : chiffrée en base avec `SHARE_SECRET`, jamais renvoyée | Les valeurs d'inscription, de quota, de lecture seule et de poubelle sont des défauts : une fois modifiées dans l'interface, c'est le réglage de l'interface qui prime. +Racine S3 : dossier « S3 » commun à tous, mêmes droits que l'arborescence commune (lecture seule possible, l'administrateur écrit toujours). Le bucket doit être vide au départ ; l'arborescence vit dans le catalogue PostgreSQL et chaque fichier garde la clé d'objet fixée au dépôt (renommer ou déplacer ne touche pas le bucket). Pas d'historique de versions, de recherche plein texte ni de favoris sur S3. Une configuration modifiée dans l'interface est reprise par toutes les instances sous 30 s. Les variables `S3_*` doivent être ajoutées au bloc `environment` du service dans `docker-compose.yml` si on les utilise. + ## API et jetons Chaque utilisateur peut créer des jetons (*Jetons d'API*) pour scripter : diff --git a/cmd/server/main.go b/cmd/server/main.go index 62597cc..eecc3a9 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -13,6 +13,7 @@ import ( "os" "os/signal" "path" + "path/filepath" "strconv" "strings" "syscall" @@ -162,6 +163,16 @@ func main() { slog.Info("catalogue PostgreSQL branché") } spaces.MaxUpload = envInt("MAX_UPLOAD_MB", 0) << 20 // 0 : illimité + // Racine S3 (Garage ou S3 compatible) : variables S3_* et/ou interface + // d'administration ; exige le catalogue PostgreSQL. + spaces.ConfigureS3(ctx, storage.S3Config{ + Endpoint: env("S3_ENDPOINT", ""), + Region: env("S3_REGION", ""), + Bucket: env("S3_BUCKET", ""), + AccessKey: secretEnv("S3_ACCESS_KEY"), + SecretKey: secretEnv("S3_SECRET_KEY"), + Insecure: envBool("S3_INSECURE", false), + }, filepath.Join(dataDir, ".s3cache")) mode := strings.ToLower(env("AUTH_MODE", "local")) handler := (&api.Handler{Store: store, Spaces: spaces, Mode: mode, Version: version}).Init() diff --git a/internal/api/api.go b/internal/api/api.go index 806cf80..63c9755 100644 --- a/internal/api/api.go +++ b/internal/api/api.go @@ -32,6 +32,7 @@ // POST /api/public/{jeton}/unlock mot de passe d'un lien protégé // GET /api/public/{jeton}/file|zip|thumb|preview contenu d'un lien de partage // GET /api/settings / PUT paramètres (écriture : administrateur) +// GET /api/admin/s3 / PUT, POST /api/admin/s3/test racine S3 (administrateur) // GET /api/logo / PUT (image/png) / DELETE logo 64x64 // POST /api/account/password changement du mot de passe (compte local) // PATCH /api/account nom et e-mail (compte local) @@ -173,6 +174,9 @@ func (h *Handler) Register(mux *http.ServeMux) { mux.HandleFunc("GET /api/logo", h.readLogo) mux.HandleFunc("PUT /api/logo", h.writeLogo) mux.HandleFunc("DELETE /api/logo", h.deleteLogo) + mux.HandleFunc("GET /api/admin/s3", h.adminS3) + mux.HandleFunc("PUT /api/admin/s3", h.adminSaveS3) + mux.HandleFunc("POST /api/admin/s3/test", h.adminTestS3) if h.Accounts != nil { mux.HandleFunc("POST /api/account/password", h.changePassword) mux.HandleFunc("PATCH /api/account", h.patchAccount) diff --git a/internal/api/api_test.go b/internal/api/api_test.go index 4a7fc83..294ba6c 100644 --- a/internal/api/api_test.go +++ b/internal/api/api_test.go @@ -502,6 +502,10 @@ func TestSettingsAndAdminPermissions(t *testing.T) { want(t, bob.json("PUT", "/api/settings", map[string]any{"title": "X"}), 403) want(t, bob.do("DELETE", "/api/logo", nil), 403) want(t, bob.get("/api/admin/users"), 403) + want(t, bob.get("/api/admin/s3"), 403) + want(t, bob.json("PUT", "/api/admin/s3", map[string]any{"bucket": "b"}), 403) + want(t, admin.get("/api/admin/s3"), 200) + want(t, admin.json("PUT", "/api/admin/s3", map[string]any{"bucket": "b"}), 400) // sans catalogue want(t, bob.json("POST", "/api/admin/users", map[string]any{"username": "eve", "password": "mot-de-passe-eve"}), 403) want(t, bob.json("PATCH", "/api/admin/users/alice", map[string]any{"role": "user"}), 403) want(t, bob.do("DELETE", "/api/admin/users/alice", nil), 403) diff --git a/internal/api/s3.go b/internal/api/s3.go new file mode 100644 index 0000000..3f04999 --- /dev/null +++ b/internal/api/s3.go @@ -0,0 +1,65 @@ +package api + +import ( + "errors" + "log/slog" + "net/http" + + "github.com/vblogio/upandown/internal/storage" +) + +// Configuration de la racine S3 (administrateurs). La clé secrète n'est +// jamais renvoyée ; un champ fixé par l'environnement ne peut être modifié. + +func (h *Handler) adminS3(w http.ResponseWriter, r *http.Request) { + if !h.admin(w, r) { + return + } + w.Header().Set("Cache-Control", "no-store") + writeJSON(w, http.StatusOK, h.Spaces.S3Status()) +} + +func (h *Handler) adminSaveS3(w http.ResponseWriter, r *http.Request) { + if !h.admin(w, r) { + return + } + var p storage.S3Patch + if !h.decode(w, r, &p) { + return + } + st, err := h.Spaces.SaveS3(p) + if err != nil { + s3Fail(w, err) + return + } + slog.Info("racine S3 : configuration modifiée", "by", userID(r)) + writeJSON(w, http.StatusOK, st) +} + +func (h *Handler) adminTestS3(w http.ResponseWriter, r *http.Request) { + if !h.admin(w, r) { + return + } + var p storage.S3Patch + if !h.decode(w, r, &p) { + return + } + if err := h.Spaces.TestS3(p); err != nil { + s3Fail(w, err) + return + } + writeJSON(w, http.StatusOK, map[string]bool{"ok": true}) +} + +// s3Fail : les erreurs de connexion au bucket sont renvoyées telles quelles +// (utiles à l'administrateur). +func s3Fail(w http.ResponseWriter, err error) { + switch { + case errors.Is(err, storage.ErrS3NotEmpty): + writeErr(w, http.StatusConflict, err.Error()) + case errors.Is(err, storage.ErrInvalidPath): + writeErr(w, http.StatusBadRequest, err.Error()) + default: + writeErr(w, http.StatusBadGateway, err.Error()) + } +}