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
This commit is contained in:
1 parent
7c1f49cb5c
commit
1da55c7ad7
1 file changed
+967
@@ -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
|
||||
}
|
||||
Reference in new issue
Block a user