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//.* + 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 `.*` 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 }