Compare commits

..
Author SHA1 Message Date
claude BotandClaude Opus 5.5 6838c147b7 Lot 3 (5/5) : interface (entrée S3, réglages admin) et tests S3
Entrée « S3 » dans la barre latérale et à la racine (icône nuage), pas
d'historique ni de favoris sur S3 ; section « Racine S3 » dans
Administration (champs verrouillés par l'environnement, clé secrète jamais
affichée, test de connexion). Tests : Store S3 sur stockage objet en
mémoire, intégration aux espaces.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 18:06:58 +01:00
claude BotandClaude Opus 5.5 e79a813272 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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 18:05:17 +01:00
claude BotandClaude Opus 5.5 53972f9762 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
2026-11-20 18:04:37 +01:00
claude BotandClaude Opus 5.5 1da55c7ad7 Lot 3 (2/4) : racine S3, opérations sur le catalogue s3_nodes
Complète le commit précédent (s3.go manquant).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 18:02:26 +01:00
claude BotandClaude Opus 5.5 7c1f49cb5c Lot 3 (1/4) : racine S3, backend du Store (catalogue + objets minio-go)
Arborescence dans s3_nodes, contenus sous des clés o/<id> figées au dépôt,
corbeille dans s3_trash, configuration admin dans s3_config. Délégations
S3 dans List/Stat/Open/Put/Mkdir/Move/Copy/Delete/Walk/corbeille,
miniatures, partages, tags, recherche (noms et tags). Pas d'historique.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 18:01:01 +01:00
claude BotandClaude Opus 5.5 235916157a Lot 2 (tests) : comptes et réglages partagés, clé hex:
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:38:45 +01:00
claude BotandClaude Opus 5.5 479aa2477c Lot 2 (fin) : jetons, réglages et secrets communs en mode cluster
- tokens.Store : UseCatalog, reprise unique de .tokens.json, recherche par
  empreinte indexée, date d'utilisation mise à jour sans verrou global.
- Réglages d'administration et logo en base (app_settings, app_blobs),
  reprise unique de .settings.json et .logo.png.
- Avec DATABASE_URL, SHARE_SECRET et SESSION_SECRET sont obligatoires
  (SESSION_SECRET non exigé avec AUTH_MODE=none) ; la forme hex:<clé>
  reprend un ancien .share-secret / .session-secret sans casser les liens
  ni les sessions. Variables *_FILE acceptées.
- docker-compose : les deux secrets sont exigés au lancement.
- Tests : comptes, jetons et réglages partagés entre deux instances.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:38:07 +01:00
claude BotandClaude Opus 5.5 3bbbac5998 Lot 2 (suite) : auth.Accounts sur fichier ou catalogue
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:36:09 +01:00
claude BotandClaude Opus 5.5 05edcd6b8e Lot 2 : comptes partagés dans le catalogue PostgreSQL
- internal/catalog/docs.go : collections de documents JSON (id, data jsonb)
  modifiées sous verrou consultatif par table, écriture du seul diff,
  reprise unique d'anciens fichiers (ImportFileOnce), petits blobs.
- Migration 002 : tables accounts, tokens, app_settings, app_blobs.
- auth.Accounts : UseCatalog ; toutes les modifications passent par une
  fonction atomique (fichier ou base), la règle du dernier administrateur
  et le premier administrateur restent vrais entre instances.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:34:29 +01:00
claude BotandClaude Opus 5.5 40c0c4d758 Lot 1 (suite) : paquet catalog et liaison Store <-> PostgreSQL
Fichiers nouveaux du commit précédent : internal/catalog/catalog.go,
internal/storage/catalog.go et ses tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:21:46 +01:00
claude BotandClaude Opus 5.5 f8801f00f9 Lot 1 : catalogue PostgreSQL partagé pour les métadonnées et les partages
- Nouveau paquet internal/catalog : pool pgx, migrations SQL embarquées
  (sérialisées entre instances par verrou consultatif), transactions
  rejouées après conflit, interblocage ou bascule du primaire (pool vidé
  sur erreur de lecture seule ou de connexion). DSN multi-hôtes accepté
  (target_session_attrs=read-write) pour une future HA.
- Store.UseCatalog : tags, icônes, auteurs (item_meta) et liens de partage
  (shares) lus et écrits en base ; chaque modification se fait sous verrou
  consultatif par racine (« main », « home/<id> »), donc sans perte
  d'écriture entre instances. Sans DATABASE_URL, rien ne change (JSON).
- Reprise unique de .meta.json et .shares.json au premier branchement
  (table imports), fichiers renommés en *.imported.
- Serveur : DATABASE_URL / DATABASE_URL_FILE, DATABASE_WAIT (60 s).
- Compose : service postgres:16 sur un réseau interne dédié ; Traefik
  inchangé. Dockerfile : go.sum et téléchargement des modules.
- Tests : UPANDOWN_TEST_DATABASE_URL fait passer toute la suite storage par
  la base ; tests de partage entre deux instances et de reprise JSON.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:20:16 +01:00
claude BotandClaude Opus 5.5 68885f7e6b Lot 0 : interface Root et lecture en flux, préalable à la racine S3
- storage.File (Read/Seek/Close) remplace *os.File dans Open, OpenVersion
  et l'API (téléchargement, aperçu, liens publics) : un objet S3 lu par
  plages pourra être servi tel quel par http.ServeContent.
- Interface storage.Root (List, Stat, Open, Put, Mkdir, Move, Copy,
  Delete, Remove, Walk), implémentée par Store ; ajout de Store.Walk et
  Store.Remove (suppression définitive).
- Archives ZIP construites via Root (Walk + Open) au lieu de chemins disque.
- transfer : copie en flux entre deux racines quelconques, base des
  déplacements disque <-> S3.
- Aucun changement de comportement ; tests ajoutés (root_test.go).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:09:52 +01:00
52 changed files with 5381 additions and 516 deletions

No files matched your search

+1
View File
@@ -1,6 +1,7 @@
**/node_modules
web/dist
data
postgres
.devdata
bin
*.md
+14
View File
@@ -16,6 +16,8 @@ OIDC_NAME=SSO
OIDC_ALLOWED_GROUPS=
OIDC_ADMIN_GROUPS=
OIDC_ADMIN_EMAILS=
# Clés communes à toutes les instances (obligatoires avec PostgreSQL),
# 16 caractères minimum : openssl rand -hex 32
SESSION_SECRET=
PUBLIC_URL=
MAX_UPLOAD_MB=0
@@ -23,3 +25,15 @@ USER_QUOTA_MB=0
COMMON_READONLY=false
TRASH_DAYS=0
HISTORY_KEEP=10
SHARE_SECRET=
# Catalogue PostgreSQL (service postgres du compose). Mot de passe sans caractère
# 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=
+1
View File
@@ -1,4 +1,5 @@
/data/
/postgres/
/.devdata/
/bin/
web/dist/*
+3 -2
View File
@@ -12,12 +12,13 @@ RUN npm run build
FROM golang:1.24-alpine AS backend
ARG VERSION=dev
WORKDIR /src
COPY go.mod ./
COPY go.mod go.sum ./
RUN --mount=type=cache,target=/go/pkg/mod go mod download
COPY cmd ./cmd
COPY internal ./internal
COPY web/embed.go ./web/
COPY --from=frontend /src/web/dist ./web/dist
RUN --mount=type=cache,target=/root/.cache/go-build \
RUN --mount=type=cache,target=/root/.cache/go-build --mount=type=cache,target=/go/pkg/mod \
CGO_ENABLED=0 go test ./... && \
CGO_ENABLED=0 go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" -o /out/server ./cmd/server && \
mkdir -p /out/data
+6 -2
View File
@@ -44,12 +44,16 @@ Pour imposer l'administrateur : `ADMIN_USER` et `ADMIN_PASSWORD` dans `.env`. Le
| `COMMON_READONLY` | `false` | Commun en lecture seule pour les non-administrateurs |
| `TRASH_DAYS` | `0` | Purge de la poubelle (0 : jamais) |
| `HISTORY_KEEP` / `HISTORY_INTERVAL` / `HISTORY_MAX_AGE` | `10` / `0` / `0` | Versions gardées par fichier, écart minimal, âge maximal |
| `SESSION_TTL` / `SESSION_SECRET` | `24h` / aléatoire | Session ; clé de signature (sinon `DATA_DIR/.session-secret`) |
| `SHARE_SECRET` | aléatoire | Clé de signature des liens de partage |
| `SESSION_TTL` / `SESSION_SECRET` | `24h` / aléatoire | Session ; clé de signature (sinon `DATA_DIR/.session-secret`). Obligatoire avec `DATABASE_URL` ; `hex:<contenu de .session-secret>` garde les sessions ouvertes |
| `SHARE_SECRET` | aléatoire | Clé de signature des liens de partage. Obligatoire avec `DATABASE_URL` ; `hex:<contenu de .share-secret>` 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 :
+69 -5
View File
@@ -13,6 +13,7 @@ import (
"os"
"os/signal"
"path"
"path/filepath"
"strconv"
"strings"
"syscall"
@@ -20,6 +21,7 @@ import (
"github.com/vblogio/upandown/internal/api"
"github.com/vblogio/upandown/internal/auth"
"github.com/vblogio/upandown/internal/catalog"
"github.com/vblogio/upandown/internal/storage"
"github.com/vblogio/upandown/internal/tokens"
"github.com/vblogio/upandown/web"
@@ -65,6 +67,19 @@ func fatal(msg string, args ...any) {
os.Exit(1)
}
// envDuration lit une durée (« 30s », « 2m »).
func envDuration(key string, def time.Duration) time.Duration {
v := os.Getenv(key)
if v == "" {
return def
}
d, err := time.ParseDuration(v)
if err != nil || d < 0 {
fatal(key + " invalide (durée attendue, ex. 60s)")
}
return d
}
// secretEnv lit un secret dans NAME, ou dans le fichier NAME_FILE (secrets Docker).
func secretEnv(name string) string {
if v := os.Getenv(name); v != "" {
@@ -107,18 +122,57 @@ func main() {
fatal("REGISTRATION invalide (closed, approval ou open)")
}
// Clé de signature des liens de partage : SHARE_SECRET, sinon DATA_DIR/.share-secret.
if secret := os.Getenv("SHARE_SECRET"); secret != "" {
if len(secret) < 16 {
fatal("SHARE_SECRET trop court (16 caractères minimum)")
// Avec le catalogue PostgreSQL, toutes les instances doivent partager la
// même clé (et celle des sessions) : SHARE_SECRET et SESSION_SECRET sont
// alors obligatoires.
dsn := secretEnv("DATABASE_URL")
if dsn != "" {
required := []string{"SHARE_SECRET", "SESSION_SECRET"}
if strings.EqualFold(os.Getenv("AUTH_MODE"), "none") {
required = required[:1] // pas de sessions
}
for _, name := range required {
if secretEnv(name) == "" {
fatal(name + " obligatoire avec DATABASE_URL (clé commune à toutes les instances)")
}
}
}
if secret := secretEnv("SHARE_SECRET"); secret != "" {
if err := store.SetShareSecret(secret); err != nil {
fatal("SHARE_SECRET", "err", err)
}
store.SetShareSecret(secret)
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
spaces := storage.NewSpaces(store)
// Catalogue PostgreSQL partagé (mode cluster) : DATABASE_URL ou DATABASE_URL_FILE.
// Sans lui, les métadonnées restent dans les fichiers JSON de DATA_DIR.
var db *catalog.DB
if dsn != "" {
db, err = catalog.Open(ctx, dsn, envDuration("DATABASE_WAIT", 60*time.Second))
if err != nil {
fatal("catalogue PostgreSQL", "err", err)
}
defer db.Close()
if err := store.UseCatalog(db, "main"); err != nil {
fatal("catalogue PostgreSQL", "err", err)
}
spaces.Catalog = db
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()
@@ -128,6 +182,11 @@ func main() {
if err != nil {
fatal("jetons d'accès", "err", err)
}
if db != nil {
if err := tokenStore.UseCatalog(db); err != nil {
fatal("jetons d'accès", "err", err)
}
}
ts := &tokens.Server{Store: tokenStore, UserID: api.UserID}
switch mode {
@@ -140,6 +199,11 @@ func main() {
if err != nil {
fatal("comptes", "err", err)
}
if db != nil {
if err := accounts.UseCatalog(db); err != nil {
fatal("comptes", "err", err)
}
}
handler.Accounts = accounts
a, err := authentication(ctx, mode, dataDir, accounts, store, handler)
if err != nil {
@@ -191,7 +255,7 @@ func main() {
// authentication prépare l'authentification locale (comptes, inscription) et/ou OIDC.
func authentication(ctx context.Context, mode, dataDir string, accounts *auth.Accounts, store *storage.Store, h *api.Handler) (*auth.Auth, error) {
secret, err := auth.LoadSecret(os.Getenv("SESSION_SECRET"), dataDir)
secret, err := auth.LoadSecret(secretEnv("SESSION_SECRET"), dataDir)
if err != nil {
return nil, err
}
+28 -2
View File
@@ -29,7 +29,7 @@ services:
OIDC_ADMIN_EMAILS: ${OIDC_ADMIN_EMAILS:-}
OIDC_LOGOUT: ${OIDC_LOGOUT:-true}
SESSION_TTL: ${SESSION_TTL:-24h}
SESSION_SECRET: ${SESSION_SECRET:-}
SESSION_SECRET: ${SESSION_SECRET:?SESSION_SECRET requis (openssl rand -hex 32)}
PUBLIC_URL: ${PUBLIC_URL:-}
# Dépôts : taille maximale d'un fichier (Mo, 0 : illimité) ; quota par utilisateur (Mo, 0 : illimité).
MAX_UPLOAD_MB: ${MAX_UPLOAD_MB:-0}
@@ -40,7 +40,14 @@ services:
HISTORY_KEEP: ${HISTORY_KEEP:-10}
HISTORY_INTERVAL: ${HISTORY_INTERVAL:-0}
HISTORY_MAX_AGE: ${HISTORY_MAX_AGE:-0}
SHARE_SECRET: ${SHARE_SECRET:-}
SHARE_SECRET: ${SHARE_SECRET:?SHARE_SECRET requis (openssl rand -hex 32)}
# Catalogue PostgreSQL partagé (indispensable pour plusieurs instances).
# Plusieurs hôtes possibles pour une base répliquée :
# postgres://upandown:<mdp>@pg1,pg2/upandown?target_session_attrs=read-write
DATABASE_URL: ${DATABASE_URL:-postgres://upandown:${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis}@postgres:5432/upandown?sslmode=disable}
depends_on:
postgres:
condition: service_healthy
volumes:
# Bind mount : chown -R 65532:65532 ./data
- ./data:/data
@@ -50,6 +57,25 @@ services:
- no-new-privileges:true
networks:
- traefik-net
- upandown-db
postgres:
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_DB: upandown
POSTGRES_USER: upandown
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis}
volumes:
- ./postgres:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U upandown -d upandown"]
interval: 10s
timeout: 5s
retries: 5
networks:
- upandown-db
networks:
upandown-db:
internal: true
traefik-net:
external: true
+5 -2
View File
@@ -1,5 +1,5 @@
import { useCallback, useEffect, useRef, useState } from "react";
import { api, FAVORIS, PERSO, POUBELLE, type Entry, type Me } from "./api";
import { api, FAVORIS, PERSO, POUBELLE, S3, type Entry, type Me } from "./api";
import { ActionMenu } from "./ActionMenu";
import { Explorer } from "./Explorer";
import { FolderTree } from "./FolderTree";
@@ -9,6 +9,7 @@ import { Splitter } from "./Splitter";
import { UploadPanel } from "./UploadPanel";
import { fmtSize, initials } from "./format";
import {
CloudIcon,
CloudUpIcon,
FolderIcon,
KeyIcon,
@@ -187,7 +188,8 @@ function Shell({ me, reloadMe }: { me: Me; reloadMe: () => Promise<unknown> }) {
const trash = places.find((p) => p.special === "poubelle");
const user = me.user!;
const root = dir.split("/")[0];
const current = root === PERSO || root === FAVORIS || root === POUBELLE ? root : "";
const hasS3 = places.some((p) => p.special === "s3");
const current = root === PERSO || root === FAVORIS || root === POUBELLE || root === S3 ? root : "";
const navItem = (id: string, text: string, icon: React.ReactNode, active: boolean, badge?: number) => (
<button className={`nav-item ${active ? "on" : ""}`} onClick={() => go(id)} aria-current={active ? "page" : undefined}>
@@ -241,6 +243,7 @@ function Shell({ me, reloadMe }: { me: Me; reloadMe: () => Promise<unknown> }) {
{navItem("", "Fichiers", <FolderIcon />, dir === "")}
<FolderTree current={current === "" ? dir : ""} reloadKey={refreshKey + treeKey} onOpen={go} />
{navItem(PERSO, "Personnel", <UserIcon />, current === PERSO)}
{hasS3 && navItem(S3, "S3", <CloudIcon />, current === S3)}
{navItem(FAVORIS, "Favoris", <StarFilledIcon />, current === FAVORIS)}
{navItem(POUBELLE, "Poubelle", trash?.count ? <TrashFullIcon /> : <TrashIcon />, current === POUBELLE, trash?.count)}
</nav>
+9 -7
View File
@@ -1,5 +1,5 @@
import { useEffect, useState } from "react";
import { api, dirname, displayPath, type Entry } from "./api";
import { api, dirname, displayPath, inS3, type Entry } from "./api";
import { CloseIcon, DownloadIcon, EyeIcon, FolderIcon, HistoryIcon, ShareIcon, StarFilledIcon, StarIcon } from "./icons";
import { FolderGlyph } from "./folderIcons";
import { FileGlyph, Thumb, thumbSource } from "./FileGlyph";
@@ -113,16 +113,18 @@ export function DetailsPanel({ entry: e, onClose, onOpen, onShare, onHistory, on
<ShareIcon />
<span>Partager</span>
</button>
{!e.isDir && (
{!e.isDir && !inS3(e.path) && (
<button onClick={() => onHistory(e)}>
<HistoryIcon />
<span>Historique</span>
</button>
)}
<button onClick={() => onFavorite(e)} aria-pressed={!!e.favorite}>
{e.favorite ? <StarFilledIcon /> : <StarIcon />}
<span>{e.favorite ? "Favori" : "Ajouter aux favoris"}</span>
</button>
{!inS3(e.path) && (
<button onClick={() => onFavorite(e)} aria-pressed={!!e.favorite}>
{e.favorite ? <StarFilledIcon /> : <StarIcon />}
<span>{e.favorite ? "Favori" : "Ajouter aux favoris"}</span>
</button>
)}
</div>
<dl>
@@ -175,7 +177,7 @@ export function DetailsPanel({ entry: e, onClose, onOpen, onShare, onHistory, on
</dl>
{!e.isDir && (
<div className="details-foot muted">
<FileGlyph name={e.name} size={14} /> {e.path.startsWith(".perso") ? "Espace personnel" : "Arborescence commune"}
<FileGlyph name={e.name} size={14} /> {e.path.startsWith(".perso") ? "Espace personnel" : inS3(e.path) ? "Racine S3" : "Arborescence commune"}
</div>
)}
</aside>
+5 -3
View File
@@ -9,6 +9,7 @@ import {
displayPath,
inFavoris,
inPoubelle,
inS3,
join,
label,
POUBELLE,
@@ -18,6 +19,7 @@ import {
type TagCount,
} from "./api";
import {
CloudIcon,
CloseIcon,
ClockIcon,
CopyIcon,
@@ -565,7 +567,7 @@ export function Explorer({ me, refreshKey, goto, onDirChange, onMutated, toolbar
const icon = (e: Entry) =>
e.special ? (
<span className={`icon special ${e.special} ${e.count ? "full" : ""}`} aria-hidden>
{e.special === "favoris" ? <StarFilledIcon size={big} /> : e.special === "poubelle" ? e.count ? <TrashFullIcon size={big} /> : <TrashIcon size={big} /> : <UserIcon size={big} />}
{e.special === "favoris" ? <StarFilledIcon size={big} /> : e.special === "poubelle" ? e.count ? <TrashFullIcon size={big} /> : <TrashIcon size={big} /> : e.special === "s3" ? <CloudIcon size={big} /> : <UserIcon size={big} />}
</span>
) : e.broken ? (
<span className="icon folder" aria-hidden>
@@ -679,13 +681,13 @@ export function Explorer({ me, refreshKey, goto, onDirChange, onMutated, toolbar
</button>
</>
)}
{!e.isDir && !e.broken && (
{!e.isDir && !e.broken && !inS3(e.path) && (
<button role="menuitem" onClick={() => setHistory(e)}>
<HistoryIcon />
Historique…
</button>
)}
{!e.broken && !favView && (
{!e.broken && !favView && !inS3(e.path) && (
<button role="menuitem" onClick={() => toggleFavorite([e])}>
{e.favorite ? <StarFilledIcon /> : <StarIcon />}
{e.favorite ? "Retirer des favoris" : "Favori"}
+118 -2
View File
@@ -1,6 +1,6 @@
import { useCallback, useEffect, useState } from "react";
import type { ReactNode } from "react";
import { api, displayPath, type Account, type ApiToken, type Me, type Role, type Settings, type Share, type Status } from "./api";
import { api, displayPath, type Account, type ApiToken, type Me, type Role, type S3Patch, type S3Status, type Settings, type Share, type Status } from "./api";
import { csvPageSizes, usePreviewPrefs } from "./prefs";
import { CheckIcon, CloseIcon, CopyLinkIcon, EyeIcon, KeyIcon, LockIcon, ShareIcon, ShieldIcon, TrashIcon, UserIcon, UsersIcon } from "./icons";
import { ConfirmDialog } from "./Dialogs";
@@ -658,7 +658,7 @@ function GeneralTab({ onError, onChanged }: { onError: (m: string | null) => voi
</form>
<label className="check-row">
<input type="checkbox" checked={st.commonReadonly} onChange={(e) => apply({ commonReadonly: e.target.checked })} />
<span>Arborescence commune en lecture seule pour les utilisateurs (seuls les administrateurs y écrivent)</span>
<span>Arborescence commune (et racine S3) en lecture seule pour les utilisateurs (seuls les administrateurs y écrivent)</span>
</label>
<form
className="inline-form"
@@ -675,10 +675,126 @@ function GeneralTab({ onError, onChanged }: { onError: (m: string | null) => voi
Enregistrer
</button>
</form>
<S3Section onError={onError} onChanged={onChanged} />
</div>
);
}
// --- Racine S3 (administrateur) -----------------------------------------------------------
const s3Fields: { id: keyof S3Patch; label: string; placeholder?: string }[] = [
{ id: "endpoint", label: "Endpoint", placeholder: "https://garage:3900" },
{ id: "region", label: "Région", placeholder: "garage" },
{ id: "bucket", label: "Bucket" },
{ id: "accessKey", label: "Clé d'accès" },
{ id: "secretKey", label: "Clé secrète" },
];
/** Connexion au bucket : un champ fixé par une variable S3_* est verrouillé ;
* la clé secrète n'est jamais affichée (vide : inchangée). */
function S3Section({ onError, onChanged }: { onError: (m: string | null) => void; onChanged: () => void }) {
const [st, setSt] = useState<S3Status | null>(null);
const [form, setForm] = useState<Record<string, string>>({});
const [insecure, setInsecure] = useState(false);
const [busy, setBusy] = useState(false);
const [note, setNote] = useState<string | null>(null);
const reset = (s: S3Status) => {
setSt(s);
setForm({ endpoint: s.endpoint, region: s.region, bucket: s.bucket, accessKey: s.accessKey, secretKey: "" });
setInsecure(s.insecure);
};
useEffect(() => {
api.s3Status().then(reset).catch((e) => onError(msg(e)));
}, [onError]);
if (!st) return null;
const locked = (k: string) => st.locked.includes(k);
const patch = (): S3Patch => {
const p: S3Patch = {};
for (const f of s3Fields) {
if (locked(f.id) || f.id === "secretKey") continue;
const v = form[f.id] ?? "";
if (v !== (st[f.id as keyof S3Status] ?? "")) (p as Record<string, string>)[f.id] = v;
}
if (!locked("secretKey") && form.secretKey) p.secretKey = form.secretKey;
if (!locked("insecure") && insecure !== st.insecure) p.insecure = insecure;
return p;
};
const run = async (save: boolean) => {
onError(null);
setNote(null);
setBusy(true);
try {
if (save) {
reset(await api.saveS3(patch()));
setNote("Configuration S3 enregistrée.");
onChanged();
} else {
await api.testS3(patch());
setNote("Connexion au bucket réussie.");
}
} catch (e) {
onError(msg(e));
} finally {
setBusy(false);
}
};
return (
<>
<h4>Racine S3</h4>
{!st.available ? (
<p className="muted small-text">Disponible avec le catalogue PostgreSQL (DATABASE_URL).</p>
) : (
<form
onSubmit={(e) => {
e.preventDefault();
run(true);
}}
>
<p className="muted small-text">
{st.active ? "Branchée." : "Non branchée."} Bucket vide attendu au départ ; l'endpoint et le bucket ne changent plus une
fois la racine utilisée. Les champs grisés sont fixés par les variables S3_*.
</p>
{st.error && <p className="error-text">{st.error}</p>}
{s3Fields.map((f) => (
<label className="field" key={f.id}>
<span>{f.label}</span>
<input
type={f.id === "secretKey" ? "password" : "text"}
autoComplete="off"
value={form[f.id] ?? ""}
disabled={locked(f.id) || (!st.empty && (f.id === "endpoint" || f.id === "bucket"))}
placeholder={f.id === "secretKey" ? (st.secretSet ? "inchangée" : "") : f.placeholder}
onChange={(e) => setForm({ ...form, [f.id]: e.target.value })}
/>
</label>
))}
<label className="check-row">
<input type="checkbox" checked={insecure} disabled={locked("insecure")} onChange={(e) => setInsecure(e.target.checked)} />
<span>HTTP sans TLS (endpoint sans schéma)</span>
</label>
{note && (
<div className="notice">
<CheckIcon size={14} /> {note}
</div>
)}
<div className="inline-form">
<button type="button" disabled={busy} onClick={() => run(false)}>
Tester la connexion
</button>
<button type="submit" className="primary" disabled={busy}>
Enregistrer
</button>
</div>
</form>
)}
</>
);
}
// --- Utilisateurs (administrateur) ---------------------------------------------------------
const statusLabel: Record<Status, string> = { active: "Actif", pending: "En attente", disabled: "Désactivé" };
+30 -2
View File
@@ -11,7 +11,7 @@ export interface Entry {
/** Dossier : icône choisie (voir folderIcons.tsx). */
icon?: string;
/** Entrée virtuelle de la racine : "favoris", "perso" (espace personnel) ou "poubelle". */
special?: "favoris" | "perso" | "poubelle";
special?: "favoris" | "perso" | "poubelle" | "s3";
/** Entrée « poubelle » de la racine : nombre d'éléments qu'elle contient. */
count?: number;
/** Élément de la poubelle : chemin d'origine (modTime = date de suppression). */
@@ -91,6 +91,25 @@ export interface PreviewSettings {
shares: boolean;
}
/** Racine S3 (administrateur) : la clé secrète n'est jamais renvoyée ;
* locked liste les champs fixés par les variables d'environnement. */
export interface S3Status {
available: boolean;
active: boolean;
error?: string;
endpoint: string;
region: string;
bucket: string;
accessKey: string;
secretSet: boolean;
insecure: boolean;
locked: string[];
empty: boolean;
}
/** Modification de la racine S3 ; secretKey vide : clé conservée. */
export type S3Patch = Partial<Pick<S3Status, "endpoint" | "region" | "bucket" | "accessKey" | "insecure">> & { secretKey?: string };
/** Version enregistrée d'un fichier (time : date de ce contenu). */
export interface Version {
id: string;
@@ -426,6 +445,12 @@ export const api = {
removeLogo: async (): Promise<Settings> => (await request("/api/logo", { method: "DELETE" })).json(),
logoUrl: (v: string) => `/api/logo?v=${q(v)}`,
s3Status: async (): Promise<S3Status> => (await request("/api/admin/s3")).json(),
saveS3: async (p: S3Patch): Promise<S3Status> => (await request("/api/admin/s3", json(p, "PUT"))).json(),
testS3: async (p: S3Patch): Promise<void> => {
await request("/api/admin/s3/test", json(p, "POST"));
},
};
export type Conflict = "fail" | "overwrite" | "rename";
@@ -471,7 +496,9 @@ export const join = (dir: string, name: string) => (dir ? `${dir}/${name}` : nam
export const PERSO = ".perso";
export const FAVORIS = ".favoris";
export const POUBELLE = ".poubelle";
const SPECIAL_LABELS: Record<string, string> = { [PERSO]: "Personnel", [FAVORIS]: "Favoris", [POUBELLE]: "Poubelle" };
/** Racine commune sur stockage objet (si configurée) : ni favoris ni historique. */
export const S3 = ".s3";
const SPECIAL_LABELS: Record<string, string> = { [PERSO]: "Personnel", [FAVORIS]: "Favoris", [POUBELLE]: "Poubelle", [S3]: "S3" };
/** Libellé d'un composant de chemin (".perso" → "Personnel"). */
export const label = (part: string) => SPECIAL_LABELS[part] ?? part;
/** Chemin affiché : "Personnel/projets" pour ".perso/projets". */
@@ -479,6 +506,7 @@ export const displayPath = (p: string) => p.split("/").map(label).join("/");
export const inFavoris = (p: string) => p === FAVORIS || p.startsWith(FAVORIS + "/");
export const inPoubelle = (p: string) => p === POUBELLE || p.startsWith(POUBELLE + "/");
export const inPerso = (p: string) => p === PERSO || p.startsWith(PERSO + "/");
export const inS3 = (p: string) => p === S3 || p.startsWith(S3 + "/");
/** Extension (sans le point, minuscules) ; vide si aucune. */
export const extOf = (name: string) => {
+24
View File
@@ -1,3 +1,27 @@
module github.com/vblogio/upandown
go 1.24.7
require (
github.com/jackc/pgx/v5 v5.7.2
github.com/minio/minio-go/v7 v7.0.80
)
require (
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/go-ini/ini v1.67.0 // indirect
github.com/goccy/go-json v0.10.3 // indirect
github.com/google/uuid v1.6.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/klauspost/compress v1.17.11 // indirect
github.com/klauspost/cpuid/v2 v2.2.8 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/rs/xid v1.6.0 // indirect
golang.org/x/crypto v0.31.0 // indirect
golang.org/x/net v0.30.0 // indirect
golang.org/x/sync v0.10.0 // indirect
golang.org/x/sys v0.28.0 // indirect
golang.org/x/text v0.21.0 // indirect
)
+52
View File
@@ -0,0 +1,52 @@
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM=
github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
github.com/minio/minio-go/v7 v7.0.80 h1:2mdUHXEykRdY/BigLt3Iuu1otL0JTogT0Nmltg0wujk=
github.com/minio/minio-go/v7 v7.0.80/go.mod h1:84gmIilaX4zcvAWWzJ5Z1WI5axN+hAbM5w25xf8xvC0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+4
View File
@@ -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)
+4
View File
@@ -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)
+1 -2
View File
@@ -5,7 +5,6 @@ import (
"io"
"io/fs"
"net/http"
"os"
"path"
"strconv"
"strings"
@@ -199,7 +198,7 @@ func (c previewConfig) maxText() int64 {
return int64(c.MaxTextMB) << 20
}
func (h *Handler) servePreview(w http.ResponseWriter, r *http.Request, f *os.File, fi fs.FileInfo, cfg previewConfig) {
func (h *Handler) servePreview(w http.ResponseWriter, r *http.Request, f storage.File, fi fs.FileInfo, cfg previewConfig) {
name := fi.Name()
kind := cfg.kind(name)
if fi.IsDir() || cfg.excluded(name) || (kind == "" && !cfg.Sniff) {
+65
View File
@@ -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())
}
}
+1 -2
View File
@@ -7,7 +7,6 @@ import (
"mime"
"net/http"
"net/url"
"os"
"path"
"strings"
@@ -66,7 +65,7 @@ func contentDisposition(inline bool, name string) string {
// serveFile envoie un fichier avec prise en charge de Range, If-Modified-Since
// et ETag. Affichage en ligne seulement si inline est demandé et que le type
// est sûr ; sinon téléchargement.
func serveFile(w http.ResponseWriter, r *http.Request, f *os.File, fi fs.FileInfo, name string, inline bool) {
func serveFile(w http.ResponseWriter, r *http.Request, f storage.File, fi fs.FileInfo, name string, inline bool) {
ct := contentType(name)
bt := baseType(ct)
showInline := inline && (inlineTypes[bt] || strings.HasPrefix(ct, "text/plain"))
+308 -170
View File
@@ -1,6 +1,7 @@
package auth
import (
"context"
"crypto/pbkdf2"
"crypto/rand"
"crypto/sha256"
@@ -8,6 +9,7 @@ import (
"encoding/json"
"errors"
"fmt"
"log/slog"
"os"
"path/filepath"
"regexp"
@@ -17,6 +19,9 @@ import (
"sync"
"time"
"unicode/utf8"
"github.com/jackc/pgx/v5"
"github.com/vblogio/upandown/internal/catalog"
)
// Comptes utilisateurs : comptes locaux (identifiant + mot de passe) et comptes
@@ -99,14 +104,22 @@ func (a Account) User() User {
return User{ID: a.ID, Sub: a.Sub, Name: a.Name, Email: a.Email, Provider: a.Provider, Role: a.Role}
}
// Accounts conserve les comptes dans dir/.accounts.json.
// Accounts conserve les comptes dans dir/.accounts.json, ou dans la table
// accounts du catalogue PostgreSQL (UseCatalog) quand plusieurs instances
// partagent les mêmes comptes.
type Accounts struct {
mu sync.Mutex
file string
byID map[string]*Account
dummy string // empreinte factice : égalise le temps de réponse d'un identifiant inconnu
byID map[string]*Account // mode fichier
db *catalog.DB // mode catalogue
dummy string // empreinte factice : égalise le temps de réponse d'un identifiant inconnu
}
const accountsTable = "accounts"
// accountsTimeout borne une opération sur le catalogue.
const accountsTimeout = 30 * time.Second
// OpenAccounts charge (ou crée) le fichier des comptes de dir.
func OpenAccounts(dir string) (*Accounts, error) {
a := &Accounts{file: filepath.Join(dir, accountsFile), byID: map[string]*Account{}}
@@ -116,13 +129,11 @@ func OpenAccounts(dir string) (*Accounts, error) {
case err != nil:
return nil, err
default:
var d struct {
Accounts []*Account `json:"accounts"`
}
if err := json.Unmarshal(b, &d); err != nil {
list, err := decodeAccounts(b)
if err != nil {
return nil, errors.New(a.file + " invalide : " + err.Error())
}
for _, acc := range d.Accounts {
for _, acc := range list {
a.byID[acc.ID] = acc
}
}
@@ -130,10 +141,88 @@ func OpenAccounts(dir string) (*Accounts, error) {
return a, nil
}
func decodeAccounts(b []byte) ([]*Account, error) {
var d struct {
Accounts []*Account `json:"accounts"`
}
err := json.Unmarshal(b, &d)
return d.Accounts, err
}
// UseCatalog range désormais les comptes dans le catalogue. Au premier
// branchement, le fichier .accounts.json est repris en base (une seule fois,
// sans écraser un compte déjà présent) puis renommé en .accounts.json.imported.
// À appeler au démarrage, avant de servir des requêtes.
func (a *Accounts) UseCatalog(db *catalog.DB) error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
err := db.ImportFileOnce(ctx, "global", "accounts", a.file, func(ctx context.Context, tx pgx.Tx, b []byte) error {
list, err := decodeAccounts(b)
if err != nil {
return err
}
m := make(map[string]*Account, len(list))
for _, acc := range list {
m[acc.ID] = acc
}
return catalog.InsertDocs(ctx, tx, accountsTable, m)
})
if err != nil {
return fmt.Errorf("reprise des comptes : %w", err)
}
a.mu.Lock()
a.db, a.byID = db, nil
a.mu.Unlock()
return nil
}
// snapshot renvoie une copie de tous les comptes.
func (a *Accounts) snapshot() (map[string]*Account, error) {
if a.db != nil {
ctx, cancel := context.WithTimeout(context.Background(), accountsTimeout)
defer cancel()
return catalog.AllDocs[Account](ctx, a.db, accountsTable)
}
a.mu.Lock()
defer a.mu.Unlock()
return cloneAccounts(a.byID), nil
}
// update applique fn à tous les comptes, de façon atomique : une erreur de fn
// n'enregistre rien. En mode catalogue, fn s'exécute sous un verrou commun à
// toutes les instances et peut être rejouée.
func (a *Accounts) update(fn func(map[string]*Account) error) error {
if a.db != nil {
ctx, cancel := context.WithTimeout(context.Background(), accountsTimeout)
defer cancel()
return catalog.UpdateDocs(ctx, a.db, accountsTable, fn)
}
a.mu.Lock()
defer a.mu.Unlock()
next := cloneAccounts(a.byID)
if err := fn(next); err != nil {
return err
}
if err := a.save(next); err != nil {
return err
}
a.byID = next
return nil
}
func cloneAccounts(m map[string]*Account) map[string]*Account {
out := make(map[string]*Account, len(m))
for id, acc := range m {
c := *acc
out[id] = &c
}
return out
}
// save écrit le fichier ; appelé sous mu.
func (a *Accounts) save() error {
list := make([]*Account, 0, len(a.byID))
for _, acc := range a.byID {
func (a *Accounts) save(m map[string]*Account) error {
list := make([]*Account, 0, len(m))
for _, acc := range m {
list = append(list, acc)
}
sort.Slice(list, func(i, j int) bool { return list[i].Created.Before(list[j].Created) })
@@ -208,6 +297,18 @@ func ValidatePassword(pw string) error {
// Get renvoie le compte d'identifiant id.
func (a *Accounts) Get(id string) (Account, bool) {
if a.db != nil {
ctx, cancel := context.WithTimeout(context.Background(), accountsTimeout)
defer cancel()
acc, err := catalog.GetDoc[Account](ctx, a.db, accountsTable, id)
if err != nil {
slog.Error("comptes : lecture", "id", id, "err", err)
}
if acc == nil {
return Account{}, false
}
return *acc, true
}
a.mu.Lock()
defer a.mu.Unlock()
if acc, ok := a.byID[id]; ok {
@@ -216,12 +317,21 @@ func (a *Accounts) Get(id string) (Account, bool) {
return Account{}, false
}
// all renvoie les comptes (vide en cas d'erreur, journalisée).
func (a *Accounts) all() (map[string]*Account, bool) {
m, err := a.snapshot()
if err != nil {
slog.Error("comptes : lecture", "err", err)
return map[string]*Account{}, false
}
return m, true
}
// List renvoie tous les comptes, du plus ancien au plus récent.
func (a *Accounts) List() []AccountInfo {
a.mu.Lock()
defer a.mu.Unlock()
out := make([]AccountInfo, 0, len(a.byID))
for _, acc := range a.byID {
m, _ := a.all()
out := make([]AccountInfo, 0, len(m))
for _, acc := range m {
out = append(out, acc.Info())
}
sort.Slice(out, func(i, j int) bool {
@@ -235,14 +345,13 @@ func (a *Accounts) List() []AccountInfo {
// Count renvoie le nombre de comptes.
func (a *Accounts) Count() int {
a.mu.Lock()
defer a.mu.Unlock()
return len(a.byID)
m, _ := a.all()
return len(m)
}
// hasAdmin indique si un administrateur actif existe ; appelé sous mu.
func (a *Accounts) hasAdmin() bool {
for _, acc := range a.byID {
// hasAdmin indique si un administrateur actif existe dans m.
func hasAdmin(m map[string]*Account) bool {
for _, acc := range m {
if acc.Role == RoleAdmin && acc.Status == StatusActive {
return true
}
@@ -251,19 +360,17 @@ func (a *Accounts) hasAdmin() bool {
}
// NeedsSetup indique qu'aucun administrateur n'existe encore : le premier
// compte créé le deviendra.
// compte créé le deviendra. Faux si les comptes sont illisibles.
func (a *Accounts) NeedsSetup() bool {
a.mu.Lock()
defer a.mu.Unlock()
return !a.hasAdmin()
m, ok := a.all()
return ok && !hasAdmin(m)
}
// PendingCount renvoie le nombre d'inscriptions en attente de validation.
func (a *Accounts) PendingCount() int {
a.mu.Lock()
defer a.mu.Unlock()
m, _ := a.all()
n := 0
for _, acc := range a.byID {
for _, acc := range m {
if acc.Status == StatusPending {
n++
}
@@ -271,8 +378,8 @@ func (a *Accounts) PendingCount() int {
return n
}
func (a *Accounts) byUsername(name string) *Account {
for _, acc := range a.byID {
func byUsername(m map[string]*Account, name string) *Account {
for _, acc := range m {
if acc.Provider == ProviderLocal && acc.Username == name {
return acc
}
@@ -319,29 +426,32 @@ func (a *Accounts) CreateLocal(n NewAccount) (Account, error) {
return Account{}, fmt.Errorf("%w : adresse e-mail", ErrInvalidAccount)
}
hash := hashPassword(n.Password) // hors verrou : calcul lent
created := time.Now().UTC().Truncate(time.Second)
a.mu.Lock()
defer a.mu.Unlock()
if _, exists := a.byID[username]; exists {
return Account{}, ErrAccountExists
}
acc := &Account{ID: username, Username: username, Name: name, Email: email, Provider: ProviderLocal,
Role: n.Role, Status: n.Status, Hash: hash, Created: time.Now().UTC().Truncate(time.Second)}
if !a.hasAdmin() {
acc.Role, acc.Status = RoleAdmin, StatusActive
}
if acc.Role != RoleAdmin {
acc.Role = RoleUser
}
if acc.Status != StatusPending && acc.Status != StatusDisabled {
acc.Status = StatusActive
}
a.byID[acc.ID] = acc
if err := a.save(); err != nil {
delete(a.byID, acc.ID)
var out Account
err := a.update(func(m map[string]*Account) error {
if _, exists := m[username]; exists {
return ErrAccountExists
}
acc := &Account{ID: username, Username: username, Name: name, Email: email, Provider: ProviderLocal,
Role: n.Role, Status: n.Status, Hash: hash, Created: created}
if !hasAdmin(m) {
acc.Role, acc.Status = RoleAdmin, StatusActive
}
if acc.Role != RoleAdmin {
acc.Role = RoleUser
}
if acc.Status != StatusPending && acc.Status != StatusDisabled {
acc.Status = StatusActive
}
m[acc.ID] = acc
out = *acc
return nil
})
if err != nil {
return Account{}, err
}
return *acc, nil
return out, nil
}
// EnsureAdmin crée l'administrateur local initial (ADMIN_USER / ADMIN_PASSWORD)
@@ -359,34 +469,56 @@ func (a *Accounts) EnsureAdmin(username, password string) error {
// Authenticate vérifie un identifiant et un mot de passe locaux.
func (a *Accounts) Authenticate(username, password string) (Account, error) {
username = strings.ToLower(strings.TrimSpace(username))
a.mu.Lock()
acc := a.byUsername(username)
var hash string
var acc *Account
if a.db != nil {
ctx, cancel := context.WithTimeout(context.Background(), accountsTimeout)
found, err := catalog.FindDoc[Account](ctx, a.db, accountsTable, "username", username)
cancel()
if err != nil {
return Account{}, err
}
if found != nil && found.Provider == ProviderLocal {
acc = found
}
} else {
a.mu.Lock()
if p := byUsername(a.byID, username); p != nil {
c := *p
acc = &c
}
a.mu.Unlock()
}
hash := a.dummy
if acc != nil {
hash = acc.Hash
} else {
hash = a.dummy
}
a.mu.Unlock()
ok := checkPassword(hash, password) && acc != nil
if !ok {
if !checkPassword(hash, password) || acc == nil {
return Account{}, ErrBadCredentials
}
a.mu.Lock()
defer a.mu.Unlock()
acc = a.byID[acc.ID]
if acc == nil {
return Account{}, ErrBadCredentials
var out Account
var refused error
err := a.update(func(m map[string]*Account) error {
refused = nil
cur := m[acc.ID]
if cur == nil || cur.Hash != hash { // supprimé ou mot de passe changé entre-temps
return ErrBadCredentials
}
out = *cur
switch cur.Status {
case StatusPending:
refused = ErrPending
case StatusDisabled:
refused = ErrDisabled
default:
cur.LastLogin = time.Now().UTC().Truncate(time.Second)
out = *cur
}
return nil
})
if err != nil {
return Account{}, err
}
switch acc.Status {
case StatusPending:
return *acc, ErrPending
case StatusDisabled:
return *acc, ErrDisabled
}
acc.LastLogin = time.Now().UTC().Truncate(time.Second)
_ = a.save()
return *acc, nil
return out, refused
}
// oidcID construit l'identifiant d'un compte OIDC : l'e-mail s'il existe (il
@@ -453,54 +585,61 @@ func (a *Accounts) UpsertOIDC(u User, groups []string, pol OIDCPolicy) (User, er
if !ok || name == "" {
name = u.Sub
}
a.mu.Lock()
defer a.mu.Unlock()
var acc *Account
for _, c := range a.byID {
if c.Provider == ProviderOIDC && c.Sub == u.Sub {
acc = c
break
}
}
wantAdmin := pol.isAdmin(u.Email, groups)
if acc == nil {
id := oidcID(u.Email, u.Sub)
if _, taken := a.byID[id]; taken { // même e-mail, autre sujet : identifiant distinct
id = "oidc." + sanitizeID(u.Sub)
}
acc = &Account{ID: id, Name: name, Email: u.Email, Provider: ProviderOIDC, Sub: u.Sub,
Role: RoleUser, Status: StatusActive, Created: time.Now().UTC().Truncate(time.Second)}
if wantAdmin || !a.hasAdmin() {
acc.Role = RoleAdmin
}
a.byID[acc.ID] = acc
} else {
acc.Name, acc.Email = name, u.Email
if pol.configured() {
switch {
case wantAdmin:
acc.Role = RoleAdmin
case acc.Role == RoleAdmin && a.otherAdmin(acc.ID):
acc.Role = RoleUser
now := time.Now().UTC().Truncate(time.Second)
var out User
var refused error
err := a.update(func(m map[string]*Account) error {
refused = nil
var acc *Account
for _, c := range m {
if c.Provider == ProviderOIDC && c.Sub == u.Sub {
acc = c
break
}
}
}
switch acc.Status {
case StatusPending:
return acc.User(), ErrPending
case StatusDisabled:
return acc.User(), ErrDisabled
}
acc.LastLogin = time.Now().UTC().Truncate(time.Second)
if err := a.save(); err != nil {
if acc == nil {
id := oidcID(u.Email, u.Sub)
if _, taken := m[id]; taken { // même e-mail, autre sujet : identifiant distinct
id = "oidc." + sanitizeID(u.Sub)
}
acc = &Account{ID: id, Name: name, Email: u.Email, Provider: ProviderOIDC, Sub: u.Sub,
Role: RoleUser, Status: StatusActive, Created: now}
if wantAdmin || !hasAdmin(m) {
acc.Role = RoleAdmin
}
m[acc.ID] = acc
} else {
acc.Name, acc.Email = name, u.Email
if pol.configured() {
switch {
case wantAdmin:
acc.Role = RoleAdmin
case acc.Role == RoleAdmin && otherAdmin(m, acc.ID):
acc.Role = RoleUser
}
}
}
switch acc.Status {
case StatusPending:
refused = ErrPending
case StatusDisabled:
refused = ErrDisabled
default:
acc.LastLogin = now
}
out = acc.User()
return nil
})
if err != nil {
return User{}, err
}
return acc.User(), nil
return out, refused
}
// otherAdmin indique si un administrateur actif autre que id existe ; appelé sous mu.
func (a *Accounts) otherAdmin(id string) bool {
for _, acc := range a.byID {
// otherAdmin indique si un administrateur actif autre que id existe dans m.
func otherAdmin(m map[string]*Account, id string) bool {
for _, acc := range m {
if acc.ID != id && acc.Role == RoleAdmin && acc.Status == StatusActive {
return true
}
@@ -529,55 +668,58 @@ func (a *Accounts) Update(id string, p Patch) (Account, error) {
}
hash = hashPassword(*p.Password)
}
a.mu.Lock()
defer a.mu.Unlock()
acc := a.byID[id]
if acc == nil {
return Account{}, ErrNoAccount
}
next := *acc
if p.Name != nil {
n, ok := cleanText(*p.Name, maxNameLen)
if !ok || n == "" {
return Account{}, fmt.Errorf("%w : nom", ErrInvalidAccount)
var out Account
err := a.update(func(m map[string]*Account) error {
acc := m[id]
if acc == nil {
return ErrNoAccount
}
next.Name = n
}
if p.Email != nil && next.Provider == ProviderLocal {
e, ok := cleanText(*p.Email, 120)
if !ok || (e != "" && (!strings.Contains(e, "@") || strings.ContainsAny(e, " <>\"'"))) {
return Account{}, fmt.Errorf("%w : adresse e-mail", ErrInvalidAccount)
next := *acc
if p.Name != nil {
n, ok := cleanText(*p.Name, maxNameLen)
if !ok || n == "" {
return fmt.Errorf("%w : nom", ErrInvalidAccount)
}
next.Name = n
}
next.Email = e
}
if p.Role != nil {
if *p.Role != RoleAdmin && *p.Role != RoleUser {
return Account{}, fmt.Errorf("%w : rôle", ErrInvalidAccount)
if p.Email != nil && next.Provider == ProviderLocal {
e, ok := cleanText(*p.Email, 120)
if !ok || (e != "" && (!strings.Contains(e, "@") || strings.ContainsAny(e, " <>\"'"))) {
return fmt.Errorf("%w : adresse e-mail", ErrInvalidAccount)
}
next.Email = e
}
next.Role = *p.Role
}
if p.Status != nil {
if *p.Status != StatusActive && *p.Status != StatusPending && *p.Status != StatusDisabled {
return Account{}, fmt.Errorf("%w : état", ErrInvalidAccount)
if p.Role != nil {
if *p.Role != RoleAdmin && *p.Role != RoleUser {
return fmt.Errorf("%w : rôle", ErrInvalidAccount)
}
next.Role = *p.Role
}
next.Status = *p.Status
}
if p.Password != nil {
if next.Provider != ProviderLocal {
return Account{}, fmt.Errorf("%w : mot de passe géré par le fournisseur d'identité", ErrInvalidAccount)
if p.Status != nil {
if *p.Status != StatusActive && *p.Status != StatusPending && *p.Status != StatusDisabled {
return fmt.Errorf("%w : état", ErrInvalidAccount)
}
next.Status = *p.Status
}
next.Hash = hash
}
wasAdmin := acc.Role == RoleAdmin && acc.Status == StatusActive
isAdmin := next.Role == RoleAdmin && next.Status == StatusActive
if wasAdmin && !isAdmin && !a.otherAdmin(id) {
return Account{}, ErrLastAdmin
}
*acc = next
if err := a.save(); err != nil {
if p.Password != nil {
if next.Provider != ProviderLocal {
return fmt.Errorf("%w : mot de passe géré par le fournisseur d'identité", ErrInvalidAccount)
}
next.Hash = hash
}
wasAdmin := acc.Role == RoleAdmin && acc.Status == StatusActive
isAdmin := next.Role == RoleAdmin && next.Status == StatusActive
if wasAdmin && !isAdmin && !otherAdmin(m, id) {
return ErrLastAdmin
}
*acc = next
out = next
return nil
})
if err != nil {
return Account{}, err
}
return *acc, nil
return out, nil
}
// ChangePassword remplace le mot de passe d'un compte local après vérification
@@ -599,21 +741,17 @@ func (a *Accounts) ChangePassword(id, current, next string) error {
// Delete supprime un compte. Le dernier administrateur actif ne peut l'être.
func (a *Accounts) Delete(id string) error {
a.mu.Lock()
defer a.mu.Unlock()
acc := a.byID[id]
if acc == nil {
return ErrNoAccount
}
if acc.Role == RoleAdmin && acc.Status == StatusActive && !a.otherAdmin(id) {
return ErrLastAdmin
}
delete(a.byID, id)
if err := a.save(); err != nil {
a.byID[id] = acc
return err
}
return nil
return a.update(func(m map[string]*Account) error {
acc := m[id]
if acc == nil {
return ErrNoAccount
}
if acc.Role == RoleAdmin && acc.Status == StatusActive && !otherAdmin(m, id) {
return ErrLastAdmin
}
delete(m, id)
return nil
})
}
// --- Limitation des tentatives ------------------------------------------------------------
+161
View File
@@ -0,0 +1,161 @@
package auth
import (
"context"
"errors"
"fmt"
"os"
"path/filepath"
"sync"
"testing"
"time"
"github.com/vblogio/upandown/internal/catalog"
)
// Comptes partagés par plusieurs instances via le catalogue PostgreSQL
// (UPANDOWN_TEST_DATABASE_URL ; la table accounts est vidée).
func catalogAccounts(t *testing.T) (*catalog.DB, func() *Accounts) {
t.Helper()
dsn := os.Getenv("UPANDOWN_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("UPANDOWN_TEST_DATABASE_URL non défini")
}
ctx := context.Background()
db, err := catalog.Open(ctx, dsn, 5*time.Second)
if err != nil {
t.Fatal(err)
}
t.Cleanup(db.Close)
if _, err := db.Pool.Exec(ctx, "TRUNCATE accounts; DELETE FROM imports WHERE root = 'global' AND kind = 'accounts'"); err != nil {
t.Fatal(err)
}
return db, func() *Accounts {
a, err := OpenAccounts(t.TempDir())
if err != nil {
t.Fatal(err)
}
if err := a.UseCatalog(db); err != nil {
t.Fatal(err)
}
return a
}
}
func TestCatalogAccountsShared(t *testing.T) {
_, open := catalogAccounts(t)
a, b := open(), open()
// Inscriptions simultanées sur deux instances : un seul administrateur.
var wg sync.WaitGroup
errs := make(chan error, 10)
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
inst := a
if i%2 == 1 {
inst = b
}
_, err := inst.CreateLocal(NewAccount{Username: fmt.Sprintf("user%02d", i), Password: "mot-de-passe-1"})
errs <- err
}(i)
}
wg.Wait()
close(errs)
for err := range errs {
if err != nil {
t.Fatal(err)
}
}
admins := 0
for _, acc := range b.List() {
if acc.Role == RoleAdmin {
admins++
}
}
if a.Count() != 10 || admins != 1 {
t.Fatalf("comptes %d, administrateurs %d", a.Count(), admins)
}
if _, err := b.CreateLocal(NewAccount{Username: "user03", Password: "mot-de-passe-1"}); !errors.Is(err, ErrAccountExists) {
t.Fatalf("doublon : %v", err)
}
// Modification sur une instance, effet immédiat sur l'autre.
disabled := StatusDisabled
if _, err := a.Update("user04", Patch{Status: &disabled}); err != nil {
t.Fatal(err)
}
if _, err := b.Authenticate("user04", "mot-de-passe-1"); !errors.Is(err, ErrDisabled) {
t.Fatalf("compte désactivé : %v", err)
}
acc, err := b.Authenticate("user05", "mot-de-passe-1")
if err != nil || acc.LastLogin.IsZero() {
t.Fatalf("connexion : %v %v", err, acc.LastLogin)
}
if got, _ := a.Get("user05"); got.LastLogin.IsZero() {
t.Error("date de connexion non partagée")
}
if _, err := a.Authenticate("user05", "mauvais-mot-de-passe"); !errors.Is(err, ErrBadCredentials) {
t.Fatal(err)
}
if err := b.Delete("user06"); err != nil {
t.Fatal(err)
}
if _, ok := a.Get("user06"); ok {
t.Error("compte supprimé encore visible")
}
// Le dernier administrateur reste protégé, quelle que soit l'instance.
var admin string
for _, acc := range a.List() {
if acc.Role == RoleAdmin {
admin = acc.ID
}
}
if err := b.Delete(admin); !errors.Is(err, ErrLastAdmin) {
t.Fatalf("dernier administrateur : %v", err)
}
// OIDC : même sujet sur deux instances, un seul compte.
u := User{Sub: "sub-1", Name: "Zoé", Email: "zoe@example.org"}
if _, err := a.UpsertOIDC(u, nil, OIDCPolicy{}); err != nil {
t.Fatal(err)
}
if _, err := b.UpsertOIDC(u, nil, OIDCPolicy{}); err != nil {
t.Fatal(err)
}
if n := a.Count(); n != 10 {
t.Errorf("après OIDC : %d comptes", n)
}
}
func TestCatalogAccountsImportOnce(t *testing.T) {
db, _ := catalogAccounts(t)
dir := t.TempDir()
old, _ := OpenAccounts(dir)
if _, err := old.CreateLocal(NewAccount{Username: "ancien", Password: "mot-de-passe-1"}); err != nil {
t.Fatal(err)
}
a, _ := OpenAccounts(dir)
if err := a.UseCatalog(db); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(filepath.Join(dir, accountsFile+".imported")); err != nil {
t.Fatal("fichier non renommé")
}
if acc, err := a.Authenticate("ancien", "mot-de-passe-1"); err != nil || acc.Role != RoleAdmin {
t.Fatalf("compte repris : %v %+v", err, acc)
}
// Second démarrage : pas de nouvelle reprise.
other := t.TempDir()
o, _ := OpenAccounts(other)
_, _ = o.CreateLocal(NewAccount{Username: "intrus", Password: "mot-de-passe-1"})
o2, _ := OpenAccounts(other)
if err := o2.UseCatalog(db); err != nil {
t.Fatal(err)
}
if _, ok := o2.Get("intrus"); ok {
t.Error("reprise effectuée deux fois")
}
}
+10 -2
View File
@@ -101,9 +101,17 @@ func randomString(n int) string {
}
// LoadSecret renvoie la clé de signature des sessions : secret si fourni
// (16 caractères minimum), sinon le contenu de dir/.session-secret, créé
// aléatoirement au premier démarrage (0600).
// (16 caractères minimum, ou « hex:<clé> » repris d'un .session-secret),
// sinon le contenu de dir/.session-secret, créé aléatoirement au premier
// démarrage (0600).
func LoadSecret(secret, dir string) ([]byte, error) {
if h, ok := strings.CutPrefix(secret, "hex:"); ok { // contenu d'un ancien .session-secret
k, err := hex.DecodeString(strings.TrimSpace(h))
if err != nil || len(k) < 32 {
return nil, errors.New("SESSION_SECRET hex: invalide (64 caractères hexadécimaux attendus)")
}
return k, nil
}
if secret != "" {
if len(secret) < 16 {
return nil, errors.New("SESSION_SECRET trop court (16 caractères minimum)")
+196
View File
@@ -0,0 +1,196 @@
// Package catalog donne accès à la base PostgreSQL partagée par les instances
// d'Upandown : pool de connexions, migrations du schéma et transactions
// rejouées après un conflit ou une bascule du serveur.
//
// Compatibilité haute disponibilité : le DSN peut lister plusieurs hôtes
// (postgres://u:p@pg1,pg2,pg3/upandown?target_session_attrs=read-write) ; pgx
// se connecte alors au primaire. Après une bascule, les connexions vers
// l'ancien primaire échouent ou deviennent en lecture seule : le pool est
// vidé et la transaction est rejouée sur le nouveau primaire.
package catalog
import (
"context"
"embed"
"errors"
"fmt"
"io"
"io/fs"
"log/slog"
"net"
"sort"
"strconv"
"strings"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
//go:embed migrations/*.sql
var migrations embed.FS
// DB est la base du catalogue.
type DB struct {
Pool *pgxpool.Pool
// Attempts borne le nombre d'essais d'une transaction (5 par défaut).
Attempts int
}
// migrationLock : clé du verrou consultatif qui sérialise les migrations
// entre instances qui démarrent en même temps.
const migrationLock = 0x75706e64 // "upnd"
// Open se connecte (en réessayant pendant wait, le temps que le serveur
// démarre) puis applique les migrations manquantes.
func Open(ctx context.Context, dsn string, wait time.Duration) (*DB, error) {
cfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
return nil, fmt.Errorf("DATABASE_URL : %w", err)
}
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, err
}
deadline := time.Now().Add(wait)
for {
err = pool.Ping(ctx)
if err == nil || time.Now().After(deadline) || ctx.Err() != nil {
break
}
slog.Info("catalogue : PostgreSQL injoignable, nouvel essai", "err", err)
time.Sleep(2 * time.Second)
}
if err != nil {
pool.Close()
return nil, fmt.Errorf("connexion à PostgreSQL : %w", err)
}
db := &DB{Pool: pool, Attempts: 5}
if err := db.migrate(ctx); err != nil {
pool.Close()
return nil, err
}
return db, nil
}
// Close ferme le pool.
func (db *DB) Close() { db.Pool.Close() }
// Tx exécute fn dans une transaction, rejouée (avec une attente croissante)
// après un conflit de sérialisation, un interblocage ou une perte du
// primaire. fn peut donc être appelée plusieurs fois : elle ne doit pas avoir
// d'effet hors de la base.
func (db *DB) Tx(ctx context.Context, fn func(pgx.Tx) error) error {
attempts := db.Attempts
if attempts < 1 {
attempts = 1
}
var err error
for i := 0; i < attempts; i++ {
if i > 0 {
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(time.Duration(100<<i) * time.Millisecond):
}
}
err = pgx.BeginFunc(ctx, db.Pool, fn)
if err == nil || !Retryable(err) {
return err
}
if failover(err) {
db.Pool.Reset() // connexions vers l'ancien primaire
}
slog.Warn("catalogue : transaction rejouée", "essai", i+1, "err", err)
}
return err
}
// Retryable indique si une erreur justifie de rejouer la transaction.
func Retryable(err error) bool {
var pg *pgconn.PgError
if errors.As(err, &pg) {
switch {
case pg.Code == "40001", pg.Code == "40P01": // sérialisation, interblocage
return true
case pg.Code == "25006": // lecture seule : on parle à un secondaire
return true
case strings.HasPrefix(pg.Code, "57P"), strings.HasPrefix(pg.Code, "08"): // arrêt, connexion
return true
}
return false
}
return failover(err)
}
// failover reconnaît une connexion perdue ou dirigée vers un secondaire.
func failover(err error) bool {
var pg *pgconn.PgError
if errors.As(err, &pg) {
return pg.Code == "25006" || strings.HasPrefix(pg.Code, "57P") || strings.HasPrefix(pg.Code, "08")
}
var ne net.Error
return errors.As(err, &ne) || errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) ||
pgconn.SafeToRetry(err) || pgconn.Timeout(err)
}
// Lock prend, dans la transaction, un verrou consultatif nommé : les
// transactions qui modifient la même ressource s'exécutent l'une après
// l'autre, quelle que soit l'instance.
func Lock(ctx context.Context, tx pgx.Tx, name string) error {
_, err := tx.Exec(ctx, "SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", name)
return err
}
func (db *DB) migrate(ctx context.Context) error {
conn, err := db.Pool.Acquire(ctx)
if err != nil {
return err
}
defer conn.Release()
if _, err := conn.Exec(ctx, "SELECT pg_advisory_lock($1)", migrationLock); err != nil {
return err
}
defer conn.Exec(context.Background(), "SELECT pg_advisory_unlock($1)", migrationLock) //nolint:errcheck
if _, err := conn.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
version int PRIMARY KEY, applied timestamptz NOT NULL DEFAULT now())`); err != nil {
return err
}
files, err := fs.Glob(migrations, "migrations/*.sql")
if err != nil {
return err
}
sort.Strings(files)
for _, f := range files {
base := strings.TrimPrefix(f, "migrations/")
v, err := strconv.Atoi(strings.SplitN(base, "_", 2)[0])
if err != nil {
return fmt.Errorf("migration %s : numéro attendu", base)
}
var done bool
if err := conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM schema_migrations WHERE version = $1)", v).Scan(&done); err != nil {
return err
}
if done {
continue
}
sql, err := migrations.ReadFile(f)
if err != nil {
return err
}
err = pgx.BeginFunc(ctx, conn, func(tx pgx.Tx) error {
if _, err := tx.Exec(ctx, string(sql)); err != nil {
return err
}
_, err := tx.Exec(ctx, "INSERT INTO schema_migrations (version) VALUES ($1)", v)
return err
})
if err != nil {
return fmt.Errorf("migration %s : %w", base, err)
}
slog.Info("catalogue : migration appliquée", "version", v)
}
return nil
}
+31
View File
@@ -0,0 +1,31 @@
package catalog
import (
"context"
"errors"
"io"
"testing"
"github.com/jackc/pgx/v5/pgconn"
)
func TestRetryable(t *testing.T) {
cases := []struct {
err error
want bool
}{
{&pgconn.PgError{Code: "40001"}, true}, // sérialisation
{&pgconn.PgError{Code: "40P01"}, true}, // interblocage
{&pgconn.PgError{Code: "25006"}, true}, // secondaire après bascule
{&pgconn.PgError{Code: "57P01"}, true}, // arrêt du serveur
{&pgconn.PgError{Code: "23505"}, false}, // doublon : erreur métier
{io.ErrUnexpectedEOF, true},
{context.Canceled, false},
{errors.New("autre"), false},
}
for _, c := range cases {
if got := Retryable(c.err); got != c.want {
t.Errorf("Retryable(%v) = %v, veut %v", c.err, got, c.want)
}
}
}
+261
View File
@@ -0,0 +1,261 @@
package catalog
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io/fs"
"log/slog"
"os"
"regexp"
"github.com/jackc/pgx/v5"
)
// Collections de documents JSON : tables (id text PRIMARY KEY, data jsonb)
// pour les données globales de l'application (comptes, jetons, réglages).
// Chaque modification charge la collection sous un verrou consultatif propre
// à la table, applique la fonction de l'appelant, puis n'écrit que les
// documents ajoutés, modifiés ou supprimés.
var fieldRe = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9_]*$`)
func ident(table string) string { return pgx.Identifier{table}.Sanitize() }
// loadDocs lit toute la collection ; raw reçoit l'encodage Go de chaque
// document (pour détecter ensuite ce qui a changé).
func loadDocs[T any](ctx context.Context, tx pgx.Tx, table string, raw map[string][]byte) (map[string]*T, error) {
rows, err := tx.Query(ctx, "SELECT id, data FROM "+ident(table))
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]*T{}
for rows.Next() {
var id string
var b []byte
if err := rows.Scan(&id, &b); err != nil {
return nil, err
}
v := new(T)
if err := json.Unmarshal(b, v); err != nil {
return nil, fmt.Errorf("%s/%s : %w", table, id, err)
}
out[id] = v
if raw != nil {
if raw[id], err = json.Marshal(v); err != nil {
return nil, err
}
}
}
return out, rows.Err()
}
// AllDocs renvoie toute la collection.
func AllDocs[T any](ctx context.Context, db *DB, table string) (map[string]*T, error) {
var out map[string]*T
err := db.Tx(ctx, func(tx pgx.Tx) error {
var err error
out, err = loadDocs[T](ctx, tx, table, nil)
return err
})
return out, err
}
// GetDoc renvoie le document id (nil s'il n'existe pas).
func GetDoc[T any](ctx context.Context, db *DB, table, id string) (*T, error) {
return findDoc[T](ctx, db, "SELECT data FROM "+ident(table)+" WHERE id = $1", id)
}
// FindDoc renvoie le premier document dont le champ texte field vaut value
// (nil si aucun). field est un nom de champ constant (index sur l'expression).
func FindDoc[T any](ctx context.Context, db *DB, table, field, value string) (*T, error) {
if !fieldRe.MatchString(field) {
return nil, fmt.Errorf("champ %q invalide", field)
}
return findDoc[T](ctx, db, "SELECT data FROM "+ident(table)+" WHERE data->>'"+field+"' = $1 LIMIT 1", value)
}
func findDoc[T any](ctx context.Context, db *DB, sql, arg string) (*T, error) {
var b []byte
err := db.Tx(ctx, func(tx pgx.Tx) error {
b = nil
err := tx.QueryRow(ctx, sql, arg).Scan(&b)
if errors.Is(err, pgx.ErrNoRows) {
return nil
}
return err
})
if err != nil || b == nil {
return nil, err
}
v := new(T)
if err := json.Unmarshal(b, v); err != nil {
return nil, err
}
return v, nil
}
// UpdateDocs modifie la collection : fn reçoit tous les documents (qu'elle
// peut modifier, ajouter ou supprimer) sous le verrou de la table. Une
// erreur de fn annule tout. fn peut être rejouée (voir DB.Tx).
func UpdateDocs[T any](ctx context.Context, db *DB, table string, fn func(map[string]*T) error) error {
return db.Tx(ctx, func(tx pgx.Tx) error {
if err := Lock(ctx, tx, "docs:"+table); err != nil {
return err
}
before := map[string][]byte{}
docs, err := loadDocs[T](ctx, tx, table, before)
if err != nil {
return err
}
if err := fn(docs); err != nil {
return err
}
return writeDocs(ctx, tx, table, before, docs)
})
}
func writeDocs[T any](ctx context.Context, tx pgx.Tx, table string, before map[string][]byte, after map[string]*T) error {
for id := range before {
if _, ok := after[id]; !ok {
if _, err := tx.Exec(ctx, "DELETE FROM "+ident(table)+" WHERE id = $1", id); err != nil {
return err
}
}
}
for id, v := range after {
b, err := json.Marshal(v)
if err != nil {
return err
}
if old, ok := before[id]; ok && bytes.Equal(old, b) {
continue
}
if _, err := tx.Exec(ctx, "INSERT INTO "+ident(table)+" (id, data) VALUES ($1, $2) "+
"ON CONFLICT (id) DO UPDATE SET data = EXCLUDED.data", id, b); err != nil {
return err
}
}
return nil
}
// ReplaceDoc remplace un document existant sans prendre le verrou de la
// table (mise à jour légère, par exemple une date de dernière utilisation) ;
// un document supprimé entre-temps n'est pas recréé.
func ReplaceDoc(ctx context.Context, db *DB, table, id string, v any) error {
b, err := json.Marshal(v)
if err != nil {
return err
}
return db.Tx(ctx, func(tx pgx.Tx) error {
_, err := tx.Exec(ctx, "UPDATE "+ident(table)+" SET data = $2 WHERE id = $1", id, b)
return err
})
}
// ImportFileOnce reprend une seule fois (table imports, clé root + kind)
// l'ancien fichier file : fn reçoit son contenu dans la transaction, puis le
// fichier est renommé en *.imported. Un fichier absent marque simplement la
// reprise comme faite.
func (db *DB) ImportFileOnce(ctx context.Context, root, kind, file string, fn func(context.Context, pgx.Tx, []byte) error) error {
var found bool
err := db.Tx(ctx, func(tx pgx.Tx) error {
found = false
if err := Lock(ctx, tx, "import:"+root+":"+kind); err != nil {
return err
}
var done bool
if err := tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM imports WHERE root = $1 AND kind = $2)",
root, kind).Scan(&done); err != nil || done {
return err
}
b, err := os.ReadFile(file)
switch {
case errors.Is(err, fs.ErrNotExist):
case err != nil:
return err
default:
if err := fn(ctx, tx, b); err != nil {
return fmt.Errorf("%s : %w", file, err)
}
found = true
}
_, err = tx.Exec(ctx, "INSERT INTO imports (root, kind) VALUES ($1, $2)", root, kind)
return err
})
if err != nil || !found {
return err
}
if err := os.Rename(file, file+".imported"); err != nil && !errors.Is(err, fs.ErrNotExist) {
slog.Warn("catalogue : fichier repris non renommé", "fichier", file, "err", err)
}
slog.Info("catalogue : fichier repris en base", "fichier", file)
return nil
}
// InsertDocs ajoute des documents sans écraser ceux qui existent (reprise).
func InsertDocs[T any](ctx context.Context, tx pgx.Tx, table string, docs map[string]*T) error {
for id, v := range docs {
b, err := json.Marshal(v)
if err != nil {
return err
}
if _, err := tx.Exec(ctx, "INSERT INTO "+ident(table)+" (id, data) VALUES ($1, $2) ON CONFLICT (id) DO NOTHING", id, b); err != nil {
return err
}
}
return nil
}
// Blobs : petits fichiers binaires partagés (logo).
// GetBlob renvoie le contenu et la version (horodatage) de key, ou nil.
func (db *DB) GetBlob(ctx context.Context, key string) ([]byte, int64, error) {
var b []byte
var v int64
err := db.Tx(ctx, func(tx pgx.Tx) error {
b, v = nil, 0
err := tx.QueryRow(ctx, "SELECT data, (extract(epoch FROM updated) * 1e6)::bigint FROM app_blobs WHERE key = $1", key).Scan(&b, &v)
if errors.Is(err, pgx.ErrNoRows) {
return nil
}
return err
})
return b, v, err
}
// BlobVersion renvoie la version de key (0 si absent), sans lire le contenu.
func (db *DB) BlobVersion(ctx context.Context, key string) (int64, error) {
var v int64
err := db.Tx(ctx, func(tx pgx.Tx) error {
v = 0
err := tx.QueryRow(ctx, "SELECT (extract(epoch FROM updated) * 1e6)::bigint FROM app_blobs WHERE key = $1", key).Scan(&v)
if errors.Is(err, pgx.ErrNoRows) {
return nil
}
return err
})
return v, err
}
// PutBlob enregistre key (data nil : suppression).
func (db *DB) PutBlob(ctx context.Context, key string, data []byte) error {
return db.Tx(ctx, func(tx pgx.Tx) error {
if data == nil {
_, err := tx.Exec(ctx, "DELETE FROM app_blobs WHERE key = $1", key)
return err
}
_, err := tx.Exec(ctx, `INSERT INTO app_blobs (key, data, updated) VALUES ($1, $2, clock_timestamp())
ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data, updated = EXCLUDED.updated`, key, data)
return err
})
}
// PutBlobTx : PutBlob dans une transaction existante (reprise).
func PutBlobTx(ctx context.Context, tx pgx.Tx, key string, data []byte) error {
_, err := tx.Exec(ctx, `INSERT INTO app_blobs (key, data) VALUES ($1, $2) ON CONFLICT (key) DO NOTHING`, key, data)
return err
}
+29
View File
@@ -0,0 +1,29 @@
-- Métadonnées des fichiers et dossiers (tags, icône, auteurs), par racine :
-- "main" (arborescence commune), "home/<utilisateur>" (espace personnel), "s3".
CREATE TABLE item_meta (
root text NOT NULL,
path text NOT NULL,
tags text[] NOT NULL DEFAULT '{}',
favorite boolean NOT NULL DEFAULT false,
icon text NOT NULL DEFAULT '',
created timestamptz,
created_by text NOT NULL DEFAULT '',
edited_by text NOT NULL DEFAULT '',
PRIMARY KEY (root, path)
);
-- Liens de partage ; data reprend le format de .shares.json.
CREATE TABLE shares (
id text PRIMARY KEY,
root text NOT NULL,
data jsonb NOT NULL
);
CREATE INDEX shares_root ON shares (root);
-- Reprises uniques des anciens fichiers JSON (une ligne par racine et par type).
CREATE TABLE imports (
root text NOT NULL,
kind text NOT NULL,
done timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (root, kind)
);
+28
View File
@@ -0,0 +1,28 @@
-- Données globales partagées par toutes les instances ; data reprend le
-- format des anciens fichiers JSON de DATA_DIR.
CREATE TABLE accounts (
id text PRIMARY KEY,
data jsonb NOT NULL
);
CREATE INDEX accounts_username ON accounts ((data->>'username'));
CREATE INDEX accounts_sub ON accounts ((data->>'sub'));
-- Jetons d'accès (seul leur hachage est conservé).
CREATE TABLE tokens (
id text PRIMARY KEY,
data jsonb NOT NULL
);
CREATE UNIQUE INDEX tokens_hash ON tokens ((data->>'hash'));
-- Réglages d'administration (document "settings", format de .settings.json).
CREATE TABLE app_settings (
id text PRIMARY KEY,
data jsonb NOT NULL
);
-- Petits fichiers binaires (logo).
CREATE TABLE app_blobs (
key text PRIMARY KEY,
data bytea NOT NULL,
updated timestamptz NOT NULL DEFAULT clock_timestamp()
);
+36
View File
@@ -0,0 +1,36 @@
-- Arborescence de la racine S3 : un nœud par fichier ou dossier. Les contenus
-- sont dans le bucket sous object_key, clé fixée au dépôt : renommer ou
-- déplacer ne modifie que ces lignes. La corbeille range les nœuds sous
-- « .trash/<id>/ ».
CREATE TABLE s3_nodes (
path text PRIMARY KEY,
dir text NOT NULL,
name text NOT NULL,
is_dir boolean NOT NULL,
size bigint NOT NULL DEFAULT 0,
mtime timestamptz NOT NULL,
object_key text,
created_by text NOT NULL DEFAULT ''
);
CREATE INDEX s3_nodes_dir ON s3_nodes (dir);
CREATE INDEX s3_nodes_prefix ON s3_nodes (path text_pattern_ops);
CREATE TABLE s3_trash (
id text PRIMARY KEY,
origin text NOT NULL,
name text NOT NULL,
is_dir boolean NOT NULL,
size bigint NOT NULL DEFAULT 0,
deleted timestamptz NOT NULL,
deleted_by text NOT NULL DEFAULT '',
meta jsonb
);
-- Configuration de la racine S3 saisie dans l'interface d'administration
-- (les variables d'environnement l'emportent champ par champ). La clé secrète
-- y est chiffrée avec une clé dérivée de SHARE_SECRET.
CREATE TABLE s3_config (
id integer PRIMARY KEY CHECK (id = 1),
data jsonb NOT NULL,
updated timestamptz NOT NULL DEFAULT clock_timestamp()
);
+366
View File
@@ -0,0 +1,366 @@
package storage
import (
"context"
"encoding/json"
"errors"
"fmt"
"io/fs"
"log/slog"
"os"
"path/filepath"
"slices"
"time"
"github.com/jackc/pgx/v5"
"github.com/vblogio/upandown/internal/catalog"
)
// Catalogue PostgreSQL : quand il est configuré, les métadonnées (tags,
// icônes, auteurs) et les liens de partage d'un Store sont lus et écrits en
// base au lieu de .meta.json et .shares.json, ce qui permet à plusieurs
// instances de servir la même arborescence. Chaque modification se fait dans
// une transaction protégée par un verrou consultatif par racine : deux
// instances qui modifient la même racine passent l'une après l'autre.
// opTimeout borne une opération sur le catalogue.
const opTimeout = 30 * time.Second
type catalogRef struct {
db *catalog.DB
root string // "main", "home/<id>", "s3"
}
// UseCatalog branche le Store sur le catalogue sous la clé root. Au premier
// branchement d'une racine, ses anciens fichiers .meta.json et .shares.json
// sont repris en base puis renommés en *.imported.
func (s *Store) UseCatalog(db *catalog.DB, root string) error {
c := &catalogRef{db: db, root: root}
if err := c.importJSON(s.root); err != nil {
return fmt.Errorf("reprise des métadonnées de %s : %w", root, err)
}
if err := c.importSettings(s.root); err != nil {
return fmt.Errorf("reprise des réglages de %s : %w", root, err)
}
s.metaMu.Lock()
s.cat, s.meta = c, nil
s.metaMu.Unlock()
return nil
}
// settingsTable : réglages d'administration (un document par racine).
const settingsTable = "app_settings"
func (c *catalogRef) settingsID() string { return "settings:" + c.root }
func (c *catalogRef) logoKey() string { return "logo:" + c.root }
// importSettings reprend une seule fois .settings.json et .logo.png.
func (c *catalogRef) importSettings(dir string) error {
ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
defer cancel()
err := c.db.ImportFileOnce(ctx, c.root, "settings", filepath.Join(dir, settingsFile),
func(ctx context.Context, tx pgx.Tx, b []byte) error {
var d settingsDisk
if err := json.Unmarshal(b, &d); err != nil {
return err
}
return catalog.InsertDocs(ctx, tx, settingsTable, map[string]*settingsDisk{c.settingsID(): &d})
})
if err != nil {
return err
}
return c.db.ImportFileOnce(ctx, c.root, "logo", filepath.Join(dir, logoFile),
func(ctx context.Context, tx pgx.Tx, b []byte) error {
return catalog.PutBlobTx(ctx, tx, c.logoKey(), b)
})
}
func ctxOp() (context.Context, context.CancelFunc) {
return context.WithTimeout(context.Background(), opTimeout)
}
// --- Métadonnées -------------------------------------------------------------
func loadMetaTx(ctx context.Context, q pgx.Tx, root string) (map[string]itemMeta, error) {
rows, err := q.Query(ctx, `SELECT path, tags, favorite, icon, created, created_by, edited_by
FROM item_meta WHERE root = $1`, root)
if err != nil {
return nil, err
}
out := map[string]itemMeta{}
for rows.Next() {
var p string
var m itemMeta
var created *time.Time
if err := rows.Scan(&p, &m.Tags, &m.Favorite, &m.Icon, &created, &m.CreatedBy, &m.EditedBy); err != nil {
rows.Close()
return nil, err
}
if len(m.Tags) == 0 {
m.Tags = nil
}
if created != nil {
t := created.UTC()
m.Created = &t
}
out[p] = m
}
return out, rows.Err()
}
func (c *catalogRef) readMeta() (map[string]itemMeta, error) {
ctx, cancel := ctxOp()
defer cancel()
var out map[string]itemMeta
err := c.db.Tx(ctx, func(tx pgx.Tx) error {
var err error
out, err = loadMetaTx(ctx, tx, c.root)
return err
})
return out, err
}
func sameMeta(a, b itemMeta) bool {
return slices.Equal(a.Tags, b.Tags) && a.Favorite == b.Favorite && a.Icon == b.Icon &&
a.CreatedBy == b.CreatedBy && a.EditedBy == b.EditedBy &&
((a.Created == nil) == (b.Created == nil)) && (a.Created == nil || a.Created.Equal(*b.Created))
}
func (c *catalogRef) updateMeta(fn func(map[string]itemMeta) (bool, error)) error {
ctx, cancel := ctxOp()
defer cancel()
return c.db.Tx(ctx, func(tx pgx.Tx) error {
if err := catalog.Lock(ctx, tx, "meta:"+c.root); err != nil {
return err
}
cur, err := loadMetaTx(ctx, tx, c.root)
if err != nil {
return err
}
next := make(map[string]itemMeta, len(cur))
for k, v := range cur {
next[k] = v
}
changed, err := fn(next)
if err != nil || !changed {
return err
}
return writeMetaDiff(ctx, tx, c.root, cur, next)
})
}
func writeMetaDiff(ctx context.Context, tx pgx.Tx, root string, cur, next map[string]itemMeta) error {
b := &pgx.Batch{}
for k := range cur {
if m, ok := next[k]; !ok || m.empty() {
b.Queue("DELETE FROM item_meta WHERE root = $1 AND path = $2", root, k)
}
}
for k, m := range next {
if m.empty() {
continue
}
if old, ok := cur[k]; ok && sameMeta(old, m) {
continue
}
tags := m.Tags
if tags == nil {
tags = []string{}
}
b.Queue(`INSERT INTO item_meta (root, path, tags, favorite, icon, created, created_by, edited_by)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
ON CONFLICT (root, path) DO UPDATE SET tags = EXCLUDED.tags, favorite = EXCLUDED.favorite,
icon = EXCLUDED.icon, created = EXCLUDED.created, created_by = EXCLUDED.created_by,
edited_by = EXCLUDED.edited_by`,
root, k, tags, m.Favorite, m.Icon, m.Created, m.CreatedBy, m.EditedBy)
}
if b.Len() == 0 {
return nil
}
return tx.SendBatch(ctx, b).Close()
}
// --- Liens de partage --------------------------------------------------------
func loadSharesTx(ctx context.Context, tx pgx.Tx, root string) (map[string]shareDisk, error) {
rows, err := tx.Query(ctx, "SELECT id, data FROM shares WHERE root = $1", root)
if err != nil {
return nil, err
}
out := map[string]shareDisk{}
for rows.Next() {
var id string
var d shareDisk
if err := rows.Scan(&id, &d); err != nil {
rows.Close()
return nil, err
}
out[id] = d
}
return out, rows.Err()
}
func (c *catalogRef) readShares() (map[string]shareDisk, error) {
ctx, cancel := ctxOp()
defer cancel()
var out map[string]shareDisk
err := c.db.Tx(ctx, func(tx pgx.Tx) error {
var err error
out, err = loadSharesTx(ctx, tx, c.root)
return err
})
return out, err
}
func (c *catalogRef) editShares(edit func(map[string]shareDisk) (bool, error)) error {
ctx, cancel := ctxOp()
defer cancel()
return c.db.Tx(ctx, func(tx pgx.Tx) error {
if err := catalog.Lock(ctx, tx, "shares:"+c.root); err != nil {
return err
}
cur, err := loadSharesTx(ctx, tx, c.root)
if err != nil {
return err
}
next := make(map[string]shareDisk, len(cur))
for k, v := range cur {
next[k] = v
}
changed, err := edit(next)
if err != nil || !changed {
return err
}
return writeSharesDiff(ctx, tx, c.root, cur, next)
})
}
func writeSharesDiff(ctx context.Context, tx pgx.Tx, root string, cur, next map[string]shareDisk) error {
b := &pgx.Batch{}
for id := range cur {
if _, ok := next[id]; !ok {
b.Queue("DELETE FROM shares WHERE id = $1", id)
}
}
for id, d := range next {
if old, ok := cur[id]; ok && sameShare(old, d) {
continue
}
b.Queue(`INSERT INTO shares (id, root, data) VALUES ($1, $2, $3)
ON CONFLICT (id) DO UPDATE SET root = EXCLUDED.root, data = EXCLUDED.data`, id, root, d)
}
if b.Len() == 0 {
return nil
}
return tx.SendBatch(ctx, b).Close()
}
func sameShare(a, b shareDisk) bool {
ja, _ := json.Marshal(a)
jb, _ := json.Marshal(b)
return string(ja) == string(jb)
}
// --- Reprise des anciens fichiers JSON --------------------------------------
// importJSON reprend .meta.json et .shares.json d'un dossier racine, une seule
// fois par racine (table imports), sous verrou : deux instances qui démarrent
// ensemble ne reprennent pas deux fois.
func (c *catalogRef) importJSON(dir string) error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
var imported []string
err := c.db.Tx(ctx, func(tx pgx.Tx) error {
imported = imported[:0]
if err := catalog.Lock(ctx, tx, "import:"+c.root); err != nil {
return err
}
for _, kind := range []string{"meta", "shares"} {
var done bool
if err := tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM imports WHERE root = $1 AND kind = $2)",
c.root, kind).Scan(&done); err != nil {
return err
}
if done {
continue
}
file := metaFile
if kind == "shares" {
file = sharesFile
}
b, err := os.ReadFile(filepath.Join(dir, file))
switch {
case errors.Is(err, fs.ErrNotExist):
b = nil
case err != nil:
return err
}
if b != nil {
if err := importFile(ctx, tx, c.root, kind, file, b); err != nil {
return err
}
imported = append(imported, file)
}
if _, err := tx.Exec(ctx, "INSERT INTO imports (root, kind) VALUES ($1, $2)", c.root, kind); err != nil {
return err
}
}
return nil
})
if err != nil {
return err
}
for _, f := range imported {
p := filepath.Join(dir, f)
if err := os.Rename(p, p+".imported"); err != nil && !errors.Is(err, fs.ErrNotExist) {
slog.Warn("catalogue : fichier repris non renommé", "fichier", p, "err", err)
}
slog.Info("catalogue : fichier repris en base", "racine", c.root, "fichier", f)
}
return nil
}
func importFile(ctx context.Context, tx pgx.Tx, root, kind, file string, b []byte) error {
if kind == "meta" {
var d struct {
Items map[string]itemMeta `json:"items"`
}
if err := json.Unmarshal(b, &d); err != nil {
return fmt.Errorf("%s : %w", file, err)
}
cur, err := loadMetaTx(ctx, tx, root)
if err != nil {
return err
}
next := make(map[string]itemMeta, len(cur)+len(d.Items))
for k, v := range cur {
next[k] = v
}
for k, v := range d.Items {
if _, ok := next[k]; !ok {
next[k] = v
}
}
return writeMetaDiff(ctx, tx, root, cur, next)
}
var d struct {
Links map[string]shareDisk `json:"links"`
}
if err := json.Unmarshal(b, &d); err != nil {
return fmt.Errorf("%s : %w", file, err)
}
cur, err := loadSharesTx(ctx, tx, root)
if err != nil {
return err
}
next := make(map[string]shareDisk, len(cur)+len(d.Links))
for k, v := range cur {
next[k] = v
}
for k, v := range d.Links {
if _, ok := next[k]; !ok {
next[k] = v
}
}
return writeSharesDiff(ctx, tx, root, cur, next)
}
+243
View File
@@ -0,0 +1,243 @@
package storage
import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"os"
"path/filepath"
"slices"
"sync"
"testing"
"time"
"github.com/vblogio/upandown/internal/catalog"
)
// Les tests du catalogue PostgreSQL s'exécutent quand
// UPANDOWN_TEST_DATABASE_URL est défini ; tous les tests du paquet passent
// alors par la base (newStore branche chaque Store sur une racine unique).
var (
testDBOnce sync.Once
testDB *catalog.DB
testDBErr error
)
func testCatalog(t *testing.T) *catalog.DB {
t.Helper()
dsn := os.Getenv("UPANDOWN_TEST_DATABASE_URL")
if dsn == "" {
return nil
}
testDBOnce.Do(func() {
testDB, testDBErr = catalog.Open(context.Background(), dsn, 5*time.Second)
})
if testDBErr != nil {
t.Fatal(testDBErr)
}
return testDB
}
func uniqueRoot(prefix string) string {
b := make([]byte, 6)
_, _ = rand.Read(b)
return prefix + "-" + hex.EncodeToString(b)
}
func attachTestCatalog(t *testing.T, s *Store) {
t.Helper()
if db := testCatalog(t); db != nil {
if err := s.UseCatalog(db, uniqueRoot("test")); err != nil {
t.Fatal(err)
}
}
}
func needCatalog(t *testing.T) *catalog.DB {
t.Helper()
db := testCatalog(t)
if db == nil {
t.Skip("UPANDOWN_TEST_DATABASE_URL non défini")
}
return db
}
// Deux instances (deux Store sur le même dossier et la même racine du
// catalogue) voient les modifications l'une de l'autre, sans perte en écriture
// concurrente.
func TestCatalogSharedBetweenInstances(t *testing.T) {
db := needCatalog(t)
dir := t.TempDir()
root := uniqueRoot("cluster")
a, _ := New(dir)
b, _ := New(dir)
if err := a.UseCatalog(db, root); err != nil {
t.Fatal(err)
}
if err := b.UseCatalog(db, root); err != nil {
t.Fatal(err)
}
for i := 0; i < 20; i++ {
put(t, a, "f"+string(rune('a'+i))+".txt", "x", PutOptions{})
}
var wg sync.WaitGroup
for i := 0; i < 20; i++ {
st := a
if i%2 == 1 {
st = b
}
wg.Add(1)
go func(st *Store, p, tag string) {
defer wg.Done()
if err := st.EditTags([]string{p}, []string{tag}, nil); err != nil {
t.Error(err)
}
}(st, "f"+string(rune('a'+i))+".txt", "t"+string(rune('a'+i)))
}
wg.Wait()
tags, err := b.Tags()
if err != nil {
t.Fatal(err)
}
if len(tags) != 20 {
t.Errorf("%d tags vus par l'autre instance, 20 attendus : %v", len(tags), tags)
}
if _, err := a.Move("fa.txt", "dossier/fa.txt"); err != nil {
t.Fatal(err)
}
e, err := b.Stat("dossier/fa.txt")
if err != nil || !slices.Equal(e.Tags, []string{"ta"}) {
t.Errorf("tags après déplacement vus par l'autre instance : %+v, %v", e, err)
}
sh, err := a.CreateShare("fb.txt", ShareOptions{})
if err != nil {
t.Fatal(err)
}
if got, err := b.ResolveShare(sh.Token); err != nil || got.Path != "fb.txt" {
t.Errorf("lien créé par a, résolu par b : %+v, %v", got, err)
}
}
func TestCatalogImportsJSONOnce(t *testing.T) {
db := needCatalog(t)
dir := t.TempDir()
s, _ := New(dir)
put(t, s, "a.txt", "a", PutOptions{By: "alice"})
if err := s.EditTags([]string{"a.txt"}, []string{"Ancien"}, nil); err != nil {
t.Fatal(err)
}
sh, err := s.CreateShare("a.txt", ShareOptions{})
if err != nil {
t.Fatal(err)
}
root := uniqueRoot("import")
if err := s.UseCatalog(db, root); err != nil {
t.Fatal(err)
}
e, err := s.Stat("a.txt")
if err != nil || !slices.Equal(e.Tags, []string{"Ancien"}) || e.EditedBy != "alice" {
t.Errorf("métadonnées reprises : %+v, %v", e, err)
}
if _, err := s.ResolveShare(sh.Token); err != nil {
t.Errorf("lien repris : %v", err)
}
for _, f := range []string{metaFile, sharesFile} {
if _, err := os.Stat(filepath.Join(dir, f)); err == nil {
t.Errorf("%s non renommé", f)
}
if _, err := os.Stat(filepath.Join(dir, f+".imported")); err != nil {
t.Errorf("%s.imported absent : %v", f, err)
}
}
// Un .meta.json réapparu n'est pas repris une seconde fois.
_ = os.WriteFile(filepath.Join(dir, metaFile), []byte(`{"items":{"a.txt":{"tags":["Autre"]}}}`), 0o644)
s2, _ := New(dir)
if err := s2.UseCatalog(db, root); err != nil {
t.Fatal(err)
}
if e, _ := s2.Stat("a.txt"); !slices.Equal(e.Tags, []string{"Ancien"}) {
t.Errorf("reprise rejouée : %v", e.Tags)
}
}
func TestCatalogSettingsShared(t *testing.T) {
db := needCatalog(t)
root := uniqueRoot("settings")
dirA := t.TempDir()
if err := os.WriteFile(filepath.Join(dirA, settingsFile), []byte(`{"title":"Ancien"}`), 0o600); err != nil {
t.Fatal(err)
}
open := func(dir string) *Store {
s, err := New(dir)
if err != nil {
t.Fatal(err)
}
if err := s.UseCatalog(db, root); err != nil {
t.Fatal(err)
}
return s
}
a, b := open(dirA), open(t.TempDir())
if st, err := b.ReadSettings(); err != nil || st.Title != "Ancien" {
t.Fatalf("reprise : %v %+v", err, st)
}
if _, err := a.WriteTitle("Partagé"); err != nil {
t.Fatal(err)
}
if _, err := b.WriteQuota(42); err != nil {
t.Fatal(err)
}
st, err := a.ReadSettings()
if err != nil || st.Title != "Partagé" || st.QuotaMB != 42 || st.Logo != "" {
t.Fatalf("réglages : %v %+v", err, st)
}
if _, err := a.WriteLogo(makePNG(10, 10)); err != nil {
t.Fatal(err)
}
if st, _ := b.ReadSettings(); st.Logo == "" {
t.Error("logo non partagé")
}
if l, err := b.ReadLogo(); err != nil || len(l) == 0 {
t.Fatalf("logo : %v", err)
}
if _, err := b.DeleteLogo(); err != nil {
t.Fatal(err)
}
if _, err := a.ReadLogo(); !errors.Is(err, ErrNotFound) {
t.Fatalf("logo supprimé : %v", err)
}
}
// SHARE_SECRET=hex:<contenu de .share-secret> garde valides les liens existants.
func TestShareSecretHexKeepsLinks(t *testing.T) {
dir := t.TempDir()
s, err := New(dir)
if err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Join(dir, "d"), 0o755); err != nil {
t.Fatal(err)
}
sh, err := s.CreateShare("d", ShareOptions{})
if err != nil {
t.Fatal(err)
}
b, err := os.ReadFile(filepath.Join(dir, secretFile))
if err != nil {
t.Fatal(err)
}
s2, _ := New(dir)
if err := s2.SetShareSecret("hex:" + string(b)); err != nil {
t.Fatal(err)
}
if _, err := s2.ResolveShare(sh.Token); err != nil {
t.Fatalf("lien existant refusé : %v", err)
}
for _, bad := range []string{"court", "hex:zz", "hex:abcd"} {
if _, err := DecodeSecret(bad); err == nil {
t.Errorf("%q accepté", bad)
}
}
}
+33 -18
View File
@@ -32,6 +32,17 @@ type Details struct {
const maxDirWalk = 20000
func (s *Store) fileDetails(rel string, meta map[string]itemMeta, shares map[string]int) (*Details, error) {
if s.s3 != nil {
c, _, err := s.lstat(rel)
if err != nil {
return nil, err
}
d := &Details{Shares: shares[c]}
if m := meta[c]; m.Created != nil {
d.Created, d.CreatedBy = m.Created, m.CreatedBy
}
return d, nil
}
c, abs, err := s.resolve(rel)
if err != nil {
return nil, err
@@ -83,6 +94,13 @@ func (s *Store) versionCount(c string) (int, string) {
// dirDetails compte le contenu d'un dossier : éléments directs, puis taille
// et nombre de fichiers de toute l'arborescence (borné à maxDirWalk entrées).
func (s *Store) dirDetails(rel string) (*Details, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return nil, err
}
return s.s3DirDetails(c)
}
_, abs, err := s.resolve(rel)
if err != nil {
return nil, err
@@ -152,24 +170,21 @@ func (s *Store) noteEdit(c, by string, created bool) {
if c == "" {
return
}
s.metaMu.Lock()
defer s.metaMu.Unlock()
if s.loadMeta() != nil {
return
}
m := s.meta[c]
changed := false
if by != "" && m.EditedBy != by {
m.EditedBy, changed = by, true
}
if created && m.Created == nil {
now := time.Now().UTC().Truncate(time.Second)
m.Created, m.CreatedBy, changed = &now, by, true
}
if changed {
s.meta[c] = m
_ = s.saveMeta()
}
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
m := meta[c]
changed := false
if by != "" && m.EditedBy != by {
m.EditedBy, changed = by, true
}
if created && m.Created == nil {
now := time.Now().UTC().Truncate(time.Second)
m.Created, m.CreatedBy, changed = &now, by, true
}
if changed {
meta[c] = m
}
return changed, nil
})
}
// AddDetails complète des entrées (chemins virtuels) de leurs détails. Les
+8 -3
View File
@@ -149,6 +149,12 @@ func (s *Store) autoSnapshot(c, abs string, fi fs.FileInfo) {
// Versions liste les versions d'un fichier existant, la plus récente en premier.
func (s *Store) Versions(rel string) ([]Version, error) {
if s.s3 != nil { // pas d'historique sur S3
if _, err := s.Stat(rel); err != nil {
return nil, err
}
return []Version{}, nil
}
c, abs, err := s.resolve(rel)
if err != nil {
return nil, err
@@ -164,7 +170,7 @@ func (s *Store) Versions(rel string) ([]Version, error) {
}
// OpenVersion ouvre une version en lecture.
func (s *Store) OpenVersion(rel, id string) (*os.File, fs.FileInfo, error) {
func (s *Store) OpenVersion(rel, id string) (File, fs.FileInfo, error) {
c, _, err := s.resolve(rel)
if err != nil {
return nil, nil, err
@@ -203,7 +209,7 @@ func (s *Store) Snapshot(rel string) (Version, error) {
// Restore remplace le contenu d'un fichier par une de ses versions. Le contenu
// courant est d'abord enregistré comme version : une restauration s'annule.
func (s *Store) Restore(rel, id string) (Entry, error) {
vf, _, err := s.OpenVersion(rel, id)
vf, vfi, err := s.OpenVersion(rel, id)
if err != nil {
return Entry{}, err
}
@@ -213,7 +219,6 @@ func (s *Store) Restore(rel, id string) (Entry, error) {
if err != nil || !fi.Mode().IsRegular() {
return Entry{}, ErrNotFound
}
vfi, _ := vf.Stat()
tmp, err := os.CreateTemp(filepath.Dir(abs), ".tmp-*")
if err != nil {
return Entry{}, err
+98 -76
View File
@@ -94,18 +94,62 @@ func (s *Store) saveMeta() error {
return atomicWrite(filepath.Join(s.root, metaFile), b)
}
// metaSnapshot renvoie une copie des métadonnées (pour List et Search).
// metaSnapshot renvoie une copie des métadonnées (pour List et Search) ;
// vide en cas d'erreur de lecture.
func (s *Store) metaSnapshot() map[string]itemMeta {
m, err := s.readMeta()
if err != nil {
return map[string]itemMeta{}
}
return m
}
// readMeta renvoie une copie des métadonnées de la racine (fichier .meta.json
// ou catalogue PostgreSQL).
func (s *Store) readMeta() (map[string]itemMeta, error) {
if s.cat != nil {
return s.cat.readMeta()
}
s.metaMu.Lock()
defer s.metaMu.Unlock()
if s.loadMeta() != nil {
return map[string]itemMeta{}
if err := s.loadMeta(); err != nil {
return nil, err
}
out := make(map[string]itemMeta, len(s.meta))
for k, v := range s.meta {
out[k] = v
}
return out
return out, nil
}
// updateMeta applique fn aux métadonnées de la racine sous verrou (verrou du
// processus, ou verrou consultatif PostgreSQL partagé par les instances) et
// enregistre le résultat si fn renvoie true. fn reçoit une copie : rien n'est
// enregistré en cas d'erreur.
func (s *Store) updateMeta(fn func(map[string]itemMeta) (bool, error)) error {
if s.cat != nil {
return s.cat.updateMeta(fn)
}
s.metaMu.Lock()
defer s.metaMu.Unlock()
if err := s.loadMeta(); err != nil {
return err
}
m := make(map[string]itemMeta, len(s.meta))
for k, v := range s.meta {
m[k] = v
}
changed, err := fn(m)
if err != nil || !changed {
return err
}
old := s.meta
s.meta = m
if err := s.saveMeta(); err != nil {
s.meta = old
return err
}
return nil
}
func decorate(e *Entry, meta map[string]itemMeta) {
@@ -135,32 +179,29 @@ func normTag(t string) (string, error) {
func (s *Store) editMeta(paths []string, edit func(*itemMeta) error) error {
cs := make([]string, 0, len(paths))
for _, p := range paths {
c, abs, err := s.resolve(p)
c, err := Clean(p)
if err != nil {
return err
}
if c == "" {
return ErrInvalidPath
}
if _, err := os.Lstat(abs); err != nil {
return mapErr(err)
if _, _, err := s.lstat(c); err != nil {
return err
}
cs = append(cs, c)
}
s.metaMu.Lock()
defer s.metaMu.Unlock()
if err := s.loadMeta(); err != nil {
return err
}
for _, c := range cs {
m := s.meta[c]
m.Tags = append([]string(nil), m.Tags...)
if err := edit(&m); err != nil {
return err
return s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
for _, c := range cs {
m := meta[c]
m.Tags = append([]string(nil), m.Tags...)
if err := edit(&m); err != nil {
return false, err
}
meta[c] = m
}
s.meta[c] = m
}
return s.saveMeta()
return true, nil
})
}
// SetFavorite ajoute ou retire des éléments des favoris.
@@ -177,12 +218,8 @@ func (s *Store) SetIcon(paths []string, icon string) error {
return fmt.Errorf("%w : icône %q", ErrInvalidPath, icon)
}
for _, p := range paths {
_, abs, err := s.resolve(p)
if err != nil {
if _, fi, err := s.lstat(p); err != nil {
return err
}
if fi, err := os.Lstat(abs); err != nil {
return mapErr(err)
} else if !fi.IsDir() {
return fmt.Errorf("%w : %q n'est pas un dossier", ErrInvalidPath, p)
}
@@ -209,19 +246,17 @@ func (s *Store) EditTags(paths, add, remove []string) error {
drop[fold(strings.TrimSpace(t))] = true
}
canon := map[string]string{} // écriture existante de chaque tag
s.metaMu.Lock()
err := s.loadMeta()
for _, m := range s.meta {
all, err := s.readMeta()
if err != nil {
return err
}
for _, m := range all {
for _, t := range m.Tags {
if _, ok := canon[fold(t)]; !ok {
canon[fold(t)] = t
}
}
}
s.metaMu.Unlock()
if err != nil {
return err
}
return s.editMeta(paths, func(m *itemMeta) error {
kept := m.Tags[:0]
has := map[string]bool{}
@@ -252,14 +287,13 @@ func (s *Store) EditTags(paths, add, remove []string) error {
// Tags liste les tags utilisés, triés par nom, avec leur nombre d'éléments.
func (s *Store) Tags() ([]TagCount, error) {
s.metaMu.Lock()
defer s.metaMu.Unlock()
if err := s.loadMeta(); err != nil {
all, err := s.readMeta()
if err != nil {
return nil, err
}
idx := map[string]int{}
out := []TagCount{}
for _, m := range s.meta {
for _, m := range all {
for _, t := range m.Tags {
k := fold(t)
if i, ok := idx[k]; ok {
@@ -279,52 +313,40 @@ func (s *Store) Tags() ([]TagCount, error) {
func under(k, c string) bool { return k == c || strings.HasPrefix(k, c+"/") }
func (s *Store) moveMeta(from, to string) {
s.metaMu.Lock()
defer s.metaMu.Unlock()
if s.loadMeta() != nil {
return
}
moved := map[string]itemMeta{}
for k, m := range s.meta {
if under(k, from) {
delete(s.meta, k)
moved[to+k[len(from):]] = m
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
moved := map[string]itemMeta{}
for k, m := range meta {
if under(k, from) {
delete(meta, k)
moved[to+k[len(from):]] = m
}
}
}
for k, m := range moved {
s.meta[k] = m
}
if len(moved) > 0 {
_ = s.saveMeta()
}
for k, m := range moved {
meta[k] = m
}
return len(moved) > 0, nil
})
}
func (s *Store) copyMeta(from, to string) {
s.metaMu.Lock()
defer s.metaMu.Unlock()
if s.loadMeta() != nil {
return
}
if m, ok := s.meta[from]; ok && len(m.Tags) > 0 {
s.meta[to] = itemMeta{Tags: append([]string(nil), m.Tags...)} // pas le favori
_ = s.saveMeta()
}
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
if m, ok := meta[from]; ok && len(m.Tags) > 0 {
meta[to] = itemMeta{Tags: append([]string(nil), m.Tags...)} // pas le favori
return true, nil
}
return false, nil
})
}
func (s *Store) removeMeta(c string) {
s.metaMu.Lock()
defer s.metaMu.Unlock()
if s.loadMeta() != nil {
return
}
changed := false
for k := range s.meta {
if under(k, c) {
delete(s.meta, k)
changed = true
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
changed := false
for k := range meta {
if under(k, c) {
delete(meta, k)
changed = true
}
}
}
if changed {
_ = s.saveMeta()
}
return changed, nil
})
}
+184
View File
@@ -0,0 +1,184 @@
package storage
import (
"errors"
"fmt"
"io"
"io/fs"
"os"
"path"
"path/filepath"
"sort"
"strings"
)
// Une racine (Root) est une arborescence de fichiers adressée par chemins
// relatifs « slash » : l'arborescence commune et les espaces personnels sur
// disque (Store), demain un bucket S3. Space aiguille les chemins virtuels vers
// la racine qui les porte ; ce qui ne dépend que de Root (archives ZIP, copie
// et déplacement entre racines) marche pour toutes.
// File est un fichier ouvert en lecture : *os.File sur disque, objet distant
// lu par plages pour S3. http.ServeContent n'a besoin que de Read et Seek.
type File interface {
io.Reader
io.Seeker
io.Closer
}
// WalkFunc reçoit chaque élément visité par Root.Walk ; rel est relatif à la
// racine. Renvoyer fs.SkipDir sur un dossier saute son contenu.
type WalkFunc func(rel string, e Entry) error
// Root regroupe les opérations de base d'une racine de fichiers.
type Root interface {
List(rel string) ([]Entry, error)
Stat(rel string) (Entry, error)
Open(rel string) (File, fs.FileInfo, error)
Put(rel string, r io.Reader, o PutOptions) (Entry, error)
Mkdir(rel string) (Entry, error)
Move(from, to string) (Entry, error)
Copy(from, to string) (Entry, error)
// Delete met l'élément à la corbeille de la racine.
Delete(rel string, recursive bool) error
// Remove supprime définitivement l'élément (fin d'un déplacement entre racines).
Remove(rel string) error
// Walk parcourt rel puis son contenu, dossiers avant leur contenu, en
// ignorant les éléments internes (noms cachés) et les liens.
Walk(rel string, fn WalkFunc) error
}
var _ Root = (*Store)(nil)
// Walk parcourt un fichier ou un dossier du Store (voir Root.Walk).
func (s *Store) Walk(rel string, fn WalkFunc) error {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return err
}
return s.s3Walk(c, fn)
}
c, abs, err := s.resolve(rel)
if err != nil {
return err
}
if _, err := os.Lstat(abs); err != nil {
return mapErr(err)
}
return filepath.WalkDir(abs, func(p string, d fs.DirEntry, err error) error {
if err != nil {
return nil // élément illisible : sauté
}
if p != abs && (!visible(d.Name()) || d.Type()&fs.ModeSymlink != 0) {
if d.IsDir() {
return filepath.SkipDir
}
return nil
}
if !d.IsDir() && !d.Type().IsRegular() {
return nil
}
fi, err := d.Info()
if err != nil {
return nil
}
r, _ := filepath.Rel(abs, p)
er := c
if r != "." {
er = path.Join(c, filepath.ToSlash(r))
}
if p == abs && c == "" {
er = ""
}
return fn(er, toEntry(er, fi))
})
}
// Remove supprime définitivement un fichier ou un dossier, avec ses
// miniatures, son historique, ses métadonnées et ses liens de partage.
func (s *Store) Remove(rel string) error {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return err
}
return s.s3Remove(c)
}
c, abs, err := s.resolve(rel)
if err != nil {
return err
}
if c == "" {
return ErrInvalidPath
}
if _, err := os.Lstat(abs); err != nil {
return mapErr(err)
}
if err := os.RemoveAll(abs); err != nil {
return err
}
_ = os.RemoveAll(s.historyAbs(c))
s.removeThumb(c)
s.removeMeta(c)
s.removeShares(c)
s.usageDirty()
return nil
}
// transfer copie from (racine src) vers to (racine dst) en flux, fichier par
// fichier : c'est le chemin générique entre deux racines qui ne partagent pas
// de volume. La destination ne doit pas exister. En cas d'échec, ce qui a été
// copié est retiré. by est l'auteur noté sur les fichiers copiés.
func transfer(src Root, from string, dst Root, to string, by string) (Entry, error) {
top, err := src.Stat(from)
if err != nil {
return Entry{}, err
}
if _, err := dst.Stat(to); err == nil {
return Entry{}, ErrExists
} else if !errors.Is(err, ErrNotFound) {
return Entry{}, err
}
base := top.Path
target := func(rel string) string {
if rel == base {
return to
}
return path.Join(to, strings.TrimPrefix(rel, base+"/"))
}
if base == "" {
target = func(rel string) string { return path.Join(to, rel) }
}
err = src.Walk(from, func(rel string, e Entry) error {
t := target(rel)
if e.IsDir {
if _, err := dst.Mkdir(t); err != nil && !errors.Is(err, ErrExists) {
return err
}
return nil
}
f, _, err := src.Open(rel)
if err != nil {
return err
}
defer f.Close()
_, err = dst.Put(t, f, PutOptions{ModTime: e.ModTime, By: by})
return err
})
if err != nil {
_ = dst.Remove(to)
return Entry{}, fmt.Errorf("copie vers %s : %w", to, err)
}
return dst.Stat(to)
}
// sortEntries trie une liste de dossier : dossiers d'abord, puis par nom.
func sortEntries(out []Entry) {
sort.Slice(out, func(i, j int) bool {
if out[i].IsDir != out[j].IsDir {
return out[i].IsDir
}
return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
})
}
+118
View File
@@ -0,0 +1,118 @@
package storage
import (
"archive/zip"
"bytes"
"errors"
"sort"
"testing"
)
func TestWalkSkipsInternalFiles(t *testing.T) {
s := newStore(t)
put(t, s, "d/a.txt", "a", PutOptions{})
put(t, s, "d/sous/b.txt", "bb", PutOptions{})
put(t, s, "d/a.txt", "a2", PutOptions{Conflict: "overwrite"}) // crée .history
if err := s.EditTags([]string{"d/a.txt"}, []string{"x"}, nil); err != nil {
t.Fatal(err)
}
var got []string
if err := s.Walk("d", func(rel string, e Entry) error {
if rel != e.Path {
t.Errorf("rel %q != Path %q", rel, e.Path)
}
got = append(got, rel)
return nil
}); err != nil {
t.Fatal(err)
}
sort.Strings(got)
want := []string{"d", "d/a.txt", "d/sous", "d/sous/b.txt"}
if len(got) != len(want) {
t.Fatalf("Walk = %v, veut %v", got, want)
}
for i := range want {
if got[i] != want[i] {
t.Fatalf("Walk = %v, veut %v", got, want)
}
}
var root []string
_ = s.Walk("", func(rel string, e Entry) error { root = append(root, rel); return nil })
for _, r := range root {
if r == ".history" || r == ".meta.json" {
t.Errorf("Walk expose un fichier interne : %s", r)
}
}
}
func TestTransferBetweenRoots(t *testing.T) {
src, dst := newStore(t), newStore(t)
put(t, src, "projet/plan.txt", "plan", PutOptions{})
put(t, src, "projet/img/logo.svg", "<svg/>", PutOptions{})
if _, err := src.Mkdir("projet/vide"); err != nil {
t.Fatal(err)
}
e, err := transfer(src, "projet", dst, "copie/projet", "alice")
if err != nil {
t.Fatal(err)
}
if !e.IsDir || e.Path != "copie/projet" {
t.Errorf("transfer = %+v", e)
}
if got := read(t, dst, "copie/projet/img/logo.svg"); got != "<svg/>" {
t.Errorf("contenu copié = %q", got)
}
if _, err := dst.Stat("copie/projet/vide"); err != nil {
t.Errorf("dossier vide non copié : %v", err)
}
if _, err := transfer(src, "projet", dst, "copie/projet", "alice"); !errors.Is(err, ErrExists) {
t.Errorf("destination existante : %v", err)
}
// Un fichier seul.
if _, err := transfer(src, "projet/plan.txt", dst, "plan.txt", ""); err != nil {
t.Fatal(err)
}
if got := read(t, dst, "plan.txt"); got != "plan" {
t.Errorf("fichier copié = %q", got)
}
}
func TestRemoveIsDefinitive(t *testing.T) {
s := newStore(t)
put(t, s, "d/a.txt", "a", PutOptions{})
if err := s.Remove("d"); err != nil {
t.Fatal(err)
}
if _, err := s.Stat("d"); !errors.Is(err, ErrNotFound) {
t.Errorf("Stat après Remove : %v", err)
}
if s.TrashCount() != 0 {
t.Errorf("Remove ne doit pas passer par la corbeille")
}
if err := s.Remove(""); !errors.Is(err, ErrInvalidPath) {
t.Errorf("Remove de la racine : %v", err)
}
}
func TestZipThroughRoot(t *testing.T) {
s := newStore(t)
put(t, s, "d/a.txt", "a", PutOptions{})
put(t, s, "d/s/b.txt", "b", PutOptions{})
var buf bytes.Buffer
if err := WriteZip(&buf, []ZipItem{{Root: s, Rel: "d", Name: "d"}, {Root: s, Rel: "d/a.txt", Name: "a.txt"}}); err != nil {
t.Fatal(err)
}
zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatal(err)
}
names := map[string]bool{}
for _, f := range zr.File {
names[f.Name] = true
}
for _, n := range []string{"d/", "d/a.txt", "d/s/", "d/s/b.txt", "a.txt"} {
if !names[n] {
t.Errorf("archive sans %s : %v", n, names)
}
}
}
+967
View File
@@ -0,0 +1,967 @@
package storage
import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"io"
"io/fs"
"log/slog"
"net/url"
"os"
"path"
"strings"
"time"
"github.com/jackc/pgx/v5"
"github.com/vblogio/upandown/internal/catalog"
)
// Racine S3 : l'arborescence (noms, dossiers, tailles, dates) vit dans le
// catalogue PostgreSQL (table s3_nodes), les contenus dans le bucket sous une
// clé fixée au dépôt (« o/<id> »). Renommer ou déplacer ne touche donc que le
// catalogue ; le chemin de dépôt reste dans les métadonnées x-amz-meta de
// l'objet (reconstruction de secours). Corbeille : les nœuds passent sous
// « .trash/<id>/ » dans le catalogue, les objets ne sont supprimés qu'à la
// purge. Pas d'historique de versions ni de recherche plein texte.
// ObjectStore est le minimum attendu du stockage objet (minio-go pour Garage,
// mémoire pour les tests).
type ObjectStore interface {
// Put envoie r (taille inconnue : -1) sous key et renvoie la taille écrite.
Put(ctx context.Context, key string, r io.Reader, meta map[string]string) (int64, error)
// Get ouvre key en lecture par plages.
Get(ctx context.Context, key string) (File, error)
// Copy duplique src vers dst côté serveur.
Copy(ctx context.Context, src, dst string, meta map[string]string) error
Remove(ctx context.Context, key string) error
// Empty indique si le bucket ne contient aucun objet.
Empty(ctx context.Context) (bool, error)
}
const (
s3TrashPrefix = ".trash"
s3ObjPrefix = "o/"
s3LockName = "s3tree"
)
// s3Root porte les opérations propres à la racine S3 d'un Store.
type s3Root struct {
db *catalog.DB
objs ObjectStore
}
type s3Node struct {
Path, Dir, Name string
IsDir bool
Size int64
ModTime time.Time
Key string
}
// NewS3 crée le Store de la racine S3 : cacheDir (sur DATA_DIR) ne reçoit que
// les miniatures ; métadonnées et partages vont dans le catalogue sous la
// racine "s3".
func NewS3(cacheDir string, db *catalog.DB, objs ObjectStore) (*Store, error) {
s, err := New(cacheDir)
if err != nil {
return nil, err
}
s.History = HistoryPolicy{}
s.s3 = &s3Root{db: db, objs: objs}
if err := s.UseCatalog(db, "s3"); err != nil {
return nil, err
}
// Décision : la racine S3 démarre toujours sur un bucket vide. Un catalogue
// vide face à un bucket qui contient déjà des objets (autre usage, ou
// catalogue perdu) est refusé plutôt que de mélanger les deux.
empty, err := s.s3Empty()
if err != nil {
return nil, err
}
if empty {
ctx, cancel := ctxOp()
defer cancel()
bucketEmpty, err := objs.Empty(ctx)
if err != nil {
return nil, err
}
if !bucketEmpty {
return nil, errors.New("racine S3 refusée : le bucket contient déjà des objets alors que le catalogue est vide (bucket vide attendu)")
}
}
return s, nil
}
// IsS3 indique si le Store est la racine S3.
func (s *Store) IsS3() bool { return s.s3 != nil }
func newObjectKey() string {
b := make([]byte, 16)
_, _ = rand.Read(b)
return s3ObjPrefix + hex.EncodeToString(b)
}
func s3Now() time.Time { return time.Now().UTC().Truncate(time.Microsecond) }
func parentOf(c string) string {
if d := path.Dir(c); d != "." {
return d
}
return ""
}
// --- Lecture du catalogue ----------------------------------------------------------
const s3Cols = "path, dir, name, is_dir, size, mtime, object_key"
func scanNode(row pgx.Row) (s3Node, error) {
var n s3Node
var key *string
err := row.Scan(&n.Path, &n.Dir, &n.Name, &n.IsDir, &n.Size, &n.ModTime, &key)
if key != nil {
n.Key = *key
}
n.ModTime = n.ModTime.UTC()
return n, err
}
func getNode(ctx context.Context, q pgx.Tx, c string) (s3Node, bool, error) {
n, err := scanNode(q.QueryRow(ctx, "SELECT "+s3Cols+" FROM s3_nodes WHERE path = $1", c))
if errors.Is(err, pgx.ErrNoRows) {
return s3Node{}, false, nil
}
return n, err == nil, err
}
func queryNodes(ctx context.Context, q pgx.Tx, where string, args ...any) ([]s3Node, error) {
rows, err := q.Query(ctx, "SELECT "+s3Cols+" FROM s3_nodes WHERE "+where, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var out []s3Node
for rows.Next() {
n, err := scanNode(rows)
if err != nil {
return nil, err
}
out = append(out, n)
}
return out, rows.Err()
}
// subtree : le nœud c et tout ce qu'il contient.
const subtreeWhere = "(path = $1 OR starts_with(path, $1 || '/'))"
func (r *s3Root) read(fn func(ctx context.Context, tx pgx.Tx) error) error {
ctx, cancel := ctxOp()
defer cancel()
return r.db.Tx(ctx, func(tx pgx.Tx) error { return fn(ctx, tx) })
}
// write exécute fn sous le verrou de l'arborescence S3 (toutes instances).
func (r *s3Root) write(fn func(ctx context.Context, tx pgx.Tx) error) error {
ctx, cancel := ctxOp()
defer cancel()
return r.db.Tx(ctx, func(tx pgx.Tx) error {
if err := catalog.Lock(ctx, tx, s3LockName); err != nil {
return err
}
return fn(ctx, tx)
})
}
func (n s3Node) entry() Entry {
e := Entry{Name: n.Name, Path: n.Path, IsDir: n.IsDir, ModTime: n.ModTime}
if !n.IsDir {
e.Size = n.Size
}
return e
}
// s3Info : fs.FileInfo d'un objet (ETag dérivé de la taille et de la date).
type s3Info struct{ n s3Node }
func (i s3Info) Name() string { return i.n.Name }
func (i s3Info) Size() int64 { return i.n.Size }
func (i s3Info) Mode() fs.FileMode { return 0o644 }
func (i s3Info) ModTime() time.Time { return i.n.ModTime }
func (i s3Info) IsDir() bool { return i.n.IsDir }
func (i s3Info) Sys() any { return nil }
// ensureDirs crée les dossiers manquants de dir (et refuse un fichier en chemin).
func ensureDirs(ctx context.Context, tx pgx.Tx, dir string, now time.Time) error {
if dir == "" {
return nil
}
n, ok, err := getNode(ctx, tx, dir)
if err != nil {
return err
}
if ok {
if !n.IsDir {
return fmt.Errorf("%w : un fichier porte le nom d'un dossier du chemin", ErrExists)
}
return nil
}
if err := ensureDirs(ctx, tx, parentOf(dir), now); err != nil {
return err
}
_, err = tx.Exec(ctx, "INSERT INTO s3_nodes (path, dir, name, is_dir, size, mtime) VALUES ($1, $2, $3, true, 0, $4)",
dir, parentOf(dir), path.Base(dir), now)
return err
}
// --- Opérations de base (Root) ---------------------------------------------------
func (s *Store) s3List(c string) ([]Entry, error) {
var nodes []s3Node
err := s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
if c != "" {
n, ok, err := getNode(ctx, tx, c)
if err != nil {
return err
}
if !ok || !n.IsDir {
return ErrNotFound
}
}
var err error
nodes, err = queryNodes(ctx, tx, "dir = $1", c)
return err
})
if err != nil {
return nil, err
}
meta := s.metaSnapshot()
out := make([]Entry, 0, len(nodes))
for _, n := range nodes {
if !visible(n.Name) {
continue
}
e := n.entry()
decorate(&e, meta)
out = append(out, e)
}
sortEntries(out)
return out, nil
}
func (s *Store) s3Node(c string) (s3Node, error) {
var n s3Node
err := s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
var ok bool
var err error
n, ok, err = getNode(ctx, tx, c)
if err == nil && !ok {
err = ErrNotFound
}
return err
})
return n, err
}
func (s *Store) s3Stat(c string) (Entry, error) {
if c == "" {
return Entry{Path: "", IsDir: true}, nil
}
n, err := s.s3Node(c)
if err != nil {
return Entry{}, err
}
e := n.entry()
decorate(&e, s.metaSnapshot())
return e, nil
}
func (s *Store) s3Open(c string) (File, fs.FileInfo, error) {
n, err := s.s3Node(c)
if err != nil {
return nil, nil, err
}
if n.IsDir || n.Key == "" {
return nil, nil, ErrNotFound
}
ctx, cancel := ctxOp()
defer cancel()
f, err := s.s3.objs.Get(ctx, n.Key)
if err != nil {
return nil, nil, err
}
return f, s3Info{n}, nil
}
// countingReader compte les octets lus et s'arrête au-delà de max (0 : illimité).
type countingReader struct {
r io.Reader
n int64
max int64
}
var errTooMuch = errors.New("limite dépassée")
func (c *countingReader) Read(p []byte) (int, error) {
n, err := c.r.Read(p)
c.n += int64(n)
if c.max > 0 && c.n > c.max {
return n, errTooMuch
}
return n, err
}
// freeNameTx : comme Store.freeName, dans le catalogue.
func freeNameTx(ctx context.Context, tx pgx.Tx, c string, isDir bool, format string) (string, error) {
_, ok, err := getNode(ctx, tx, c)
if err != nil || !ok {
return c, err
}
dir, base := parentOf(c), path.Base(c)
ext := ""
if !isDir {
ext = path.Ext(base)
if ext == base {
ext = ""
}
}
stem := strings.TrimSuffix(base, ext)
for i := 2; ; i++ {
cand := path.Join(dir, stem+fmt.Sprintf(format, i)+ext)
_, ok, err := getNode(ctx, tx, cand)
if err != nil || !ok {
return cand, err
}
}
}
func (s *Store) s3Put(c string, r io.Reader, o PutOptions) (Entry, error) {
if c == "" {
return Entry{}, ErrInvalidPath
}
// Contrôles préalables (refaits sous verrou après l'envoi).
target := c
if err := s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
n, ok, err := getNode(ctx, tx, c)
if err != nil || !ok {
if err == nil && o.IfMatch != "" && o.IfMatch != "*" {
err = ErrConflict
}
return err
}
if n.IsDir {
return fmt.Errorf("%w : un dossier porte déjà ce nom", ErrExists)
}
switch o.Conflict {
case "overwrite":
if o.IfMatch != "" && o.IfMatch != "*" && o.IfMatch != ETag(s3Info{n}) {
return ErrConflict
}
case "rename":
target, err = freeNameTx(ctx, tx, c, false, " (%d)")
return err
default:
return ErrExists
}
return nil
}); err != nil {
return Entry{}, err
}
key := newObjectKey()
cr := &countingReader{r: r}
if o.Limit > 0 {
cr.max = o.Limit
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
meta := map[string]string{"path": url.PathEscape(target), "by": url.PathEscape(o.By)}
size, err := s.s3.objs.Put(ctx, key, cr, meta)
if err != nil || (o.Limit > 0 && cr.n > o.Limit) {
s.s3RemoveObjects([]string{key})
if errors.Is(err, errTooMuch) || (o.Limit > 0 && cr.n > o.Limit) {
if o.LimitErr != nil {
return Entry{}, o.LimitErr
}
return Entry{}, ErrTooLarge
}
return Entry{}, err
}
mtime := s3Now()
if m := o.ModTime; !m.IsZero() && m.After(time.Date(1980, 1, 1, 0, 0, 0, 0, time.UTC)) && m.Before(time.Now().Add(24*time.Hour)) {
mtime = m.UTC().Truncate(time.Microsecond)
}
var old string
created := false
err = s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
old, created = "", false
n, ok, err := getNode(ctx, tx, target)
if err != nil {
return err
}
if ok {
if n.IsDir {
return fmt.Errorf("%w : un dossier porte déjà ce nom", ErrExists)
}
switch o.Conflict {
case "overwrite":
if o.IfMatch != "" && o.IfMatch != "*" && o.IfMatch != ETag(s3Info{n}) {
return ErrConflict
}
case "rename": // pris entre-temps
if target, err = freeNameTx(ctx, tx, target, false, " (%d)"); err != nil {
return err
}
ok = false
default:
return ErrExists
}
} else if o.IfMatch != "" && o.IfMatch != "*" && o.Conflict == "overwrite" && target == c {
return ErrConflict
}
if err := ensureDirs(ctx, tx, parentOf(target), mtime); err != nil {
return err
}
if ok {
old = n.Key
_, err = tx.Exec(ctx, "UPDATE s3_nodes SET size = $2, mtime = $3, object_key = $4 WHERE path = $1",
target, size, mtime, key)
return err
}
created = true
_, err = tx.Exec(ctx, `INSERT INTO s3_nodes (path, dir, name, is_dir, size, mtime, object_key, created_by)
VALUES ($1, $2, $3, false, $4, $5, $6, $7)`, target, parentOf(target), path.Base(target), size, mtime, key, o.By)
return err
})
if err != nil {
s.s3RemoveObjects([]string{key})
return Entry{}, err
}
if old != "" {
s.s3RemoveObjects([]string{old})
}
s.removeThumb(target)
s.noteEdit(target, o.By, created)
e := s3Node{Path: target, Name: path.Base(target), Size: size, ModTime: mtime}.entry()
e.EditedBy = o.By
return e, nil
}
func (s *Store) s3Mkdir(c string) (Entry, error) {
if c == "" {
return Entry{}, ErrInvalidPath
}
now := s3Now()
err := s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
if _, ok, err := getNode(ctx, tx, c); err != nil || ok {
if err == nil {
err = ErrExists
}
return err
}
return ensureDirs(ctx, tx, c, now)
})
if err != nil {
return Entry{}, err
}
return Entry{Name: path.Base(c), Path: c, IsDir: true, ModTime: now}, nil
}
// moveTx renomme le sous-arbre from en to dans le catalogue.
func moveTx(ctx context.Context, tx pgx.Tx, from, to string) error {
if _, err := tx.Exec(ctx, `UPDATE s3_nodes SET path = $2 || substr(path, length($1) + 1),
dir = CASE WHEN path = $1 THEN $3 ELSE $2 || substr(dir, length($1) + 1) END,
name = CASE WHEN path = $1 THEN $4 ELSE name END
WHERE `+subtreeWhere, from, to, parentOf(to), path.Base(to)); err != nil {
return err
}
return nil
}
func (s *Store) s3Move(from, to string) (Entry, error) {
if from == "" || to == "" {
return Entry{}, ErrInvalidPath
}
var n s3Node
err := s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
var ok bool
var err error
if n, ok, err = getNode(ctx, tx, from); err != nil || !ok {
if err == nil {
err = ErrNotFound
}
return err
}
if n.IsDir && (to == from || strings.HasPrefix(to, from+"/")) {
return fmt.Errorf("%w : déplacement d'un dossier dans lui-même", ErrInvalidPath)
}
if _, ok, err := getNode(ctx, tx, to); err != nil || ok {
if err == nil {
err = ErrExists
}
return err
}
if err := ensureDirs(ctx, tx, parentOf(to), s3Now()); err != nil {
return err
}
return moveTx(ctx, tx, from, to)
})
if err != nil {
return Entry{}, err
}
s.moveThumb(from, to, n.IsDir)
s.moveMeta(from, to)
s.moveShares(from, to)
n.Path, n.Dir, n.Name = to, parentOf(to), path.Base(to)
e := n.entry()
decorate(&e, s.metaSnapshot())
return e, nil
}
func (s *Store) s3Copy(from, to string) (Entry, error) {
if from == "" || to == "" {
return Entry{}, ErrInvalidPath
}
// Liste des nœuds à copier, puis copie des objets hors transaction.
var nodes []s3Node
err := s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
n, ok, err := getNode(ctx, tx, from)
if err != nil || !ok {
if err == nil {
err = ErrNotFound
}
return err
}
if n.IsDir && (to == from || strings.HasPrefix(to, from+"/")) {
return fmt.Errorf("%w : copie d'un dossier dans lui-même", ErrInvalidPath)
}
if _, ok, err := getNode(ctx, tx, to); err != nil || ok {
if err == nil {
err = ErrExists
}
return err
}
nodes, err = queryNodes(ctx, tx, subtreeWhere+" ORDER BY path", from)
return err
})
if err != nil {
return Entry{}, err
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
newKeys := map[string]string{}
var created []string
for _, n := range nodes {
if n.IsDir || n.Key == "" {
continue
}
k := newObjectKey()
dst := to + strings.TrimPrefix(n.Path, from)
if err := s.s3.objs.Copy(ctx, n.Key, k, map[string]string{"path": url.PathEscape(dst)}); err != nil {
s.s3RemoveObjects(created)
return Entry{}, err
}
newKeys[n.Path] = k
created = append(created, k)
}
now := s3Now()
err = s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
if _, ok, err := getNode(ctx, tx, to); err != nil || ok {
if err == nil {
err = ErrExists
}
return err
}
if err := ensureDirs(ctx, tx, parentOf(to), now); err != nil {
return err
}
for _, n := range nodes {
p := to + strings.TrimPrefix(n.Path, from)
var key *string
if k, ok := newKeys[n.Path]; ok {
key = &k
}
if _, err := tx.Exec(ctx, `INSERT INTO s3_nodes (path, dir, name, is_dir, size, mtime, object_key)
VALUES ($1, $2, $3, $4, $5, $6, $7)`, p, parentOf(p), path.Base(p), n.IsDir, n.Size, n.ModTime, key); err != nil {
return err
}
}
return nil
})
if err != nil {
s.s3RemoveObjects(created)
return Entry{}, err
}
s.copyMeta(from, to)
root := nodes[0]
root.Path, root.Dir, root.Name = to, parentOf(to), path.Base(to)
return root.entry(), nil
}
// s3RemoveObjects supprime des objets ; un échec laisse un orphelin, signalé
// dans le journal (la réconciliation le retrouvera).
func (s *Store) s3RemoveObjects(keys []string) {
if len(keys) == 0 {
return
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
for _, k := range keys {
if err := s.s3.objs.Remove(ctx, k); err != nil {
slog.Warn("s3 : objet non supprimé", "key", k, "err", err)
}
}
}
// deleteTx retire le sous-arbre c du catalogue et renvoie les clés à supprimer.
func deleteTx(ctx context.Context, tx pgx.Tx, c string) ([]string, error) {
rows, err := tx.Query(ctx, "DELETE FROM s3_nodes WHERE "+subtreeWhere+" RETURNING object_key", c)
if err != nil {
return nil, err
}
defer rows.Close()
var keys []string
for rows.Next() {
var k *string
if err := rows.Scan(&k); err != nil {
return nil, err
}
if k != nil {
keys = append(keys, *k)
}
}
return keys, rows.Err()
}
func (s *Store) s3Remove(c string) error {
if c == "" {
return ErrInvalidPath
}
var keys []string
err := s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
if _, ok, err := getNode(ctx, tx, c); err != nil || !ok {
if err == nil {
err = ErrNotFound
}
return err
}
var err error
keys, err = deleteTx(ctx, tx, c)
return err
})
if err != nil {
return err
}
s.s3RemoveObjects(keys)
s.removeThumb(c)
s.removeMeta(c)
s.removeShares(c)
return nil
}
func (s *Store) s3Walk(c string, fn WalkFunc) error {
var nodes []s3Node
err := s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
var err error
if c == "" {
nodes, err = queryNodes(ctx, tx, "NOT starts_with(path, '.') ORDER BY path")
return err
}
if _, ok, err := getNode(ctx, tx, c); err != nil || !ok {
if err == nil {
err = ErrNotFound
}
return err
}
nodes, err = queryNodes(ctx, tx, subtreeWhere+" ORDER BY path", c)
return err
})
if err != nil {
return err
}
if c == "" {
if err := fn("", Entry{IsDir: true}); err != nil {
if errors.Is(err, fs.SkipDir) {
return nil
}
return err
}
}
skip := ""
for _, n := range nodes {
if skip != "" && strings.HasPrefix(n.Path, skip) {
continue
}
if err := fn(n.Path, n.entry()); err != nil {
if errors.Is(err, fs.SkipDir) {
if n.IsDir {
skip = n.Path + "/"
continue
}
return nil
}
return err
}
}
return nil
}
func (s *Store) s3Usage() int64 {
var total int64
_ = s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
return tx.QueryRow(ctx, "SELECT coalesce(sum(size), 0) FROM s3_nodes").Scan(&total)
})
return total
}
// s3Empty indique si le catalogue S3 ne contient aucun élément.
func (s *Store) s3Empty() (bool, error) {
var n int64
err := s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
return tx.QueryRow(ctx, "SELECT count(*) FROM s3_nodes").Scan(&n)
})
return n == 0, err
}
// --- Corbeille -------------------------------------------------------------------
func (s *Store) s3Delete(c string, recursive bool, by string) error {
if c == "" {
return ErrInvalidPath
}
now := time.Now().UTC()
id := now.Format(trashLayout)
var n s3Node
meta := s.takeMeta(c)
err := s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
var ok bool
var err error
if n, ok, err = getNode(ctx, tx, c); err != nil || !ok {
if err == nil {
err = ErrNotFound
}
return err
}
if n.IsDir && !recursive {
var child bool
if err := tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM s3_nodes WHERE dir = $1)", c).Scan(&child); err != nil {
return err
}
if child {
return ErrNotEmpty
}
}
for i := 1; ; i++ { // deux suppressions dans la même nanoseconde
var taken bool
if err := tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM s3_trash WHERE id = $1)", id).Scan(&taken); err != nil {
return err
}
if !taken {
break
}
id = now.Add(time.Duration(i)).Format(trashLayout)
}
var size int64
if err := tx.QueryRow(ctx, "SELECT coalesce(sum(size), 0) FROM s3_nodes WHERE "+subtreeWhere, c).Scan(&size); err != nil {
return err
}
if err := moveTx(ctx, tx, c, s3TrashPrefix+"/"+id+"/"+n.Name); err != nil {
return err
}
_, err = tx.Exec(ctx, `INSERT INTO s3_trash (id, origin, name, is_dir, size, deleted, deleted_by, meta)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, id, c, n.Name, n.IsDir, size, now, by, meta)
return err
})
if err != nil {
s.putMeta(c, meta)
return err
}
s.removeThumb(c)
s.removeShares(c)
return nil
}
func (s *Store) s3TrashItems() ([]TrashItem, error) {
out := []TrashItem{}
err := s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
rows, err := tx.Query(ctx, "SELECT id, origin, name, is_dir, size, deleted, deleted_by FROM s3_trash ORDER BY id DESC")
if err != nil {
return err
}
defer rows.Close()
out = out[:0]
for rows.Next() {
var it TrashItem
if err := rows.Scan(&it.ID, &it.Path, &it.Name, &it.IsDir, &it.Size, &it.Deleted, &it.By); err != nil {
return err
}
it.Deleted = it.Deleted.UTC()
if it.IsDir {
it.Size = 0
}
out = append(out, it)
}
return rows.Err()
})
return out, err
}
func (s *Store) s3TrashCount() int {
var n int
_ = s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
return tx.QueryRow(ctx, "SELECT count(*) FROM s3_trash").Scan(&n)
})
return n
}
func (s *Store) s3RestoreTrash(id string) (Entry, error) {
if !trashID.MatchString(id) {
return Entry{}, fmt.Errorf("%w : élément de corbeille %q", ErrInvalidPath, id)
}
var c string
var meta map[string]itemMeta
var n s3Node
err := s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
var origin, name string
var isDir bool
meta = nil
err := tx.QueryRow(ctx, "SELECT origin, name, is_dir, meta FROM s3_trash WHERE id = $1", id).Scan(&origin, &name, &isDir, &meta)
if errors.Is(err, pgx.ErrNoRows) {
return ErrNotFound
}
if err != nil {
return err
}
if cc, err := Clean(origin); err != nil || cc == "" {
origin = name
}
if c, err = freeNameTx(ctx, tx, origin, isDir, " (restauré %d)"); err != nil {
return err
}
if err := ensureDirs(ctx, tx, parentOf(c), s3Now()); err != nil {
return err
}
src := s3TrashPrefix + "/" + id + "/" + name
var ok bool
if n, ok, err = getNode(ctx, tx, src); err != nil || !ok {
if err == nil {
err = ErrNotFound
}
return err
}
if err := moveTx(ctx, tx, src, c); err != nil {
return err
}
_, err = tx.Exec(ctx, "DELETE FROM s3_trash WHERE id = $1", id)
return err
})
if err != nil {
return Entry{}, err
}
s.putMeta(c, meta)
n.Path, n.Dir, n.Name = c, parentOf(c), path.Base(c)
e := n.entry()
decorate(&e, s.metaSnapshot())
return e, nil
}
// s3DropTrash supprime définitivement des entrées de corbeille (ids nil : toutes
// celles que drop retient).
func (s *Store) s3DropTrash(drop func(id string) bool) error {
var keys []string
err := s.s3.write(func(ctx context.Context, tx pgx.Tx) error {
keys = keys[:0]
rows, err := tx.Query(ctx, "SELECT id FROM s3_trash")
if err != nil {
return err
}
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return err
}
if drop(id) {
ids = append(ids, id)
}
}
rows.Close()
if err := rows.Err(); err != nil {
return err
}
for _, id := range ids {
k, err := deleteTx(ctx, tx, s3TrashPrefix+"/"+id)
if err != nil {
return err
}
keys = append(keys, k...)
if _, err := tx.Exec(ctx, "DELETE FROM s3_trash WHERE id = $1", id); err != nil {
return err
}
}
return nil
})
if err != nil {
return err
}
s.s3RemoveObjects(keys)
return nil
}
// lstat renvoie le chemin nettoyé et la nature d'un élément, sur disque comme
// sur S3 (liens symboliques refusés sur disque).
func (s *Store) lstat(rel string) (string, fs.FileInfo, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return "", nil, err
}
if c == "" {
return "", s3Info{s3Node{IsDir: true}}, nil
}
n, err := s.s3Node(c)
if err != nil {
return "", nil, err
}
return c, s3Info{n}, nil
}
c, abs, err := s.resolve(rel)
if err != nil {
return "", nil, err
}
fi, err := os.Lstat(abs)
if err != nil {
return "", nil, mapErr(err)
}
if fi.Mode()&fs.ModeSymlink != 0 {
return "", nil, ErrNotFound
}
return c, fi, nil
}
// s3DirDetails : comme dirDetails, depuis le catalogue.
func (s *Store) s3DirDetails(c string) (*Details, error) {
es, err := s.s3List(c)
if err != nil {
return nil, err
}
d := &Details{}
for _, e := range es {
if e.IsDir {
d.Dirs++
} else {
d.Files++
}
}
err = s.s3.read(func(ctx context.Context, tx pgx.Tx) error {
var n int64
err := tx.QueryRow(ctx, "SELECT coalesce(sum(size), 0), count(*) FROM s3_nodes WHERE NOT is_dir AND starts_with(path, $1) AND NOT starts_with(path, '.trash/')",
strings.TrimPrefix(c+"/", "/")).Scan(&d.Total, &n)
d.Count = int(n)
return err
})
return d, err
}
+313
View File
@@ -0,0 +1,313 @@
package storage
import (
"bytes"
"context"
"errors"
"io"
"io/fs"
"strings"
"sync"
"testing"
)
// memObjects : stockage objet en mémoire pour les tests.
type memObjects struct {
mu sync.Mutex
objs map[string][]byte
meta map[string]map[string]string
}
func newMemObjects() *memObjects {
return &memObjects{objs: map[string][]byte{}, meta: map[string]map[string]string{}}
}
type memFile struct{ *bytes.Reader }
func (memFile) Close() error { return nil }
func (m *memObjects) Put(_ context.Context, key string, r io.Reader, meta map[string]string) (int64, error) {
b, err := io.ReadAll(r)
if err != nil {
return 0, err
}
m.mu.Lock()
defer m.mu.Unlock()
m.objs[key], m.meta[key] = b, meta
return int64(len(b)), nil
}
func (m *memObjects) Get(_ context.Context, key string) (File, error) {
m.mu.Lock()
defer m.mu.Unlock()
b, ok := m.objs[key]
if !ok {
return nil, ErrNotFound
}
return memFile{bytes.NewReader(b)}, nil
}
func (m *memObjects) Copy(_ context.Context, src, dst string, meta map[string]string) error {
m.mu.Lock()
defer m.mu.Unlock()
b, ok := m.objs[src]
if !ok {
return ErrNotFound
}
m.objs[dst], m.meta[dst] = append([]byte(nil), b...), meta
return nil
}
func (m *memObjects) Remove(_ context.Context, key string) error {
m.mu.Lock()
defer m.mu.Unlock()
delete(m.objs, key)
return nil
}
func (m *memObjects) Empty(context.Context) (bool, error) {
m.mu.Lock()
defer m.mu.Unlock()
return len(m.objs) == 0, nil
}
func (m *memObjects) count() int {
m.mu.Lock()
defer m.mu.Unlock()
return len(m.objs)
}
func newS3Store(t *testing.T) (*Store, *memObjects) {
t.Helper()
db := needCatalog(t)
ctx := context.Background()
if _, err := db.Pool.Exec(ctx, "TRUNCATE s3_nodes, s3_trash, s3_config; DELETE FROM item_meta WHERE root = 's3'; DELETE FROM shares WHERE root = 's3'"); err != nil {
t.Fatal(err)
}
objs := newMemObjects()
s, err := NewS3(t.TempDir(), db, objs)
if err != nil {
t.Fatal(err)
}
return s, objs
}
func readAll(t *testing.T, s *Store, rel string) string {
t.Helper()
f, _, err := s.Open(rel)
if err != nil {
t.Fatal(err)
}
defer f.Close()
b, _ := io.ReadAll(f)
return string(b)
}
func names(es []Entry) string {
var n []string
for _, e := range es {
n = append(n, e.Name)
}
return strings.Join(n, ",")
}
func TestS3RootBasics(t *testing.T) {
s, objs := newS3Store(t)
if _, err := s.Put("a/b/c.txt", strings.NewReader("bonjour"), PutOptions{By: "alice"}); err != nil {
t.Fatal(err)
}
if es, err := s.List(""); err != nil || names(es) != "a" {
t.Fatalf("racine : %v %v", names(es), err)
}
if es, _ := s.List("a/b"); names(es) != "c.txt" || es[0].Size != 7 || es[0].EditedBy != "alice" {
t.Fatalf("a/b : %+v", es)
}
if got := readAll(t, s, "a/b/c.txt"); got != "bonjour" {
t.Fatal(got)
}
// Conflits et remplacement.
if _, err := s.Put("a/b/c.txt", strings.NewReader("x"), PutOptions{}); !errors.Is(err, ErrExists) {
t.Fatal(err)
}
e, err := s.Put("a/b/c.txt", strings.NewReader("x"), PutOptions{Conflict: "rename"})
if err != nil || e.Path != "a/b/c (2).txt" {
t.Fatalf("rename : %v %+v", err, e)
}
_, fi, _ := s.Open("a/b/c.txt")
if _, err := s.Put("a/b/c.txt", strings.NewReader("salut"), PutOptions{Conflict: "overwrite", IfMatch: "faux"}); !errors.Is(err, ErrConflict) {
t.Fatal(err)
}
if _, err := s.Put("a/b/c.txt", strings.NewReader("salut"), PutOptions{Conflict: "overwrite", IfMatch: ETag(fi)}); err != nil {
t.Fatal(err)
}
if got := readAll(t, s, "a/b/c.txt"); got != "salut" || objs.count() != 2 {
t.Fatalf("remplacement : %q, %d objets", got, objs.count())
}
if _, err := s.Put("a/b/c.txt/d", strings.NewReader("x"), PutOptions{}); !errors.Is(err, ErrExists) {
t.Fatalf("fichier en chemin : %v", err)
}
if _, err := s.Put("big", strings.NewReader("0123456789"), PutOptions{Limit: 5}); !errors.Is(err, ErrTooLarge) || objs.count() != 2 {
t.Fatalf("limite : %v, %d objets", err, objs.count())
}
// Tags, déplacement (catalogue seul), copie (objets dupliqués).
if err := s.EditTags([]string{"a/b"}, []string{"Projet"}, nil); err != nil {
t.Fatal(err)
}
if _, err := s.Move("a/b", "x/y"); err != nil {
t.Fatal(err)
}
if _, err := s.Move("x", "x/z"); !errors.Is(err, ErrInvalidPath) {
t.Fatal(err)
}
if e, err := s.Stat("x/y"); err != nil || len(e.Tags) != 1 {
t.Fatalf("tags suivis : %v %+v", err, e)
}
if got := readAll(t, s, "x/y/c.txt"); got != "salut" || objs.count() != 2 {
t.Fatalf("déplacé : %q %d", got, objs.count())
}
if _, err := s.Copy("x", "copie"); err != nil {
t.Fatal(err)
}
if got := readAll(t, s, "copie/y/c (2).txt"); got != "x" || objs.count() != 4 {
t.Fatalf("copie : %q %d", got, objs.count())
}
var walked []string
_ = s.Walk("copie", func(rel string, e Entry) error {
walked = append(walked, rel)
return nil
})
if strings.Join(walked, "|") != "copie|copie/y|copie/y/c (2).txt|copie/y/c.txt" {
t.Fatalf("walk : %q", walked)
}
if s.Usage() != 12 {
t.Errorf("usage : %d", s.Usage())
}
// Corbeille : suppression, restauration, purge.
if err := s.Delete("x", false); !errors.Is(err, ErrNotEmpty) {
t.Fatal(err)
}
if err := s.Delete("x", true); err != nil {
t.Fatal(err)
}
if _, err := s.Stat("x/y/c.txt"); !errors.Is(err, ErrNotFound) {
t.Fatal(err)
}
items, _ := s.TrashItems()
if len(items) != 1 || items[0].Path != "x" || !items[0].IsDir || s.TrashCount() != 1 {
t.Fatalf("corbeille : %+v", items)
}
if es, _ := s.List(""); names(es) != "a,copie" {
t.Fatalf("racine après suppression : %s", names(es))
}
if _, err := s.RestoreTrash(items[0].ID); err != nil {
t.Fatal(err)
}
if e, err := s.Stat("x/y"); err != nil || len(e.Tags) != 1 {
t.Fatalf("restauré : %v %+v", err, e)
}
if err := s.Delete("x", true); err != nil {
t.Fatal(err)
}
if err := s.EmptyTrash(); err != nil {
t.Fatal(err)
}
if objs.count() != 2 || s.TrashCount() != 0 {
t.Fatalf("purge : %d objets", objs.count())
}
if err := s.Remove("copie"); err != nil || objs.count() != 0 {
t.Fatalf("remove : %v %d", err, objs.count())
}
if vs, err := s.Versions("a"); err != nil || len(vs) != 0 {
t.Fatalf("versions : %v", err)
}
}
// Transfert disque -> S3 et S3 -> disque par la fonction commune.
func TestS3Transfer(t *testing.T) {
s3s, _ := newS3Store(t)
disk := newStore(t)
if _, err := disk.Put("d/f.txt", strings.NewReader("disque"), PutOptions{}); err != nil {
t.Fatal(err)
}
if _, err := transfer(disk, "d", s3s, "d", "bob"); err != nil {
t.Fatal(err)
}
if got := readAll(t, s3s, "d/f.txt"); got != "disque" {
t.Fatal(got)
}
if _, err := transfer(s3s, "d", disk, "retour", "bob"); err != nil {
t.Fatal(err)
}
if got := readAll(t, disk, "retour/f.txt"); got != "disque" {
t.Fatal(got)
}
if err := s3s.Walk("absent", func(string, Entry) error { return nil }); !errors.Is(err, ErrNotFound) {
t.Fatal(err)
}
// Walk : SkipDir saute le contenu d'un dossier.
var seen []string
_ = s3s.Walk("", func(rel string, e Entry) error {
seen = append(seen, rel)
if rel == "d" {
return fs.SkipDir
}
return nil
})
if strings.Join(seen, "|") != "|d" {
t.Fatalf("SkipDir : %q", seen)
}
}
func TestS3MetaSharesSearch(t *testing.T) {
s, _ := newS3Store(t)
s.SetShareSecret("0123456789abcdef0123")
if _, err := s.Put("docs/rapport.txt", strings.NewReader("contenu"), PutOptions{}); err != nil {
t.Fatal(err)
}
if err := s.SetIcon([]string{"docs"}, ""); err != nil {
t.Fatal(err)
}
if err := s.SetIcon([]string{"docs/rapport.txt"}, ""); !errors.Is(err, ErrInvalidPath) {
t.Fatalf("icône sur fichier : %v", err)
}
if err := s.EditTags([]string{"docs/rapport.txt"}, []string{"Urgent"}, nil); err != nil {
t.Fatal(err)
}
sh, err := s.CreateShare("docs", ShareOptions{})
if err != nil || !sh.IsDir {
t.Fatalf("partage : %v %+v", err, sh)
}
if _, err := s.ResolveShare(sh.Token); err != nil {
t.Fatal(err)
}
if _, err := s.Move("docs", "archives"); err != nil {
t.Fatal(err)
}
if got, err := s.ResolveShare(sh.Token); err != nil || got.Path != "archives" {
t.Fatalf("partage suivi : %v %+v", err, got)
}
hits, err := s.Search("rapp", Filter{}, 10)
if err != nil || len(hits) != 1 || hits[0].Path != "archives/rapport.txt" {
t.Fatalf("recherche nom : %v %+v", err, hits)
}
if hits, _ := s.Search("contenu", Filter{}, 10); len(hits) != 0 {
t.Fatal("plein texte inattendu sur S3")
}
if hits, _ := s.Search("", Filter{Tag: "urgent"}, 10); len(hits) != 1 {
t.Fatalf("tag : %+v", hits)
}
if d, err := s.dirDetails("archives"); err != nil || d.Files != 1 || d.Total != 7 {
t.Fatalf("détails : %v %+v", err, d)
}
if _, _, _, err := s.Thumb("archives/rapport.txt"); !errors.Is(err, ErrNotFound) {
t.Fatal(err)
}
if _, err := s.Put("img.png", bytes.NewReader(makePNG(300, 200)), PutOptions{}); err != nil {
t.Fatal(err)
}
if b, _, _, err := s.Thumb("img.png"); err != nil || len(b) == 0 {
t.Fatalf("miniature : %v", err)
}
}
+453
View File
@@ -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
}
+89
View File
@@ -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)
}
}
+134
View File
@@ -0,0 +1,134 @@
package storage
import (
"context"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
// S3Config décrit la connexion au bucket (Garage ou tout S3 compatible).
type S3Config struct {
Endpoint string // URL (https://garage:3900) ou hôte:port
Region string // Garage : celle de sa configuration (s3_region), "garage" par défaut
Bucket string
AccessKey string
SecretKey string
Insecure bool // endpoint sans schéma : HTTP au lieu de HTTPS
transport http.RoundTripper // tests
}
// Valid indique si la configuration est complète.
func (c S3Config) Valid() bool {
return c.Endpoint != "" && c.Bucket != "" && c.AccessKey != "" && c.SecretKey != ""
}
// partSize : taille des parties d'un envoi en plusieurs morceaux (mémoire
// tampon par envoi en cours).
const partSize = 16 << 20
type minioObjects struct {
c *minio.Client
bucket string
}
// NewMinioObjects ouvre le bucket décrit par cfg et vérifie qu'il existe.
func NewMinioObjects(ctx context.Context, cfg S3Config) (ObjectStore, error) {
if !cfg.Valid() {
return nil, errors.New("configuration S3 incomplète (endpoint, bucket, clés)")
}
host, secure := cfg.Endpoint, !cfg.Insecure
if u, err := url.Parse(cfg.Endpoint); err == nil && u.Host != "" {
host, secure = u.Host, u.Scheme == "https"
}
region := cfg.Region
if region == "" {
region = "garage"
}
c, err := minio.New(host, &minio.Options{
Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""),
Secure: secure,
Region: region,
BucketLookup: minio.BucketLookupPath, // Garage : style chemin
Transport: cfg.transport,
})
if err != nil {
return nil, err
}
ok, err := c.BucketExists(ctx, cfg.Bucket)
if err != nil {
return nil, fmt.Errorf("bucket %s : %w", cfg.Bucket, err)
}
if !ok {
return nil, fmt.Errorf("bucket %s introuvable", cfg.Bucket)
}
return &minioObjects{c: c, bucket: cfg.Bucket}, nil
}
func (m *minioObjects) Put(ctx context.Context, key string, r io.Reader, meta map[string]string) (int64, error) {
info, err := m.c.PutObject(ctx, m.bucket, key, r, -1, minio.PutObjectOptions{
UserMetadata: meta, PartSize: partSize, ContentType: "application/octet-stream",
})
return info.Size, err
}
// minioFile : objet lu par plages (Seek puis Read relance un GET partiel).
type minioFile struct{ *minio.Object }
func (m *minioObjects) Get(ctx context.Context, key string) (File, error) {
// Le contexte de l'appelant ne borne que l'ouverture : la lecture dure
// autant que le téléchargement.
o, err := m.c.GetObject(context.Background(), m.bucket, key, minio.GetObjectOptions{})
if err != nil {
return nil, err
}
if _, err := o.Stat(); err != nil {
o.Close()
if minio.ToErrorResponse(err).Code == "NoSuchKey" {
return nil, ErrNotFound
}
return nil, err
}
return minioFile{o}, nil
}
func (m *minioObjects) Copy(ctx context.Context, src, dst string, meta map[string]string) error {
dstOpts := minio.CopyDestOptions{Bucket: m.bucket, Object: dst, UserMetadata: meta, ReplaceMetadata: true}
srcOpts := minio.CopySrcOptions{Bucket: m.bucket, Object: src}
info, err := m.c.StatObject(ctx, m.bucket, src, minio.StatObjectOptions{})
if err != nil {
return err
}
if info.Size < 5<<30 { // CopyObject : une requête, jusqu'à 5 Go
_, err = m.c.CopyObject(ctx, dstOpts, srcOpts)
return err
}
// Au-delà : copie par parties (UploadPartCopy, implémenté par Garage).
_, err = m.c.ComposeObject(ctx, dstOpts, srcOpts)
return err
}
func (m *minioObjects) Remove(ctx context.Context, key string) error {
return m.c.RemoveObject(ctx, m.bucket, key, minio.RemoveObjectOptions{})
}
func (m *minioObjects) Empty(ctx context.Context) (bool, error) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
for o := range m.c.ListObjects(ctx, m.bucket, minio.ListObjectsOptions{Recursive: true, MaxKeys: 1}) {
if o.Err != nil {
return false, o.Err
}
if !strings.HasPrefix(o.Key, ".upandown/") {
return false, nil
}
}
return true, nil
}
+138
View File
@@ -0,0 +1,138 @@
package storage
import (
"errors"
"io"
"strings"
"testing"
)
func uread(t *testing.T, u *Space, p string) string {
t.Helper()
f, _, err := u.Open(p)
if err != nil {
t.Fatalf("Open(%s) : %v", p, err)
}
defer f.Close()
b, _ := io.ReadAll(f)
return string(b)
}
func TestSpaceS3Root(t *testing.T) {
s3, _ := newS3Store(t)
sp := newSpaces(t)
sp.SetS3(s3)
alice := space(t, sp, "alice", false)
admin := space(t, sp, "admin", true)
es, err := alice.List("")
if err != nil {
t.Fatal(err)
}
found := false
for _, e := range es {
found = found || (e.Special == "s3" && e.Path == S3Prefix)
}
if !found {
t.Fatalf("entrée S3 absente de la racine : %v", es)
}
e := uput(t, alice, ".s3/docs/a.txt", "AAA")
if e.Path != ".s3/docs/a.txt" {
t.Errorf("chemin virtuel %q", e.Path)
}
if got := uread(t, alice, ".s3/docs/a.txt"); got != "AAA" {
t.Errorf("contenu %q", got)
}
if l, _ := alice.List(".s3/docs"); len(l) != 1 || l[0].Path != ".s3/docs/a.txt" {
t.Errorf("liste .s3/docs : %v", l)
}
// Copie et déplacement entre disque et S3, dans les deux sens.
uput(t, alice, "commun/b.txt", "BB")
if err := alice.EditTags([]string{"commun/b.txt"}, []string{"rouge"}, nil); err != nil {
t.Fatal(err)
}
if _, err := alice.Copy("commun", ".s3/copie"); err != nil {
t.Fatal(err)
}
if got := uread(t, alice, ".s3/copie/b.txt"); got != "BB" {
t.Errorf("copie vers S3 : %q", got)
}
if _, err := alice.Move("commun/b.txt", ".s3/b.txt"); err != nil {
t.Fatal(err)
}
if _, err := alice.Stat("commun/b.txt"); !errors.Is(err, ErrNotFound) {
t.Errorf("original toujours présent : %v", err)
}
st, err := alice.Stat(".s3/b.txt")
if err != nil || len(st.Tags) != 1 || st.Tags[0] != "rouge" {
t.Errorf("tags non repris : %+v %v", st, err)
}
if _, err := alice.Move(".s3/docs", ".perso/docs"); err != nil {
t.Fatal(err)
}
if got := uread(t, alice, ".perso/docs/a.txt"); got != "AAA" {
t.Errorf("S3 → perso : %q", got)
}
if _, err := alice.Stat(".s3/docs"); !errors.Is(err, ErrNotFound) {
t.Errorf("dossier S3 toujours présent : %v", err)
}
if res, err := alice.MoveMany([]string{".perso/docs/a.txt"}, ".s3/copie"); err != nil || res[0].Error != "" {
t.Errorf("MoveMany vers S3 : %v %+v", err, res)
}
// Pas de favoris sur S3.
if err := alice.SetFavorite([]string{".s3/b.txt"}, true); !errors.Is(err, ErrInvalidPath) {
t.Errorf("favori S3 accepté : %v", err)
}
// Poubelle : s-<id>, restauration.
if err := alice.Delete(".s3/b.txt", false); err != nil {
t.Fatal(err)
}
tr, _ := alice.Trash()
var item string
for _, e := range tr {
if strings.HasPrefix(e.Path, TrashPrefix+"/s-") {
item = e.Path
if e.Origin != ".s3/b.txt" {
t.Errorf("origine %q", e.Origin)
}
}
}
if item == "" {
t.Fatalf("élément S3 absent de la poubelle : %v", tr)
}
if r := alice.RestoreTrash([]string{item}); r[0].Error != "" || r[0].To != ".s3/b.txt" {
t.Errorf("restauration : %+v", r)
}
// Partage d'un fichier S3, résolu par Spaces.
sh, err := alice.CreateShare(".s3/b.txt", ShareOptions{})
if err != nil {
t.Fatal(err)
}
if sh.Path != ".s3/b.txt" {
t.Errorf("chemin du partage %q", sh.Path)
}
if _, store, err := sp.ResolveShare(sh.Token); err != nil || store != s3 {
t.Errorf("ResolveShare : %v", err)
}
// Lecture seule : mêmes règles que l'arborescence commune.
if _, err := sp.Main.WriteCommonReadonly(true); err != nil {
t.Fatal(err)
}
if _, err := alice.Put(".s3/x.txt", strings.NewReader("x"), 1, PutOptions{}); !errors.Is(err, ErrForbidden) {
t.Errorf("écriture S3 en lecture seule : %v", err)
}
uput(t, admin, ".s3/x.txt", "x")
// Racine S3 absente : .s3 introuvable.
sp.SetS3(nil)
alice = space(t, sp, "alice", false)
if _, err := alice.List(".s3"); !errors.Is(err, ErrNotFound) {
t.Errorf("sans S3 : %v", err)
}
}
+26
View File
@@ -156,6 +156,32 @@ func (s *Store) Search(q string, f Filter, limit int) ([]Hit, error) {
return []Hit{}, nil
}
meta := s.metaSnapshot()
if s.s3 != nil { // S3 : noms et tags seulement, pas de plein texte
out := []Hit{}
err := s.s3Walk("", func(rel string, e Entry) error {
if rel == "" || len(out) >= limit {
return nil
}
hit := Hit{Entry: e}
decorate(&hit.Entry, meta)
if f.Favorite && !hit.Favorite {
return nil
}
tags := fold(strings.Join(hit.Tags, "\n"))
if tag != "" && !strings.Contains("\n"+tags+"\n", "\n"+tag+"\n") {
return nil
}
name := fold(e.Name) + "\n" + tags
for _, t := range terms {
if !strings.Contains(name, t) {
return nil
}
}
out = append(out, hit)
return nil
})
return out, err
}
s.index.mu.Lock()
defer s.index.mu.Unlock()
if s.index.docs == nil {
+67 -4
View File
@@ -14,11 +14,14 @@ import (
"strconv"
"strings"
"unicode/utf8"
"github.com/vblogio/upandown/internal/catalog"
)
// Paramètres partagés par tous les navigateurs : .settings.json et .logo.png à
// la racine. Les valeurs que l'administrateur n'a pas modifiées viennent des
// variables d'environnement (SettingsDefaults).
// la racine, ou en base quand le catalogue PostgreSQL est branché. Les
// valeurs que l'administrateur n'a pas modifiées viennent des variables
// d'environnement (SettingsDefaults).
const (
settingsFile = ".settings.json"
@@ -131,6 +134,15 @@ type settingsDisk struct {
func (s *Store) readSettingsDisk() (settingsDisk, error) {
var d settingsDisk
if s.cat != nil {
ctx, cancel := ctxOp()
defer cancel()
p, err := catalog.GetDoc[settingsDisk](ctx, s.cat.db, settingsTable, s.cat.settingsID())
if p != nil {
d = *p
}
return d, err
}
b, err := os.ReadFile(filepath.Join(s.root, settingsFile))
switch {
case errors.Is(err, fs.ErrNotExist):
@@ -149,6 +161,24 @@ func (s *Store) readSettingsDisk() (settingsDisk, error) {
func (s *Store) updateSettings(edit func(*settingsDisk)) (Settings, error) {
s.settingsMu.Lock()
defer s.settingsMu.Unlock()
if s.cat != nil {
ctx, cancel := ctxOp()
defer cancel()
id := s.cat.settingsID()
err := catalog.UpdateDocs(ctx, s.cat.db, settingsTable, func(m map[string]*settingsDisk) error {
d := m[id]
if d == nil {
d = &settingsDisk{}
m[id] = d
}
edit(d)
return nil
})
if err != nil {
return Settings{}, err
}
return s.readSettings()
}
d, err := s.readSettingsDisk()
if err != nil {
return Settings{}, err
@@ -212,7 +242,17 @@ func (s *Store) readSettings() (Settings, error) {
st.Preview.Shares = *p.Shares
}
}
if fi, err := os.Stat(filepath.Join(s.root, logoFile)); err == nil {
if s.cat != nil {
ctx, cancel := ctxOp()
defer cancel()
v, err := s.cat.db.BlobVersion(ctx, s.cat.logoKey())
if err != nil {
return Settings{}, err
}
if v != 0 {
st.Logo = strconv.FormatInt(v, 36)
}
} else if fi, err := os.Stat(filepath.Join(s.root, logoFile)); err == nil {
st.Logo = strconv.FormatInt(fi.ModTime().UnixNano(), 36)
}
return st, nil
@@ -325,6 +365,15 @@ func (s *Store) WriteTitle(title string) (Settings, error) {
// ReadLogo renvoie le logo PNG 64x64, ou ErrNotFound.
func (s *Store) ReadLogo() ([]byte, error) {
if s.cat != nil {
ctx, cancel := ctxOp()
defer cancel()
b, _, err := s.cat.db.GetBlob(ctx, s.cat.logoKey())
if err == nil && b == nil {
err = ErrNotFound
}
return b, err
}
b, err := os.ReadFile(filepath.Join(s.root, logoFile))
return b, mapErr(err)
}
@@ -348,7 +397,13 @@ func (s *Store) WriteLogo(data []byte) (Settings, error) {
if err := png.Encode(&buf, squareResize(img, LogoSize)); err != nil {
return Settings{}, err
}
if err := atomicWrite(filepath.Join(s.root, logoFile), buf.Bytes()); err != nil {
if s.cat != nil {
ctx, cancel := ctxOp()
defer cancel()
if err := s.cat.db.PutBlob(ctx, s.cat.logoKey(), buf.Bytes()); err != nil {
return Settings{}, err
}
} else if err := atomicWrite(filepath.Join(s.root, logoFile), buf.Bytes()); err != nil {
return Settings{}, err
}
return s.ReadSettings()
@@ -356,6 +411,14 @@ func (s *Store) WriteLogo(data []byte) (Settings, error) {
// DeleteLogo supprime le logo (sans erreur s'il est absent).
func (s *Store) DeleteLogo() (Settings, error) {
if s.cat != nil {
ctx, cancel := ctxOp()
defer cancel()
if err := s.cat.db.PutBlob(ctx, s.cat.logoKey(), nil); err != nil {
return Settings{}, err
}
return s.ReadSettings()
}
if err := os.Remove(filepath.Join(s.root, logoFile)); err != nil && !errors.Is(err, fs.ErrNotExist) {
return Settings{}, err
}
+38 -8
View File
@@ -70,12 +70,36 @@ type shareDisk struct {
var b64 = base64.RawURLEncoding
// SetShareSecret impose la clé de signature (variable SHARE_SECRET).
func (s *Store) SetShareSecret(secret string) {
// SetShareSecret impose la clé de signature (variable SHARE_SECRET). La
// forme « hex:<clé> » reprend le contenu d'un ancien fichier .share-secret,
// ce qui garde valides les liens déjà diffusés.
func (s *Store) SetShareSecret(secret string) error {
key, err := DecodeSecret(secret)
if err != nil {
return err
}
s.sharesMu.Lock()
defer s.sharesMu.Unlock()
s.shareKey = []byte(secret)
s.shareKey = key
s.fixedKey = true
return nil
}
// DecodeSecret lit une clé fournie par l'environnement : texte brut de 16
// caractères au moins, ou « hex:<clé> » (32 octets au moins) reprise d'un
// fichier de clé généré par Upandown.
func DecodeSecret(secret string) ([]byte, error) {
if h, ok := strings.CutPrefix(secret, "hex:"); ok {
k, err := hex.DecodeString(strings.TrimSpace(h))
if err != nil || len(k) < 32 {
return nil, errors.New("clé hex: invalide (64 caractères hexadécimaux attendus)")
}
return k, nil
}
if len(secret) < 16 {
return nil, errors.New("clé trop courte (16 caractères minimum)")
}
return []byte(secret), nil
}
// key renvoie la clé de signature, créée au besoin ; appelé sous sharesMu.
@@ -127,6 +151,9 @@ func sign(key []byte, id string) string {
}
func (s *Store) readShares() (map[string]shareDisk, error) {
if s.cat != nil {
return s.cat.readShares()
}
out := map[string]shareDisk{}
b, err := os.ReadFile(filepath.Join(s.root, sharesFile))
switch {
@@ -164,6 +191,9 @@ func (s *Store) writeShares(m map[string]shareDisk) error {
func (s *Store) editShares(edit func(map[string]shareDisk) (bool, error)) error {
s.sharesMu.Lock()
defer s.sharesMu.Unlock()
if s.cat != nil {
return s.cat.editShares(edit)
}
m, err := s.readShares()
if err != nil {
return err
@@ -178,7 +208,7 @@ func (s *Store) editShares(edit func(map[string]shareDisk) (bool, error)) error
func (s *Store) toShare(key []byte, id string, d shareDisk) Share {
sh := Share{ID: id, Token: id + "." + sign(key, id), Path: d.Path, Created: d.Created, Expires: d.Expires,
Protected: d.Password != "", Downloads: d.Downloads, pw: d.Password}
if fi, err := os.Stat(absOf(s, d.Path)); err == nil {
if _, fi, err := s.lstat(d.Path); err == nil {
sh.IsDir = fi.IsDir()
}
return sh
@@ -189,15 +219,15 @@ const MaxPasswordLen = 200
// CreateShare crée un lien de partage d'un fichier ou d'un dossier.
func (s *Store) CreateShare(rel string, o ShareOptions) (Share, error) {
c, abs, err := s.resolve(rel)
c, err := Clean(rel)
if err != nil {
return Share{}, err
}
if c == "" {
return Share{}, ErrInvalidPath
}
if fi, err := os.Lstat(abs); err != nil {
return Share{}, mapErr(err)
if _, fi, err := s.lstat(c); err != nil {
return Share{}, err
} else if !fi.IsDir() && !fi.Mode().IsRegular() {
return Share{}, ErrNotFound
}
@@ -236,7 +266,7 @@ func (s *Store) Shares(rel string) ([]Share, error) {
c := ""
if rel != "" {
var err error
if c, _, err = s.resolve(rel); err != nil {
if c, err = Clean(rel); err != nil {
return nil, err
}
}
+213 -66
View File
@@ -13,7 +13,10 @@ import (
"sort"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/vblogio/upandown/internal/catalog"
)
// Espaces personnels et favoris par utilisateur :
@@ -29,6 +32,10 @@ import (
// 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>",
// 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 (
// PersoPrefix est la racine virtuelle de l'espace personnel.
@@ -37,6 +44,8 @@ const (
FavPrefix = ".favoris"
// TrashPrefix est le dossier virtuel de la poubelle.
TrashPrefix = ".poubelle"
// S3Prefix est la racine virtuelle du stockage objet (si configuré).
S3Prefix = ".s3"
usersDir = ".users"
homeName = "home"
@@ -76,9 +85,18 @@ func UserID(raw string) string {
type Spaces struct {
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 int64
// Catalog : catalogue PostgreSQL partagé (nil : métadonnées en fichiers
// JSON). Les espaces personnels y sont rangés sous « home/<id> ».
Catalog *catalog.DB
mu sync.Mutex
homes map[string]*Store
@@ -116,6 +134,11 @@ func (sp *Spaces) home(id string) (*Store, error) {
}
st.History = sp.Main.History
st.keyFrom = sp.Main
if sp.Catalog != nil {
if err := st.UseCatalog(sp.Catalog, "home/"+id); err != nil {
return nil, err
}
}
sp.homes[id] = st
return st, nil
}
@@ -126,7 +149,7 @@ func (sp *Spaces) For(id string, admin bool) (*Space, error) {
if err != nil {
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.
@@ -148,6 +171,11 @@ func (sp *Spaces) ResolveShare(token string) (Share, *Store, error) {
if !errors.Is(err, ErrNotFound) {
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() {
st, herr := sp.home(id)
if herr != nil {
@@ -270,7 +298,8 @@ type Space struct {
sp *Spaces
id string
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.
@@ -295,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)
case c == TrashPrefix || strings.HasPrefix(c, TrashPrefix+"/"):
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
}
// virt traduit un chemin relatif à st en chemin virtuel.
func (u *Space) virt(st *Store, rel string) string {
if st == u.sp.Main {
prefix := PersoPrefix
switch {
case st == u.sp.Main:
return rel
case st == u.s3 && st != nil:
prefix = S3Prefix
}
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.
@@ -387,6 +439,9 @@ func (u *Space) SetFavorite(paths []string, favorite bool) error {
if err != nil {
return err
}
if st.IsS3() {
return fmt.Errorf("%w : pas de favoris sur la racine S3", ErrInvalidPath)
}
c, abs, err := st.resolve(rel)
if err != nil {
return err
@@ -453,13 +508,19 @@ func (u *Space) List(p string) ([]Entry, error) {
return nil, err
}
favs := u.favSet()
out := make([]Entry, 0, len(es)+2)
out := make([]Entry, 0, len(es)+4)
if st == u.sp.Main && isRoot(rel) {
n := 0
for _, s := range u.stores() {
n += s.TrashCount()
}
out = append(out,
Entry{Name: "Favoris", Path: FavPrefix, IsDir: true, Special: "favoris"},
Entry{Name: "Personnel", Path: PersoPrefix, IsDir: true, Special: "perso"},
Entry{Name: "Poubelle", Path: TrashPrefix, IsDir: true, Special: "poubelle",
Count: u.sp.Main.TrashCount() + u.home.TrashCount()})
Entry{Name: "Personnel", Path: PersoPrefix, IsDir: true, Special: "perso"})
if u.s3 != nil {
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 {
out = append(out, u.entry(st, e, favs))
@@ -487,7 +548,7 @@ func (u *Space) Search(q string, f Filter, limit int) ([]Hit, error) {
lim = 1 << 30 // filtrés ensuite
}
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)
if err != nil {
return nil, err
@@ -514,7 +575,7 @@ func (u *Space) Search(q string, f Filter, limit int) ([]Hit, error) {
func (u *Space) Tags() ([]TagCount, error) {
idx := map[string]int{}
out := []TagCount{}
for _, st := range []*Store{u.sp.Main, u.home} {
for _, st := range u.stores() {
ts, err := st.Tags()
if err != nil {
return nil, err
@@ -587,7 +648,7 @@ func (u *Space) canWriteMain() bool {
// writable refuse la modification de l'arborescence commune en lecture seule.
func (u *Space) writable(stores ...*Store) error {
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)
}
}
@@ -603,22 +664,29 @@ func (u *Space) quota() int64 {
return st.QuotaMB << 20
}
// quotaFor vérifie que le contenu de abs (fichier ou dossier) tient dans le
// quota restant de l'espace st, si c'est un espace personnel.
func (u *Space) quotaFor(st *Store, abs string) error {
// quotaFor vérifie que rel de src (fichier ou dossier) tient dans le quota
// restant de l'espace st, si c'est un espace personnel.
func (u *Space) quotaFor(st, src *Store, rel string) error {
q := u.quota()
if st == u.sp.Main || q == 0 {
if u.common(st) || q == 0 {
return nil
}
var size int64
_ = filepath.WalkDir(abs, func(_ string, d fs.DirEntry, err error) error {
if err == nil && d.Type().IsRegular() {
if fi, err := d.Info(); err == nil {
size += fi.Size()
if src.IsS3() {
_ = src.Walk(rel, func(_ string, e Entry) error {
size += e.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 {
return ErrQuota
}
@@ -642,7 +710,7 @@ func (u *Space) Stat(p string) (Entry, error) {
}
// Open ouvre un fichier en lecture (chemin virtuel).
func (u *Space) Open(p string) (*os.File, fs.FileInfo, error) {
func (u *Space) Open(p string) (File, fs.FileInfo, error) {
st, rel, err := u.route(p)
if err != nil {
return nil, nil, err
@@ -663,7 +731,7 @@ func (u *Space) Put(p string, r io.Reader, size int64, o PutOptions) (Entry, err
}
o.By = u.id
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()
if rem <= 0 {
return Entry{}, ErrQuota
@@ -709,10 +777,15 @@ func (u *Space) Move(from, to string) (Entry, error) {
return Entry{}, err
}
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
}
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
}
cf, _ := Clean(rf)
@@ -767,6 +840,36 @@ func (sp *Spaces) moveAcross(src *Store, from string, dst *Store, to string) (En
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).
func moveAside(src, dst string) {
if _, err := os.Stat(src); err != nil {
@@ -784,14 +887,10 @@ func (u *Space) MoveMany(paths []string, dir string) ([]MoveResult, error) {
if err != nil {
return nil, err
}
cd, ad, err := sd.resolve(rd)
cd, fi, err := sd.statDir(rd)
if err != nil {
return nil, err
}
fi, err := os.Stat(ad)
if err != nil {
return nil, mapErr(err)
}
if !fi.IsDir() {
return nil, fmt.Errorf("%w : la destination n'est pas un dossier", ErrInvalidPath)
}
@@ -838,20 +937,27 @@ func (u *Space) Copy(from, to string) (Entry, error) {
if err := u.writable(st); err != nil {
return Entry{}, err
}
cf, af, err := sf.resolve(rf)
cf, _, err := sf.lstat(rf)
if err != nil {
return Entry{}, err
}
if cf == "" {
return Entry{}, ErrInvalidPath
}
if err := u.quotaFor(st, af); err != nil {
if err := u.quotaFor(st, sf, rf); err != nil {
return Entry{}, err
}
af := absOf(sf, cf)
var e Entry
if sf == st {
switch {
case sf == st:
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)
if rerr != nil {
return Entry{}, rerr
@@ -910,6 +1016,9 @@ func (u *Space) Delete(p string, recursive bool) error {
if err := u.writable(st); err != nil {
return err
}
if st.IsS3() {
return st.deleteAs(rel, recursive, u.id)
}
_, abs, err := st.resolve(rel)
if err != nil {
return err
@@ -939,7 +1048,7 @@ func (u *Space) Versions(p string) ([]Version, error) {
}
// OpenVersion ouvre une version d'un fichier en lecture.
func (u *Space) OpenVersion(p, id string) (*os.File, fs.FileInfo, error) {
func (u *Space) OpenVersion(p, id string) (File, fs.FileInfo, error) {
st, rel, err := u.route(p)
if err != nil {
return nil, nil, err
@@ -977,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
// commune et espace personnel) si p est vide.
func (u *Space) Shares(p string) ([]Share, error) {
stores := []*Store{u.sp.Main, u.home}
stores := u.stores()
rel := ""
if p != "" {
st, r, err := u.route(p)
@@ -1013,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.
func (u *Space) RevokeShare(id string) error {
err := u.sp.Main.RevokeShare(id)
if errors.Is(err, ErrNotFound) {
err = u.home.RevokeShare(id)
var err error
for _, st := range u.stores() {
if st.IsS3() && !u.canWriteMain() {
continue
}
if err = st.RevokeShare(id); !errors.Is(err, ErrNotFound) {
return err
}
}
return err
}
@@ -1029,6 +1143,11 @@ func (u *Space) RevokeAllShares() error {
if err := u.sp.Main.RevokeAllShares(); err != nil {
return err
}
if u.s3 != nil {
if err := u.s3.RevokeAllShares(); err != nil {
return err
}
}
for _, id := range u.sp.users() {
if st, err := u.sp.home(id); err == nil {
if err := st.RevokeAllShares(); err != nil {
@@ -1044,21 +1163,17 @@ func (u *Space) RevokeAllShares() error {
// takeMeta retire et renvoie les métadonnées de c et de son contenu (clés
// relatives à c).
func (s *Store) takeMeta(c string) map[string]itemMeta {
s.metaMu.Lock()
defer s.metaMu.Unlock()
if s.loadMeta() != nil {
return nil
}
out := map[string]itemMeta{}
for k, m := range s.meta {
if under(k, c) {
out[k[len(c):]] = m
delete(s.meta, k)
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
clear(out)
for k, m := range meta {
if under(k, c) {
out[k[len(c):]] = m
delete(meta, k)
}
}
}
if len(out) > 0 {
_ = s.saveMeta()
}
return len(out) > 0, nil
})
return out
}
@@ -1066,15 +1181,12 @@ func (s *Store) putMeta(c string, m map[string]itemMeta) {
if len(m) == 0 {
return
}
s.metaMu.Lock()
defer s.metaMu.Unlock()
if s.loadMeta() != nil {
return
}
for suffix, v := range m {
s.meta[c+suffix] = v
}
_ = s.saveMeta()
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
for suffix, v := range m {
meta[c+suffix] = v
}
return true, nil
})
}
func (s *Store) takeShares(c string) map[string]shareDisk {
@@ -1107,7 +1219,7 @@ func (s *Store) putShares(c string, add map[string]shareDisk) {
// --- 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) {
key, ok := strings.CutPrefix(cleanVirtual(p), TrashPrefix+"/")
if !ok {
@@ -1118,6 +1230,8 @@ func (u *Space) trashItem(p string) (*Store, string, bool) {
return u.sp.Main, key[2:], true
case strings.HasPrefix(key, "p-"):
return u.home, key[2:], true
case strings.HasPrefix(key, "s-") && u.s3 != nil:
return u.s3, key[2:], true
}
return nil, "", false
}
@@ -1127,14 +1241,17 @@ func (u *Space) trashItem(p string) (*Store, string, bool) {
// suppression, Origin le chemin d'origine.
func (u *Space) Trash() ([]Entry, error) {
out := []Entry{}
for _, st := range []*Store{u.sp.Main, u.home} {
for _, st := range u.stores() {
items, err := st.TrashItems()
if err != nil {
return nil, err
}
prefix := "c-"
if st == u.home {
switch {
case st == u.home:
prefix = "p-"
case st.IsS3():
prefix = "s-"
}
for _, it := range items {
out = append(out, Entry{
@@ -1178,6 +1295,9 @@ func (u *Space) EmptyTrash() error {
errs := []error{u.home.EmptyTrash()}
if u.canWriteMain() {
errs = append(errs, u.sp.Main.EmptyTrash())
if u.s3 != nil {
errs = append(errs, u.s3.EmptyTrash())
}
}
return errors.Join(errs...)
}
@@ -1206,6 +1326,9 @@ func (sp *Spaces) PurgeTrash() error {
}
maxAge := time.Duration(st.TrashDays) * 24 * time.Hour
errs := []error{sp.Main.PurgeTrashOlder(maxAge)}
if s3 := sp.s3.Load(); s3 != nil {
errs = append(errs, s3.PurgeTrashOlder(maxAge))
}
for _, id := range sp.users() {
h, err := sp.home(id)
if err == nil {
@@ -1237,3 +1360,27 @@ func (sp *Spaces) RetireUser(id string) error {
}
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
}
+72 -8
View File
@@ -17,7 +17,6 @@ import (
"os"
"path"
"path/filepath"
"sort"
"strconv"
"strings"
"sync"
@@ -87,6 +86,7 @@ type Store struct {
thumbSem chan struct{}
metaMu sync.Mutex // tags, favoris, auteurs (meta.go)
cat *catalogRef // catalogue PostgreSQL (catalog.go) ; nil : fichiers JSON
meta map[string]itemMeta // nil : pas encore chargé
sharesMu sync.Mutex // liens de partage (share.go)
@@ -94,6 +94,8 @@ type Store struct {
fixedKey bool // clé imposée par SHARE_SECRET
keyFrom *Store // espace personnel : clé de signature du Store principal
s3 *s3Root // racine S3 (s3.go) ; nil : disque
usageMu sync.Mutex
usageAt time.Time
usageSize int64
@@ -209,6 +211,13 @@ func visible(name string) bool { return !strings.HasPrefix(name, ".") }
// List renvoie le contenu d'un dossier : dossiers d'abord, puis fichiers,
// triés par nom (insensible à la casse).
func (s *Store) List(rel string) ([]Entry, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return nil, err
}
return s.s3List(c)
}
c, abs, err := s.resolve(rel)
if err != nil {
return nil, err
@@ -237,17 +246,19 @@ func (s *Store) List(rel string) ([]Entry, error) {
decorate(&e, meta)
out = append(out, e)
}
sort.Slice(out, func(i, j int) bool {
if out[i].IsDir != out[j].IsDir {
return out[i].IsDir
}
return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
})
sortEntries(out)
return out, nil
}
// Stat décrit un fichier ou un dossier.
func (s *Store) Stat(rel string) (Entry, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return Entry{}, err
}
return s.s3Stat(c)
}
c, abs, err := s.resolve(rel)
if err != nil {
return Entry{}, err
@@ -270,7 +281,14 @@ func ETag(fi fs.FileInfo) string {
}
// Open ouvre un fichier en lecture. Les liens symboliques sont refusés.
func (s *Store) Open(rel string) (*os.File, fs.FileInfo, error) {
func (s *Store) Open(rel string) (File, fs.FileInfo, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return nil, nil, err
}
return s.s3Open(c)
}
c, abs, err := s.resolve(rel)
if err != nil {
return nil, nil, err
@@ -319,6 +337,13 @@ type PutOptions struct {
// dossiers parents sont créés. Renvoie l'entrée écrite (son chemin peut
// différer de rel avec Conflict = "rename").
func (s *Store) Put(rel string, r io.Reader, o PutOptions) (Entry, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return Entry{}, err
}
return s.s3Put(c, r, o)
}
c, abs, err := s.resolve(rel)
if err != nil {
return Entry{}, err
@@ -413,6 +438,13 @@ func (s *Store) Put(rel string, r io.Reader, o PutOptions) (Entry, error) {
// Mkdir crée un dossier (et ses parents).
func (s *Store) Mkdir(rel string) (Entry, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return Entry{}, err
}
return s.s3Mkdir(c)
}
c, abs, err := s.resolve(rel)
if err != nil {
return Entry{}, err
@@ -439,6 +471,17 @@ func (s *Store) Mkdir(rel string) (Entry, error) {
// Move renomme ou déplace un fichier ou un dossier. La destination ne doit
// pas exister ; un dossier ne peut pas être déplacé dans lui-même.
func (s *Store) Move(from, to string) (Entry, error) {
if s.s3 != nil {
cf, err := Clean(from)
if err != nil {
return Entry{}, err
}
ct, err := Clean(to)
if err != nil {
return Entry{}, err
}
return s.s3Move(cf, ct)
}
cf, af, err := s.resolve(from)
if err != nil {
return Entry{}, err
@@ -496,6 +539,17 @@ func (r MoveResult) Err() error { return r.err }
// Copy duplique un fichier, ou un dossier avec tout son contenu (fichiers
// réguliers seulement). Les tags sont copiés, pas les favoris ni les partages.
func (s *Store) Copy(from, to string) (Entry, error) {
if s.s3 != nil {
cf, err := Clean(from)
if err != nil {
return Entry{}, err
}
ct, err := Clean(to)
if err != nil {
return Entry{}, err
}
return s.s3Copy(cf, ct)
}
cf, af, err := s.resolve(from)
if err != nil {
return Entry{}, err
@@ -597,6 +651,13 @@ func (s *Store) Delete(rel string, recursive bool) error {
// deleteAs est Delete en notant l'auteur de la suppression (by).
func (s *Store) deleteAs(rel string, recursive bool, by string) error {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return err
}
return s.s3Delete(c, recursive, by)
}
c, abs, err := s.resolve(rel)
if err != nil {
return err
@@ -659,6 +720,9 @@ func (s *Store) usageDirty() {
// compris ; miniatures exclues). Le résultat est gardé 15 s, ou jusqu'à la
// prochaine écriture.
func (s *Store) Usage() int64 {
if s.s3 != nil {
return s.s3Usage()
}
s.usageMu.Lock()
defer s.usageMu.Unlock()
if time.Since(s.usageAt) < 15*time.Second {
+1
View File
@@ -21,6 +21,7 @@ func newStore(t *testing.T) *Store {
if err != nil {
t.Fatal(err)
}
attachTestCatalog(t, s)
return s
}
+9 -13
View File
@@ -53,15 +53,11 @@ func (s *Store) thumbAbs(c string, isDir bool) string {
// type MIME et sa date. ErrNotFound si le fichier n'est pas une image
// décodable.
func (s *Store) Thumb(rel string) ([]byte, string, time.Time, error) {
c, abs, err := s.resolve(rel)
c, src, err := s.lstat(rel)
if err != nil {
return nil, "", time.Time{}, err
}
if c == "" || !isDecodableImage(c) {
return nil, "", time.Time{}, ErrNotFound
}
src, err := os.Lstat(abs)
if err != nil || !src.Mode().IsRegular() {
if c == "" || !isDecodableImage(c) || !src.Mode().IsRegular() {
return nil, "", time.Time{}, ErrNotFound
}
ta := s.thumbAbs(c, false)
@@ -75,7 +71,12 @@ func (s *Store) Thumb(rel string) ([]byte, string, time.Time, error) {
}
s.thumbSem <- struct{}{}
defer func() { <-s.thumbSem }()
b, err := makeThumb(abs)
f, _, err := s.Open(c)
if err != nil {
return nil, "", time.Time{}, ErrNotFound
}
b, err := makeThumb(f)
f.Close()
if err != nil {
return nil, "", time.Time{}, ErrNotFound
}
@@ -92,12 +93,7 @@ func sniffThumb(b []byte) string {
return "image/jpeg"
}
func makeThumb(abs string) ([]byte, error) {
f, err := os.Open(abs)
if err != nil {
return nil, err
}
defer f.Close()
func makeThumb(f io.ReadSeeker) ([]byte, error) {
cfg, format, err := image.DecodeConfig(f)
if err != nil {
return nil, err
+18
View File
@@ -114,6 +114,9 @@ func (s *Store) trashEntry(id string) (string, trashInfo, error) {
// TrashItems liste la corbeille, les suppressions les plus récentes en premier.
func (s *Store) TrashItems() ([]TrashItem, error) {
if s.s3 != nil {
return s.s3TrashItems()
}
des, err := os.ReadDir(filepath.Join(s.root, trashDir))
if errors.Is(err, fs.ErrNotExist) {
return []TrashItem{}, nil
@@ -146,6 +149,9 @@ func (s *Store) TrashItems() ([]TrashItem, error) {
// TrashCount renvoie le nombre d'éléments dans la corbeille.
func (s *Store) TrashCount() int {
if s.s3 != nil {
return s.s3TrashCount()
}
des, _ := os.ReadDir(filepath.Join(s.root, trashDir))
n := 0
for _, de := range des {
@@ -159,6 +165,9 @@ func (s *Store) TrashCount() int {
// RestoreTrash remet un élément à son emplacement d'origine (dossiers parents
// recréés au besoin), sous un autre nom si la place est prise.
func (s *Store) RestoreTrash(id string) (Entry, error) {
if s.s3 != nil {
return s.s3RestoreTrash(id)
}
name, info, err := s.trashEntry(id)
if err != nil {
return Entry{}, err
@@ -193,6 +202,12 @@ func (s *Store) RestoreTrash(id string) (Entry, error) {
// DropTrash supprime définitivement un élément de la corbeille.
func (s *Store) DropTrash(id string) error {
if s.s3 != nil {
if !trashID.MatchString(id) {
return fmt.Errorf("%w : élément de corbeille %q", ErrInvalidPath, id)
}
return s.s3DropTrash(func(i string) bool { return i == id })
}
if _, _, err := s.trashEntry(id); err != nil {
return err
}
@@ -214,6 +229,9 @@ func (s *Store) PurgeTrashOlder(maxAge time.Duration) error {
}
func (s *Store) purgeTrash(drop func(id string) bool) error {
if s.s3 != nil {
return s.s3DropTrash(drop)
}
root := filepath.Join(s.root, trashDir)
des, err := os.ReadDir(root)
if errors.Is(err, fs.ErrNotExist) {
+27 -68
View File
@@ -2,23 +2,22 @@ package storage
import (
"archive/zip"
"errors"
"fmt"
"io"
"io/fs"
"os"
"path"
"path/filepath"
"strings"
)
// Téléchargement d'un dossier ou d'une sélection en archive ZIP, générée en
// flux (aucun fichier temporaire, mémoire constante).
// ZipItem est un fichier ou un dossier à archiver : Abs est son chemin sur le
// disque, Name son nom dans l'archive.
// ZipItem est un fichier ou un dossier à archiver : Rel est son chemin dans
// la racine Root, Name son nom dans l'archive.
type ZipItem struct {
Abs string
Name string
Root Root `json:"-"`
Rel string `json:"rel"`
Name string `json:"name"`
}
// compressed : extensions déjà compressées, stockées sans recompression.
@@ -44,22 +43,15 @@ func (u *Space) ZipItems(paths []string) ([]ZipItem, string, error) {
if err != nil {
return nil, "", err
}
c, abs, err := st.resolve(rel)
e, err := st.Stat(rel)
if err != nil {
return nil, "", err
}
name := path.Base(c)
if c == "" {
name := path.Base(e.Path)
if e.Path == "" {
name = "fichiers" // racine de l'espace personnel
}
fi, err := os.Lstat(abs)
if err != nil {
return nil, "", mapErr(err)
}
if !fi.IsDir() && !fi.Mode().IsRegular() {
return nil, "", ErrNotFound
}
items = append(items, ZipItem{Abs: abs, Name: uniqueZipName(name, used)})
items = append(items, ZipItem{Root: st, Rel: e.Path, Name: uniqueZipName(name, used)})
}
archive := "fichiers"
if len(items) == 1 {
@@ -81,82 +73,49 @@ func uniqueZipName(name string, used map[string]bool) string {
// SharedZipItem renvoie l'élément d'un lien de partage (ou d'un de ses
// sous-dossiers) à archiver.
func (s *Store) SharedZipItem(rel string) (ZipItem, error) {
c, abs, err := s.resolve(rel)
e, err := s.Stat(rel)
if err != nil {
return ZipItem{}, err
}
if _, err := os.Lstat(abs); err != nil {
return ZipItem{}, mapErr(err)
}
return ZipItem{Abs: abs, Name: path.Base(c)}, nil
return ZipItem{Root: s, Rel: e.Path, Name: path.Base(e.Path)}, nil
}
// WriteZip écrit les éléments dans w au format ZIP. Les liens symboliques, les
// fichiers spéciaux et les fichiers internes (noms cachés) sont ignorés ; un
// fichier illisible est sauté sans interrompre l'archive.
// WriteZip écrit les éléments dans w au format ZIP, en flux. Les liens
// symboliques, les fichiers spéciaux et les fichiers internes (noms cachés)
// sont ignorés ; un fichier illisible est sauté sans interrompre l'archive.
func WriteZip(w io.Writer, items []ZipItem) error {
zw := zip.NewWriter(w)
for _, it := range items {
fi, err := os.Lstat(it.Abs)
if err != nil {
continue
}
if !fi.IsDir() {
if err := addZipFile(zw, it.Abs, it.Name, fi); err != nil {
return err
}
continue
}
err = filepath.WalkDir(it.Abs, func(p string, d fs.DirEntry, err error) error {
if err != nil {
return nil
}
if p != it.Abs && !visible(d.Name()) {
if d.IsDir() {
return filepath.SkipDir
}
return nil
}
rel, _ := filepath.Rel(it.Abs, p)
base := it.Rel
err := it.Root.Walk(it.Rel, func(rel string, e Entry) error {
name := it.Name
if rel != "." {
name = path.Join(it.Name, filepath.ToSlash(rel))
if rel != base {
name = path.Join(it.Name, strings.TrimPrefix(strings.TrimPrefix(rel, base), "/"))
}
switch {
case d.IsDir():
h := &zip.FileHeader{Name: name + "/", Method: zip.Store}
if info, err := d.Info(); err == nil {
h.Modified = info.ModTime()
}
_, err := zw.CreateHeader(h)
if e.IsDir {
_, err := zw.CreateHeader(&zip.FileHeader{Name: name + "/", Method: zip.Store, Modified: e.ModTime})
return err
case d.Type().IsRegular():
info, err := d.Info()
if err != nil {
return nil
}
return addZipFile(zw, p, name, info)
}
return nil
return addZipFile(zw, it.Root, rel, name, e)
})
if err != nil {
if err != nil && !errors.Is(err, ErrNotFound) {
return err
}
}
return zw.Close()
}
func addZipFile(zw *zip.Writer, abs, name string, fi fs.FileInfo) error {
f, err := os.Open(abs)
func addZipFile(zw *zip.Writer, root Root, rel, name string, e Entry) error {
f, _, err := root.Open(rel)
if err != nil {
return nil // fichier illisible : sauté
}
defer f.Close()
h := &zip.FileHeader{Name: name, Method: zip.Deflate, Modified: fi.ModTime()}
h := &zip.FileHeader{Name: name, Method: zip.Deflate, Modified: e.ModTime}
if compressed[strings.ToLower(path.Ext(name))] {
h.Method = zip.Store
}
h.UncompressedSize64 = uint64(fi.Size())
h.UncompressedSize64 = uint64(e.Size)
out, err := zw.CreateHeader(h)
if err != nil {
return err
+170 -49
View File
@@ -4,8 +4,9 @@
// sans session de navigateur.
//
// Les jetons ne sont conservés que hachés (SHA-256) dans DATA_DIR/.tokens.json
// (0600), rattachés à l'utilisateur qui les a créés : ils donnent accès à ses
// fichiers comme sa session, mais ne peuvent pas gérer les jetons ni les comptes.
// (0600) ou dans le catalogue PostgreSQL, rattachés à l'utilisateur qui les a
// créés : ils donnent accès à ses fichiers comme sa session, mais ne peuvent
// pas gérer les jetons ni les comptes.
package tokens
import (
@@ -16,6 +17,8 @@ import (
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"log/slog"
"net/http"
"os"
"path/filepath"
@@ -25,7 +28,9 @@ import (
"time"
"unicode/utf8"
"github.com/jackc/pgx/v5"
"github.com/vblogio/upandown/internal/auth"
"github.com/vblogio/upandown/internal/catalog"
)
const (
@@ -64,35 +69,129 @@ func (t *Token) info() Info {
return Info{ID: t.ID, Name: t.Name, Created: t.Created, LastUsed: t.LastUsed}
}
// Store conserve les jetons dans dir/.tokens.json.
// Store conserve les jetons dans dir/.tokens.json, ou dans la table tokens du
// catalogue PostgreSQL (UseCatalog), partagée par toutes les instances.
type Store struct {
mu sync.Mutex
file string
tokens []*Token
tokens map[string]*Token // mode fichier, par ID
db *catalog.DB // mode catalogue
}
const (
table = "tokens"
dbTimeout = 30 * time.Second
)
// Open charge (ou crée) le fichier des jetons de dir.
func Open(dir string) (*Store, error) {
s := &Store{file: filepath.Join(dir, fileName)}
s := &Store{file: filepath.Join(dir, fileName), tokens: map[string]*Token{}}
b, err := os.ReadFile(s.file)
switch {
case errors.Is(err, os.ErrNotExist):
case err != nil:
return nil, err
default:
var d struct {
Tokens []*Token `json:"tokens"`
}
if err := json.Unmarshal(b, &d); err != nil {
list, err := decode(b)
if err != nil {
return nil, errors.New(s.file + " invalide : " + err.Error())
}
s.tokens = d.Tokens
s.tokens = list
}
return s, nil
}
func (s *Store) save() error {
b, err := json.Marshal(map[string]any{"tokens": s.tokens})
func decode(b []byte) (map[string]*Token, error) {
var d struct {
Tokens []*Token `json:"tokens"`
}
if err := json.Unmarshal(b, &d); err != nil {
return nil, err
}
m := make(map[string]*Token, len(d.Tokens))
for _, t := range d.Tokens {
m[t.ID] = t
}
return m, nil
}
// UseCatalog range désormais les jetons dans le catalogue ; .tokens.json est
// repris une seule fois puis renommé en .tokens.json.imported. À appeler au
// démarrage, avant de servir des requêtes.
func (s *Store) UseCatalog(db *catalog.DB) error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
err := db.ImportFileOnce(ctx, "global", "tokens", s.file, func(ctx context.Context, tx pgx.Tx, b []byte) error {
m, err := decode(b)
if err != nil {
return err
}
return catalog.InsertDocs(ctx, tx, table, m)
})
if err != nil {
return fmt.Errorf("reprise des jetons : %w", err)
}
s.mu.Lock()
s.db, s.tokens = db, nil
s.mu.Unlock()
return nil
}
// snapshot renvoie une copie de tous les jetons.
func (s *Store) snapshot() (map[string]*Token, error) {
if s.db != nil {
ctx, cancel := context.WithTimeout(context.Background(), dbTimeout)
defer cancel()
return catalog.AllDocs[Token](ctx, s.db, table)
}
s.mu.Lock()
defer s.mu.Unlock()
return clone(s.tokens), nil
}
// update applique fn à tous les jetons, de façon atomique (rien n'est
// enregistré si fn échoue).
func (s *Store) update(fn func(map[string]*Token) error) error {
if s.db != nil {
ctx, cancel := context.WithTimeout(context.Background(), dbTimeout)
defer cancel()
return catalog.UpdateDocs(ctx, s.db, table, fn)
}
s.mu.Lock()
defer s.mu.Unlock()
next := clone(s.tokens)
if err := fn(next); err != nil {
return err
}
if err := s.save(next); err != nil {
return err
}
s.tokens = next
return nil
}
func clone(m map[string]*Token) map[string]*Token {
out := make(map[string]*Token, len(m))
for id, t := range m {
c := *t
out[id] = &c
}
return out
}
// save écrit le fichier ; appelé sous mu.
func (s *Store) save(m map[string]*Token) error {
list := make([]*Token, 0, len(m))
for _, t := range m {
list = append(list, t)
}
sort.Slice(list, func(i, j int) bool {
if !list[i].Created.Equal(list[j].Created) {
return list[i].Created.Before(list[j].Created)
}
return list[i].ID < list[j].ID
})
b, err := json.Marshal(map[string]any{"tokens": list})
if err != nil {
return err
}
@@ -132,22 +231,23 @@ func (s *Store) Create(userID, name string) (string, Info, error) {
if name == "" || !utf8.ValidString(name) || utf8.RuneCountInString(name) > MaxNameLen {
return "", Info{}, ErrInvalid
}
s.mu.Lock()
defer s.mu.Unlock()
n := 0
for _, t := range s.tokens {
if t.UserID == userID {
n++
}
}
if n >= maxPerUser {
return "", Info{}, ErrTooMany
}
secret := prefix + randomString(32)
t := &Token{ID: randomString(9), Name: name, UserID: userID, Hash: hashOf(secret), Created: time.Now().UTC().Truncate(time.Second)}
s.tokens = append(s.tokens, t)
if err := s.save(); err != nil {
s.tokens = s.tokens[:len(s.tokens)-1]
err := s.update(func(m map[string]*Token) error {
n := 0
for _, o := range m {
if o.UserID == userID {
n++
}
}
if n >= maxPerUser {
return ErrTooMany
}
c := *t
m[t.ID] = &c
return nil
})
if err != nil {
return "", Info{}, err
}
return secret, t.info(), nil
@@ -155,10 +255,12 @@ func (s *Store) Create(userID, name string) (string, Info, error) {
// List renvoie les jetons de userID, les plus récents en premier.
func (s *Store) List(userID string) []Info {
s.mu.Lock()
defer s.mu.Unlock()
m, err := s.snapshot()
if err != nil {
slog.Error("jetons : lecture", "err", err)
}
out := []Info{}
for _, t := range s.tokens {
for _, t := range m {
if t.UserID == userID {
out = append(out, t.info())
}
@@ -169,30 +271,27 @@ func (s *Store) List(userID string) []Info {
// Revoke supprime un jeton de userID.
func (s *Store) Revoke(userID, id string) error {
s.mu.Lock()
defer s.mu.Unlock()
for i, t := range s.tokens {
if t.ID == id && t.UserID == userID {
s.tokens = append(s.tokens[:i:i], s.tokens[i+1:]...)
return s.save()
return s.update(func(m map[string]*Token) error {
if t, ok := m[id]; !ok || t.UserID != userID {
return ErrNotFound
}
}
return ErrNotFound
delete(m, id)
return nil
})
}
// RevokeUser supprime tous les jetons d'un utilisateur (compte supprimé ou désactivé).
func (s *Store) RevokeUser(userID string) {
s.mu.Lock()
defer s.mu.Unlock()
kept := s.tokens[:0:0]
for _, t := range s.tokens {
if t.UserID != userID {
kept = append(kept, t)
err := s.update(func(m map[string]*Token) error {
for id, t := range m {
if t.UserID == userID {
delete(m, id)
}
}
}
if len(kept) != len(s.tokens) {
s.tokens = kept
_ = s.save()
return nil
})
if err != nil {
slog.Error("jetons : révocation", "user", userID, "err", err)
}
}
@@ -202,13 +301,35 @@ func (s *Store) Lookup(secret string) (Token, bool) {
return Token{}, false
}
h := hashOf(secret)
if s.db != nil {
ctx, cancel := context.WithTimeout(context.Background(), dbTimeout)
defer cancel()
t, err := catalog.FindDoc[Token](ctx, s.db, table, "hash", h)
if err != nil {
slog.Error("jetons : lecture", "err", err)
}
if t == nil {
return Token{}, false
}
if time.Since(t.LastUsed) > touchEvery {
t.LastUsed = time.Now().UTC().Truncate(time.Second)
if err := catalog.ReplaceDoc(ctx, s.db, table, t.ID, t); err != nil {
slog.Warn("jetons : date d'utilisation non enregistrée", "err", err)
}
}
return *t, true
}
s.mu.Lock()
defer s.mu.Unlock()
for _, t := range s.tokens {
if t.Hash == h {
if time.Since(t.LastUsed) > touchEvery {
t.LastUsed = time.Now().UTC().Truncate(time.Second)
_ = s.save()
next := clone(s.tokens)
next[t.ID].LastUsed = time.Now().UTC().Truncate(time.Second)
if s.save(next) == nil {
s.tokens = next
t = next[t.ID]
}
}
return *t, true
}
+96
View File
@@ -0,0 +1,96 @@
package tokens
import (
"context"
"errors"
"os"
"path/filepath"
"testing"
"time"
"github.com/vblogio/upandown/internal/catalog"
)
func TestFileStore(t *testing.T) {
dir := t.TempDir()
s, err := Open(dir)
if err != nil {
t.Fatal(err)
}
secret, info, err := s.Create("alice", "script")
if err != nil {
t.Fatal(err)
}
s2, err := Open(dir)
if err != nil {
t.Fatal(err)
}
if tok, ok := s2.Lookup(secret); !ok || tok.ID != info.ID || tok.LastUsed.IsZero() {
t.Fatalf("rechargement : %v %+v", ok, tok)
}
if err := s2.Revoke("bob", info.ID); !errors.Is(err, ErrNotFound) {
t.Fatalf("révocation par un autre : %v", err)
}
s2.RevokeUser("alice")
if _, ok := s2.Lookup(secret); ok {
t.Error("jeton révoqué encore valide")
}
}
func TestCatalogStoreShared(t *testing.T) {
dsn := os.Getenv("UPANDOWN_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("UPANDOWN_TEST_DATABASE_URL non défini")
}
ctx := context.Background()
db, err := catalog.Open(ctx, dsn, 5*time.Second)
if err != nil {
t.Fatal(err)
}
defer db.Close()
if _, err := db.Pool.Exec(ctx, "TRUNCATE tokens; DELETE FROM imports WHERE root = 'global' AND kind = 'tokens'"); err != nil {
t.Fatal(err)
}
// Un ancien fichier est repris au premier branchement.
dir := t.TempDir()
old, _ := Open(dir)
oldSecret, _, _ := old.Create("alice", "ancien")
open := func(dir string) *Store {
s, err := Open(dir)
if err != nil {
t.Fatal(err)
}
if err := s.UseCatalog(db); err != nil {
t.Fatal(err)
}
return s
}
a, b := open(dir), open(t.TempDir())
if _, err := os.Stat(filepath.Join(dir, fileName+".imported")); err != nil {
t.Fatal("fichier non renommé")
}
if _, ok := b.Lookup(oldSecret); !ok {
t.Fatal("jeton repris introuvable")
}
secret, info, err := a.Create("bob", "ci")
if err != nil {
t.Fatal(err)
}
tok, ok := b.Lookup(secret)
if !ok || tok.UserID != "bob" {
t.Fatalf("lookup sur l'autre instance : %v %+v", ok, tok)
}
if l := a.List("bob"); len(l) != 1 || l[0].LastUsed.IsZero() {
t.Fatalf("liste : %+v", l)
}
if err := b.Revoke("bob", info.ID); err != nil {
t.Fatal(err)
}
if _, ok := a.Lookup(secret); ok {
t.Error("jeton révoqué encore valide")
}
a.RevokeUser("alice")
if _, ok := b.Lookup(oldSecret); ok {
t.Error("RevokeUser sans effet")
}
}