Files
venture 95b4cf79cf V3 S1-S2 : corbeille + versions + extract générique
S1 filet (backend + mobile) : corbeille 30j (deleted_at réutilisé,
trash/restore récursifs, purge auto serveur), versions N=3 à chaque
overwrite, ops outbox trash/restore/purge (delete legacy mappé), Room
v19 (trashed_at), Deleters -> trash, écran Corbeille, walk guards.

S2 extract (backend) : package extract (règles FR stdlib, corpus
testé), resource_facts 000019 (origin auto/user), hook worker OCR +
backfill boot, GET /files/:id/facts (viewer+).

Contrat docs/api-v1.md étendu, V3.md (vision + plan).
2026-09-26 10:14:07 +02:00

421 lines
12 KiB
Go

package service
import (
"fmt"
"io"
"log"
"os"
"path/filepath"
"strings"
"time"
"github.com/kazier/backend/repository"
)
// TrashRetention is the corbeille lifetime (V3 P1 : 30j, cf. V3.md §2).
// Après ce délai, la passe de purge détruit définitivement les lignes.
const TrashRetention = 30 * 24 * time.Hour
// TrashDTO serializes one trashed resource for GET /trash.
type TrashDTO struct {
ID string `json:"id"`
Type string `json:"type"`
Name string `json:"name"`
Size int64 `json:"size"`
TrashedAt string `json:"trashedAt"`
UpdatedAt string `json:"updatedAt,omitempty"`
}
// VersionDTO serializes one frozen byte-generation for GET /files/:id/versions.
type VersionDTO struct {
VersionNo int `json:"versionNo"`
Size int64 `json:"size"`
MimeType string `json:"mimeType,omitempty"`
CreatedAt string `json:"createdAt"`
}
// Trash soft-deletes a resource and its subtree (corbeille). Owner-only :
// foreign or absent → repository.ErrNotFound (même code, pas d'oracle).
// delete_resource (legacy) est mappé vers Trash (cf. applySyncOp).
func (s *Resources) Trash(ownerID, id string) (string, error) {
owned, err := s.Repo.ExistsOwner(ownerID, id)
if err != nil {
return "", err
}
if !owned {
return "", repository.ErrNotFound
}
if err := s.Repo.TrashResource(ownerID, id); err != nil {
return "", err
}
return id, nil
}
// DeleteFile is the legacy owner-only file removal — now a trash (V3 P1).
// Purge définitive : Purge. Le handler choisit via ?mode=purge.
func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
// Restreint aux files comme avant (les dossiers passent par l'outbox).
if _, err := s.Repo.GetFile(ownerID, id); err != nil {
return "", err
}
return s.Trash(ownerID, id)
}
// Restore clears the trash flag on a resource, its subtree and its ancestor
// chain. Owner-only : absent/foreign → ErrNotFound ; live → no-op succès.
func (s *Resources) Restore(ownerID, id string) (string, error) {
owned, err := s.Repo.ExistsOwnerAny(ownerID, id)
if err != nil {
return "", err
}
if !owned {
return "", repository.ErrNotFound
}
if err := s.Repo.RestoreResource(ownerID, id); err != nil {
return "", err
}
return id, nil
}
// Purge hard-deletes a resource and its subtree (lignes + versions + octets).
// Owner-only (trashed ou live) : absent/foreign → ErrNotFound.
// Les fichiers physiques sont supprimés best-effort (jamais d'échec sur FS).
func (s *Resources) Purge(ownerID, id string) (string, error) {
owned, err := s.Repo.ExistsOwnerAny(ownerID, id)
if err != nil {
return "", err
}
if !owned {
return "", repository.ErrNotFound
}
purged, err := s.Repo.PurgeResource(ownerID, id)
if err != nil {
return "", err
}
for _, pid := range purged {
s.removePhysical(ownerID, pid)
}
return id, nil
}
// ListTrashed returns the owner's corbeille, most recently trashed first.
func (s *Resources) ListTrashed(ownerID string, page, pageSize int) ([]TrashDTO, int, error) {
rows, total, err := s.Repo.ListTrashed(ownerID, pageSize, (page-1)*pageSize)
if err != nil {
return nil, 0, err
}
out := make([]TrashDTO, 0, len(rows))
for _, row := range rows {
out = append(out, TrashDTO{
ID: row.ID,
Type: row.Type,
Name: row.Name,
Size: row.Size,
TrashedAt: row.TrashedAt.UTC().Format(time.RFC3339),
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
})
}
return out, total, nil
}
// ListVersions returns the frozen byte-generations of a live owned resource,
// newest first. Trashed/absent/foreign → ErrNotFound.
func (s *Resources) ListVersions(ownerID, id string) ([]VersionDTO, error) {
rows, err := s.Repo.ListVersions(ownerID, id)
if err != nil {
return nil, err
}
out := make([]VersionDTO, 0, len(rows))
for _, row := range rows {
out = append(out, VersionDTO{
VersionNo: row.VersionNo,
Size: row.Size,
MimeType: row.MimeType,
CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339),
})
}
return out, nil
}
// RestoreVersion recopies la génération n vers l'emplacement live (l'actuel
// est à son tour versionné, puis élagué à N=3). Owner-only, parent live.
func (s *Resources) RestoreVersion(ownerID, id string, n int) (FileDTO, error) {
ver, err := s.Repo.GetVersion(ownerID, id, n)
if err != nil {
return FileDTO{}, err
}
srcAbs := filepath.Join(s.UploadDir, ver.StoredPath)
if fi, err := os.Stat(srcAbs); err != nil || !fi.Mode().IsRegular() {
return FileDTO{}, repository.ErrNotFound
}
cur, err := s.Repo.GetFile(ownerID, id)
if err != nil {
return FileDTO{}, err
}
destDir := filepath.Join(s.UploadDir, ownerID)
if err := os.MkdirAll(destDir, 0o700); err != nil {
return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
}
if err := os.Chmod(destDir, 0o700); err != nil {
return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
}
// 1. Geler l'actuel (staging copy, pas de move — l'échec reste safe).
staged, stagedExt, stagedSize, stagedMime, hasLive, err := s.freezeLive(ownerID, id, cur, destDir)
if err != nil {
return FileDTO{}, err
}
if hasLive {
defer func() {
// Staging orphelin si on sort en erreur avant finalize.
if err != nil {
_ = os.Remove(staged)
}
}()
}
// 2. Recopier la version vers le live (même atomicité que l'upload).
destName := id
if ver.Extension != "" {
destName = id + "." + ver.Extension
}
if err := copyFileAtomic(srcAbs, destDir, filepath.Join(destDir, destName)); err != nil {
return FileDTO{}, err
}
mime := ver.MimeType
if mime == "" {
mime = "application/octet-stream"
}
var extPtr *string
if ver.Extension != "" {
extPtr = &ver.Extension
}
fi, err := os.Stat(filepath.Join(destDir, destName))
if err != nil {
return FileDTO{}, err
}
if err := s.Repo.UpdatePhysical(ownerID, id, fi.Size(), &mime, extPtr); err != nil {
return FileDTO{}, err
}
if err := s.Repo.SetHasContent(ownerID, id, true); err != nil {
log.Printf("versions: SetHasContent(%s): %v", id, err)
}
// 3. Nettoyer les suffixes orphelins + figer l'ancien actuel en version.
s.removeStaleSuffixes(destDir, id, destName)
if hasLive {
if ferr := s.finalizeVersion(ownerID, id, staged, stagedExt, stagedSize, stagedMime); ferr != nil {
log.Printf("versions: finalize displaced current(%s): %v", id, ferr)
}
}
row, err := s.Repo.GetFile(ownerID, id)
if err != nil {
return FileDTO{}, err
}
return toFileDTO(row), nil
}
// PurgeExpiredTrash détruit les lignes trashées depuis plus de retention
// (corbeille 30j) + leurs octets (best-effort). Boucle par batch jusqu'à vide.
// Retourne le nombre de ressources racines purgées. Appelé au boot puis par
// ticker (cf. cmd/server/main.go).
func (s *Resources) PurgeExpiredTrash(retention time.Duration) (int, error) {
cutoff := time.Now().Add(-retention)
total := 0
for {
purged, err := s.Repo.PurgeExpiredTrash(cutoff, 500)
if err != nil {
return total, err
}
if len(purged) == 0 {
return total, nil
}
for _, p := range purged {
s.removePhysical(p.UserID, p.ResourceID)
total++
}
}
}
// removePhysical supprime tous les octets connus d'une ressource : live
// (UPLOAD_DIR/<user>/<resource>.* + nu) et versions (.versions/). Best-effort.
func (s *Resources) removePhysical(userID, resourceID string) {
if !idPattern.MatchString(userID) || !idPattern.MatchString(resourceID) {
return
}
dir := filepath.Join(s.UploadDir, userID)
matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*"))
for _, m := range matches {
if strings.HasPrefix(filepath.Base(m), resourceID+".") {
_ = os.Remove(m)
}
}
_ = os.Remove(filepath.Join(dir, resourceID))
verMatches, _ := filepath.Glob(filepath.Join(dir, ".versions", resourceID+"_v*"))
for _, m := range verMatches {
_ = os.Remove(m)
}
}
// removeStaleSuffixes supprime les anciens suffixes orphelins après écriture
// du live (même règle que Upload : tout `<id>.*` sauf le live).
func (s *Resources) removeStaleSuffixes(destDir, resourceID, liveName string) {
matches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*"))
for _, m := range matches {
if filepath.Base(m) != liveName && strings.HasPrefix(filepath.Base(m), resourceID+".") {
_ = os.Remove(m)
}
}
}
// livePhysicalFile retourne le chemin live existant d'une ressource (suffixé
// ou nu), "" si metadata-only.
func livePhysicalFile(uploadDir, ownerID, resourceID string) string {
dir := filepath.Join(uploadDir, ownerID)
matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*"))
for _, m := range matches {
if strings.HasPrefix(filepath.Base(m), resourceID+".") {
if fi, err := os.Lstat(m); err == nil && fi.Mode().IsRegular() {
return m
}
}
}
if bare := filepath.Join(dir, resourceID); bare != "" {
if fi, err := os.Lstat(bare); err == nil && fi.Mode().IsRegular() {
return bare
}
}
return ""
}
// freezeLive copie les octets live vers un staging temp (jamais de move :
// l'original reste en place jusqu'au succès). Retourne le staging + métadonnées.
// ok=false quand metadata-only (rien à versionner).
func (s *Resources) freezeLive(ownerID, resourceID string, cur repository.FileRow, destDir string) (staging, ext string, size int64, mime string, ok bool, err error) {
live := livePhysicalFile(s.UploadDir, ownerID, resourceID)
if live == "" {
return "", "", 0, "", false, nil
}
base := filepath.Base(live)
ext = ""
if strings.HasPrefix(base, resourceID+".") {
ext = strings.TrimPrefix(base, resourceID+".")
}
tmp, err := os.CreateTemp(destDir, ".ver-"+resourceID+".*")
if err != nil {
return "", "", 0, "", false, fmt.Errorf("stage version: %w", err)
}
staging = tmp.Name()
if err := copyInto(tmp, live); err != nil {
tmp.Close()
_ = os.Remove(staging)
return "", "", 0, "", false, err
}
if err := tmp.Close(); err != nil {
_ = os.Remove(staging)
return "", "", 0, "", false, fmt.Errorf("stage version: %w", err)
}
fi, err := os.Stat(staging)
if err != nil {
_ = os.Remove(staging)
return "", "", 0, "", false, err
}
mime = cur.MimeType
if mime == "" {
mime = "application/octet-stream"
}
return staging, ext, fi.Size(), mime, true, nil
}
// finalizeVersion déplace le staging vers .versions/, insère la ligne et
// élague au-delà de MaxVersions (fichiers élagués supprimés best-effort).
func (s *Resources) finalizeVersion(ownerID, resourceID, staged, ext string, size int64, mime string) error {
no, err := s.Repo.NextVersionNo(resourceID)
if err != nil {
return err
}
rel := filepath.Join(ownerID, ".versions", fmt.Sprintf("%s_v%d", resourceID, no))
if ext != "" {
rel += "." + ext
}
abs := filepath.Join(s.UploadDir, rel)
if err := os.MkdirAll(filepath.Dir(abs), 0o700); err != nil {
return err
}
if err := os.Rename(staged, abs); err != nil {
return err
}
if err := os.Chmod(abs, 0o600); err != nil {
log.Printf("versions: chmod(%s): %v", rel, err)
}
var extPtr *string
if ext != "" {
extPtr = &ext
}
vid, err := repository.NewIDErr()
if err != nil {
return err
}
if err := s.Repo.InsertVersion(vid, resourceID, no, size, &mime, extPtr, rel); err != nil {
_ = os.Remove(abs)
return err
}
pruned, err := s.Repo.PruneVersions(resourceID, repository.MaxVersions)
if err != nil {
log.Printf("versions: prune(%s): %v", resourceID, err)
return nil
}
for _, p := range pruned {
_ = os.Remove(filepath.Join(s.UploadDir, p))
}
return nil
}
// copyInto copie src vers le fichier ouvert dst.
func copyInto(dst *os.File, src string) error {
in, err := os.Open(src)
if err != nil {
return err
}
defer in.Close()
if _, err := io.Copy(dst, in); err != nil {
return fmt.Errorf("copy version bytes: %w", err)
}
return nil
}
// copyFileAtomic recopie src vers destPath via temp+rename (0600).
func copyFileAtomic(src, destDir, destPath string) error {
tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*")
if err != nil {
return fmt.Errorf("create tmp file: %w", err)
}
tmpName := tmp.Name()
success := false
defer func() {
if !success {
_ = os.Remove(tmpName)
}
}()
if err := tmp.Chmod(0o600); err != nil {
tmp.Close()
return fmt.Errorf("chmod tmp file: %w", err)
}
if err := copyInto(tmp, src); err != nil {
tmp.Close()
return err
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return fmt.Errorf("fsync: %w", err)
}
if err := tmp.Close(); err != nil {
return fmt.Errorf("close: %w", err)
}
if err := os.Rename(tmpName, destPath); err != nil {
return fmt.Errorf("commit: %w", err)
}
if err := os.Chmod(destPath, 0o600); err != nil {
return fmt.Errorf("chmod: %w", err)
}
success = true
return nil
}