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).
421 lines
12 KiB
Go
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
|
|
}
|