From 2b2d341497193c4926ce6a178f2417081020643f Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 5 Oct 2026 22:06:31 +0000 Subject: [PATCH] fix(data): trash moves finish whatever is cancelled, archive-wide jobs hold their sequences Once a folder has moved into the trash (or back), its index step runs to the end with no cancellation and a failed step moves the folder back, so trash and index never disagree. Running or paused archive-wide jobs (scan, rebuild, import, maintenance, a verify of everything) block a delete of every sequence of their archive; a verify of named sequences blocks those. A row whose folder is gone is refused (FolderMissing) instead of losing its settings. Delete revalidates the plan cheaply (index row, jobs, sidecar id from its head) instead of measuring every folder again; the dry run reports progress. A restored folder without a sidecar gets the record's title, tags, rating and notes and drops a hero frame it no longer has. EditSequenceInfoAsync changes one field from the current sidecar values. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Data/Archiving/ArchiveService.cs | 44 ++- src/Titano.Data/Archiving/SequenceTrash.cs | 352 +++++++++++++----- .../Archiving/ArchiveIndexTests.cs | 18 + .../Archiving/SequenceTrashTests.cs | 196 ++++++++-- 4 files changed, 475 insertions(+), 135 deletions(-) diff --git a/src/Titano.Data/Archiving/ArchiveService.cs b/src/Titano.Data/Archiving/ArchiveService.cs index b338d554..92aff0f9 100644 --- a/src/Titano.Data/Archiving/ArchiveService.cs +++ b/src/Titano.Data/Archiving/ArchiveService.cs @@ -115,20 +115,37 @@ public sealed class ArchiveService : IJobHandlerProvider public static ArchiveAvailability GetAvailability(Archive archive) => ArchiveVolume.Probe(new ArchivePaths(archive.RootPath)); /// Changes title, tags, rating and notes in the sidecar and the index together (settings version + 1). - public async Task SetSequenceInfoAsync(Guid sequenceId, string? title, IReadOnlyList tags, int rating, string? notes, - CancellationToken cancellationToken = default) + public Task SetSequenceInfoAsync(Guid sequenceId, string? title, IReadOnlyList tags, int rating, string? notes, + CancellationToken cancellationToken = default) => + EditSequenceInfoAsync(sequenceId, _ => new SequenceInfo(title, tags, rating, notes), cancellationToken); + + /// + /// Changes some of title, tags, rating and notes from their current values — read under the sequence's lease from + /// the sidecar, or from the index when it is ahead (an edit made there only) — so fields + /// leaves alone keep any change made since the caller read the sequence. Sidecar and index change together + /// (settings version + 1). + /// + public async Task EditSequenceInfoAsync(Guid sequenceId, Func edit, CancellationToken cancellationToken = default) { + ArgumentNullException.ThrowIfNull(edit); var (archive, sequence) = await LoadSequenceAsync(sequenceId, cancellationToken).ConfigureAwait(false); var paths = new ArchivePaths(archive.RootPath); ArchiveVolume.EnsureWritable(paths); - var manifest = await _writer.UpdateAsync(paths, sequenceId, sequence.Folder, m => m with + var manifest = await _writer.UpdateAsync(paths, sequenceId, sequence.Folder, m => { - Title = string.IsNullOrWhiteSpace(title) ? null : title.Trim(), - Tags = tags, - Rating = rating, - Notes = notes, - Versions = m.Versions with { Settings = System.Math.Max(m.Versions.Settings, sequence.SettingsVersion) + 1 }, - UpdatedAt = DateTimeOffset.UtcNow, + var current = sequence.SettingsVersion > m.Versions.Settings + ? new SequenceInfo(sequence.Title, sequence.Tags, sequence.Rating, sequence.Notes) + : new SequenceInfo(m.Title, m.Tags, m.Rating, m.Notes); + var info = edit(current); + return m with + { + Title = string.IsNullOrWhiteSpace(info.Title) ? null : info.Title.Trim(), + Tags = info.Tags, + Rating = info.Rating, + Notes = info.Notes, + Versions = m.Versions with { Settings = System.Math.Max(m.Versions.Settings, sequence.SettingsVersion) + 1 }, + UpdatedAt = DateTimeOffset.UtcNow, + }; }, cancellationToken).ConfigureAwait(false); var folder = paths.Sequence(sequence.Folder); var updated = SequenceMapping.ToSequence(manifest, archive.Id, folder, sequence); @@ -165,9 +182,9 @@ public sealed class ArchiveService : IJobHandlerProvider await Renamer.ApplyAsync(await LoadArchiveAsync(plan.ArchiveId, cancellationToken).ConfigureAwait(false), plan, progress, cancellationToken) .ConfigureAwait(false); - /// Dry run of moving sequences to their archive's trash. - public Task PlanDeleteAsync(IReadOnlyList sequenceIds, CancellationToken cancellationToken = default) => - Trash.PlanAsync(sequenceIds, cancellationToken); + /// Dry run of moving sequences to their archive's trash; counts the sequences checked. + public Task PlanDeleteAsync(IReadOnlyList sequenceIds, IProgress? progress = null, CancellationToken cancellationToken = default) => + Trash.PlanAsync(sequenceIds, progress, cancellationToken); /// Moves exactly the planned sequences to the trash; returns the trash entries made. public Task> DeleteAsync(DeletePlan plan, string? deletedBy = null, IProgress? progress = null, @@ -222,6 +239,9 @@ public sealed class ArchiveService : IJobHandlerProvider } } +/// The fields of a sequence the user describes it with (sidecar and index). +public sealed record SequenceInfo(string? Title, IReadOnlyList Tags, int Rating, string? Notes); + /// Builds the archive jobs; enqueue with . public static class ArchiveJobs { diff --git a/src/Titano.Data/Archiving/SequenceTrash.cs b/src/Titano.Data/Archiving/SequenceTrash.cs index a25a8bbf..5e9c321b 100644 --- a/src/Titano.Data/Archiving/SequenceTrash.cs +++ b/src/Titano.Data/Archiving/SequenceTrash.cs @@ -5,6 +5,7 @@ using Titano.Core.Diagnostics; using Titano.Core.IO; using Titano.Core.Localization; using Titano.Core.Model; +using Titano.Data.Archiving.Jobs; namespace Titano.Data.Archiving; @@ -20,15 +21,18 @@ public enum DeleteBlock /// Other sequences live in folders below this one; moving it would take them along. ContainsSequences, - /// A job is running on the sequence, or paused in the middle of it. + /// A running or paused job works on the sequence, or on its whole archive (a scan, a rebuild, an import, a verify, maintenance). Busy, /// The folder's sidecar names another sequence: the index is out of date (a scan fixes it). ForeignSidecar, + + /// The index names a folder that is not on disk: there is nothing to keep in the trash, so the Orphans check removes the row. + FolderMissing, } /// One sequence of a delete plan: its folder moves to and its index rows go. -/// Archive-relative folder the sequence folder moves to; null when it has no folder on disk (only its rows go). +/// Archive-relative folder the sequence folder moves to; null for a sequence that has no folder yet (created on the server, no photo received), of which only the rows go. /// Files under the folder (originals, proxies, exports, sidecars). /// Their size on disk. public sealed record DeleteStep(Sequence Sequence, string? TrashFolder, int Files, long Bytes); @@ -61,7 +65,9 @@ public sealed class StaleDeletePlanException(Guid sequenceId) : InvalidOperation /// run; moves each sequence folder whole — originals, proxies, exports and its sidecars — into /// .titano/trash/<id> of its archive under the sequence's leases, next to a record of its index row and /// renders, then removes the index rows. moves a folder back and indexes it again from its -/// sidecar with the same ids. The trash is a hidden folder of the archive, so scans never index it. +/// sidecar with the same ids. The trash is a hidden folder of the archive, so scans never index it. Once a folder has +/// moved, its index step runs to the end whatever the caller cancels; when that step fails, the folder moves back, so +/// the trash and the index never disagree. /// public sealed class SequenceTrash { @@ -71,6 +77,9 @@ public sealed class SequenceTrash private const string RecordExtension = ".json"; private const int JobPage = 200; + /// Bytes of a sidecar read to find its id (written second, after the schema version). + private const int SidecarHead = 4096; + private readonly TitanoDatabase _db; private readonly SequenceWriter _writer; private readonly ArchiveIndexer _indexer; @@ -92,43 +101,40 @@ public sealed class SequenceTrash public static string TrashDirectory(ArchivePaths archive) => Path.Combine(archive.MetaDirectory, FolderName); /// The dry run: for each sequence, where its folder goes and how many files and bytes it holds, or why it cannot go. + /// Sequences checked so far. /// A sequence is not in the index. - public async Task PlanAsync(IReadOnlyList sequenceIds, CancellationToken cancellationToken = default) + public async Task PlanAsync(IReadOnlyList sequenceIds, IProgress? progress = null, CancellationToken cancellationToken = default) { - var busy = await BusySequencesAsync(cancellationToken).ConfigureAwait(false); - var archives = new Dictionary Locations)>(); + var busy = await BusyAsync(cancellationToken).ConfigureAwait(false); + var archives = new Dictionary(); var steps = new List(); var blocked = new List(); var claimed = new HashSet(StringComparer.OrdinalIgnoreCase); + var checkedCount = 0; foreach (var id in sequenceIds.Distinct()) { cancellationToken.ThrowIfCancellationRequested(); var sequence = await _db.Sequences.GetAsync(id, cancellationToken).ConfigureAwait(false) ?? throw new ArgumentException($"Unknown sequence {id}.", nameof(sequenceIds)); - if (!archives.TryGetValue(sequence.ArchiveId, out var context)) - { - var archive = await _db.Archives.GetAsync(sequence.ArchiveId, cancellationToken).ConfigureAwait(false) - ?? throw new ArgumentException($"Unknown archive {sequence.ArchiveId}.", nameof(sequenceIds)); - var paths = new ArchivePaths(archive.RootPath); - context = (archive, paths, ArchiveVolume.Probe(paths) == ArchiveAvailability.Online, - await _db.Sequences.ListLocationsAsync(archive.Id, cancellationToken).ConfigureAwait(false)); - archives[sequence.ArchiveId] = context; - } - if (Block(sequence, context.Paths, context.Online, context.Locations, busy) is { } reason) + var context = await ContextAsync(archives, sequence.ArchiveId, cancellationToken).ConfigureAwait(false) + ?? throw new ArgumentException($"Unknown archive {sequence.ArchiveId}.", nameof(sequenceIds)); + if (Block(sequence, context, busy) is { } reason) { blocked.Add(new BlockedDelete(sequence, reason)); - continue; } - var folder = sequence.Folder.Length == 0 ? null : context.Paths.Sequence(sequence.Folder).Folder; - if (folder is null || !Directory.Exists(folder)) + else if (sequence.Folder.Length == 0) { steps.Add(new DeleteStep(sequence, null, 0, 0)); - continue; } - var (files, bytes) = await Task.Run(() => Measure(folder, cancellationToken), cancellationToken).ConfigureAwait(false); - var name = EntryName(context.Paths, sequence.Id, claimed); - claimed.Add(name); - steps.Add(new DeleteStep(sequence, context.Paths.ToRelative(Path.Combine(TrashDirectory(context.Paths), name)), files, bytes)); + else + { + var folder = context.Paths.Sequence(sequence.Folder).Folder; + var (files, bytes) = await Task.Run(() => Measure(folder, cancellationToken), cancellationToken).ConfigureAwait(false); + var name = EntryName(context.Paths, sequence.Id, claimed); + claimed.Add(name); + steps.Add(new DeleteStep(sequence, context.Paths.ToRelative(Path.Combine(TrashDirectory(context.Paths), name)), files, bytes)); + } + progress?.Report(++checkedCount); } return new DeletePlan(steps, blocked); } @@ -138,26 +144,19 @@ public sealed class SequenceTrash /// next; cancelling stops between two sequences. Returns the trash entries made. /// /// Who asked (user name or client), kept in the trash record. + /// Sequences moved so far. /// A sequence moved, vanished or got busy since the plan; nothing was deleted. - /// An archive went offline; sequences before it are in the trash. + /// An archive is offline; sequences before it are in the trash. public async Task> DeleteAsync(DeletePlan plan, string? deletedBy = null, IProgress? progress = null, CancellationToken cancellationToken = default) { ArgumentNullException.ThrowIfNull(plan); - // A plan made before another change is refused before anything moves. - var fresh = await PlanAsync([.. plan.Steps.Select(s => s.Sequence.Id)], cancellationToken).ConfigureAwait(false); - if (fresh.Blocked is [var block, ..]) throw new StaleDeletePlanException(block.Sequence.Id); - foreach (var step in plan.Steps) - { - if (fresh.Steps.First(s => s.Sequence.Id == step.Sequence.Id).Sequence.Folder != step.Sequence.Folder) - throw new StaleDeletePlanException(step.Sequence.Id); - } - + await RevalidateAsync(plan, cancellationToken).ConfigureAwait(false); var entries = new List(plan.Steps.Count); - for (var i = 0; i < fresh.Steps.Count; i++) + for (var i = 0; i < plan.Steps.Count; i++) { cancellationToken.ThrowIfCancellationRequested(); - if (await DeleteOneAsync(fresh.Steps[i], deletedBy, cancellationToken).ConfigureAwait(false) is { } entry) entries.Add(entry); + if (await DeleteOneAsync(plan.Steps[i], deletedBy, cancellationToken).ConfigureAwait(false) is { } entry) entries.Add(entry); progress?.Report(i + 1); } return entries; @@ -186,7 +185,8 @@ public sealed class SequenceTrash /// /// Moves a sequence back from the trash into its folder (or, when that is taken, a free one next to it) and indexes /// it again from its sidecar with its ids, settings and renders. A folder without a sidecar is adopted under the - /// sequence's id, as a scan would adopt it. Returns the restored row. + /// sequence's id, as a scan would adopt it, with the title, tags, rating and notes the record kept. Returns the + /// restored row. When it cannot be indexed, the folder goes back into the trash with its record. /// /// The index already holds that sequence. /// The entry is not in the trash. @@ -211,36 +211,101 @@ public sealed class SequenceTrash var sequence = paths.Sequence(folder); await using (await _writer.LockAsync(paths, id, cancellationToken).ConfigureAwait(false)) { + cancellationToken.ThrowIfCancellationRequested(); Directory.CreateDirectory(Path.GetDirectoryName(sequence.Folder)!); Directory.Move(source, sequence.Folder); - Log.Info("archive", $"{record.Sequence.DisplayTitle} restored from the trash to {folder}"); - var manifest = File.Exists(sequence.ManifestPath) ? SequenceWriter.ReadLocked(sequence, id) : Adopt(sequence, id, cancellationToken); - var kept = record.Sequence with { ArchiveId = archive.Id, Folder = folder, RenderedCount = 0 }; - await using (var tx = await _db.BeginAsync(cancellationToken).ConfigureAwait(false)) + try { - await tx.Sequences.UpsertAsync(SequenceMapping.ToSequence(manifest, archive.Id, sequence, kept), cancellationToken).ConfigureAwait(false); - await tx.Frames.SyncSequenceAsync(id, SequenceMapping.ToFrames(manifest, sequence), cancellationToken).ConfigureAwait(false); - foreach (var key in manifest.SessionKeys) await tx.Sequences.MapSessionKeyAsync(archive.Id, key, id, cancellationToken).ConfigureAwait(false); - foreach (var render in record.Renders) - await tx.Renders.InsertAsync(render with { OutputPath = Rebase(render.OutputPath, record.Sequence.Folder, folder) }, cancellationToken).ConfigureAwait(false); - await tx.CommitAsync(cancellationToken).ConfigureAwait(false); + var manifest = File.Exists(sequence.ManifestPath) ? SequenceWriter.ReadLocked(sequence, id) : Adopt(sequence, record.Sequence, cancellationToken); + // The index step runs to the end once it starts: a cancel cannot leave half the rows written. + await IndexAsync(archive, sequence, manifest, record, CancellationToken.None).ConfigureAwait(false); } - await _indexer.RecordStampsAsync(archive, sequence, id, cancellationToken).ConfigureAwait(false); + catch (Exception ex) + { + Log.Warning("archive", $"{record.Sequence.DisplayTitle} could not be restored; its folder goes back into the trash", ex); + MoveBack(sequence.Folder, source); + throw; + } + Log.Info("archive", $"{record.Sequence.DisplayTitle} restored from the trash to {folder}"); + await RecordStampsAsync(archive, sequence, id).ConfigureAwait(false); File.Delete(recordPath); } - return await _db.Sequences.GetAsync(id, cancellationToken).ConfigureAwait(false) + return await _db.Sequences.GetAsync(id, CancellationToken.None).ConfigureAwait(false) ?? throw new InvalidOperationException($"{record.Sequence.DisplayTitle} was restored but is not in the index."); } - /// A sidecar for a restored folder that had none (its frames get new ids; the sequence keeps its own). - private SequenceManifest Adopt(SequencePaths sequence, Guid id, CancellationToken cancellationToken) + /// + /// A sidecar for a restored folder that lost its own, built as a scan adopts a folder: its frames get new ids, the + /// sequence keeps its id, and the title, tags, rating and notes of the record go into it so sidecar and index agree. + /// + private SequenceManifest Adopt(SequencePaths sequence, Sequence kept, CancellationToken cancellationToken) { - var manifest = SequenceAdopter.Build(id, sequence, _writer.Options.Owner, cancellationToken); + var built = SequenceAdopter.Build(kept.Id, sequence, _writer.Options.Owner, cancellationToken); + var manifest = built with + { + Title = kept.Title, + Tags = kept.Tags, + Rating = kept.Rating, + Notes = kept.Notes, + Versions = built.Versions with { Settings = System.Math.Max(built.Versions.Settings, kept.SettingsVersion) }, + }; Directory.CreateDirectory(sequence.MetaDirectory); ManifestStore.WriteSequence(sequence.ManifestPath, manifest); return manifest; } + /// The restored sequence's rows: the sidecar's frames, the record's row and renders; a hero frame the sidecar no longer has is dropped. + private async Task IndexAsync(Archive archive, SequencePaths sequence, SequenceManifest manifest, TrashRecord record, CancellationToken cancellationToken) + { + var deleted = record.Sequence; + var hero = deleted.HeroFrameId is { } frame && manifest.Frames.Any(f => f.Id == frame) ? frame : (Guid?)null; + var kept = deleted with { ArchiveId = archive.Id, Folder = sequence.RelativeFolder, RenderedCount = 0, HeroFrameId = hero }; + await using var tx = await _db.BeginAsync(cancellationToken).ConfigureAwait(false); + await tx.Sequences.UpsertAsync(SequenceMapping.ToSequence(manifest, archive.Id, sequence, kept), cancellationToken).ConfigureAwait(false); + await tx.Frames.SyncSequenceAsync(deleted.Id, SequenceMapping.ToFrames(manifest, sequence), cancellationToken).ConfigureAwait(false); + foreach (var key in manifest.SessionKeys) await tx.Sequences.MapSessionKeyAsync(archive.Id, key, deleted.Id, cancellationToken).ConfigureAwait(false); + foreach (var render in record.Renders) + { + var moved = render with { OutputPath = Rebase(render.OutputPath, deleted.Folder, sequence.RelativeFolder) }; + await tx.Renders.InsertAsync(moved, cancellationToken).ConfigureAwait(false); + } + await tx.CommitAsync(cancellationToken).ConfigureAwait(false); + } + + /// The next incremental scan skips the restored folder; when the stamps cannot be written it only reads the folder again. + private async Task RecordStampsAsync(Archive archive, SequencePaths sequence, Guid id) + { + try + { + await _indexer.RecordStampsAsync(archive, sequence, id, CancellationToken.None).ConfigureAwait(false); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException) + { + Log.Warning("archive", $"Scan stamps of {sequence.RelativeFolder} not recorded; the next scan reads it again", ex); + } + } + + /// Checks the plan again just before anything moves, without measuring the folders again; any change refuses it whole. + private async Task RevalidateAsync(DeletePlan plan, CancellationToken cancellationToken) + { + var busy = await BusyAsync(cancellationToken).ConfigureAwait(false); + var archives = new Dictionary(); + foreach (var step in plan.Steps) + { + cancellationToken.ThrowIfCancellationRequested(); + var row = await _db.Sequences.GetAsync(step.Sequence.Id, cancellationToken).ConfigureAwait(false); + if (row is null || row.ArchiveId != step.Sequence.ArchiveId || row.Folder != step.Sequence.Folder) throw new StaleDeletePlanException(step.Sequence.Id); + if (await ContextAsync(archives, row.ArchiveId, cancellationToken).ConfigureAwait(false) is not { } context) throw new StaleDeletePlanException(row.Id); + switch (Block(row, context, busy)) + { + case DeleteBlock.Offline: + throw new ArchiveOfflineException(context.Paths.Root, context.Availability); + case not null: + throw new StaleDeletePlanException(row.Id); + } + } + } + private async Task DeleteOneAsync(DeleteStep step, string? deletedBy, CancellationToken cancellationToken) { var sequence = step.Sequence; @@ -248,74 +313,114 @@ public sealed class SequenceTrash ?? throw new StaleDeletePlanException(sequence.Id); var paths = new ArchivePaths(archive.RootPath); ArchiveVolume.EnsureWritable(paths); - TrashEntry? entry = null; await using (await _writer.LockAsync(paths, sequence.Id, cancellationToken).ConfigureAwait(false)) using (await LeaseFile.AcquireAsync(paths.LocksDirectory, $"thumbs-{sequence.Id:N}", _writer.Options.Owner, _writer.Options.LeaseWait, _writer.Options.LeaseDuration, cancellationToken).ConfigureAwait(false)) { var row = await _db.Sequences.GetAsync(sequence.Id, cancellationToken).ConfigureAwait(false); if (row is null || row.Folder != sequence.Folder) throw new StaleDeletePlanException(sequence.Id); - if (step.TrashFolder is not null && sequence.Folder.Length > 0 && Directory.Exists(paths.Sequence(sequence.Folder).Folder)) + if (step.TrashFolder is null) { - var folder = paths.Sequence(sequence.Folder); - if (File.Exists(folder.ManifestPath) && ManifestStore.ReadSequence(folder.ManifestPath).Id != sequence.Id) - throw new StaleDeletePlanException(sequence.Id); - var trash = TrashDirectory(paths); - Directory.CreateDirectory(trash); - var name = EntryName(paths, sequence.Id, new HashSet()); - var record = new TrashRecord(row, await _db.Renders.ListBySequenceAsync(sequence.Id, cancellationToken).ConfigureAwait(false), step.Files, - step.Bytes, DateTimeOffset.UtcNow, deletedBy); - // The record first: a crash before the move leaves a record without a folder, which the listing ignores. - var recordPath = Path.Combine(trash, name + RecordExtension); - AtomicFile.WriteAllText(recordPath, JsonSerializer.Serialize(record, TrashJson.Default.TrashRecord)); - try - { - Directory.Move(folder.Folder, Path.Combine(trash, name)); - } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) - { - // A file of the folder is open elsewhere: nothing moved, so the record goes and the rows stay. - File.Delete(recordPath); - throw; - } - entry = Entry(archive.Id, name, record); + await RemoveRowsAsync(archive.Id, row, cancellationToken).ConfigureAwait(false); + Log.Info("archive", $"{row.DisplayTitle} removed from the index (no folder yet)"); + return null; } - await using (var tx = await _db.BeginAsync(cancellationToken).ConfigureAwait(false)) + + var folder = paths.Sequence(sequence.Folder); + if (!Directory.Exists(folder.Folder) || (File.Exists(folder.ManifestPath) && SidecarId(folder.ManifestPath) != sequence.Id)) + throw new StaleDeletePlanException(sequence.Id); + var trash = TrashDirectory(paths); + Directory.CreateDirectory(trash); + var name = EntryName(paths, sequence.Id, new HashSet()); + var target = Path.Combine(trash, name); + var record = new TrashRecord(row, await _db.Renders.ListBySequenceAsync(sequence.Id, cancellationToken).ConfigureAwait(false), step.Files, + step.Bytes, DateTimeOffset.UtcNow, deletedBy); + cancellationToken.ThrowIfCancellationRequested(); + // The record first: a crash before the move leaves a record without a folder, which the listing ignores. + var recordPath = target + RecordExtension; + AtomicFile.WriteAllText(recordPath, JsonSerializer.Serialize(record, TrashJson.Default.TrashRecord)); + try { - await tx.Sequences.DeleteAsync(sequence.Id, cancellationToken).ConfigureAwait(false); - await tx.Archives.DeleteFolderStateAsync(archive.Id, sequence.Folder, cancellationToken).ConfigureAwait(false); - await tx.CommitAsync(cancellationToken).ConfigureAwait(false); + Directory.Move(folder.Folder, target); } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + // A file of the folder is open elsewhere: nothing moved, so the record goes and the rows stay. + File.Delete(recordPath); + throw; + } + try + { + // The folder has moved: its rows go too, to the end, whatever the caller cancels meanwhile. + await RemoveRowsAsync(archive.Id, row, CancellationToken.None).ConfigureAwait(false); + } + catch (Exception ex) + { + Log.Warning("archive", $"{row.DisplayTitle} could not leave the index; its folder goes back", ex); + if (MoveBack(target, folder.Folder)) File.Delete(recordPath); + throw; + } + Log.Info("archive", $"{row.DisplayTitle} moved to the trash: {row.Folder} → {name} ({step.Files} files, {step.Bytes} bytes)"); + return Entry(archive.Id, name, record); } - Log.Info("archive", entry is null - ? $"{sequence.DisplayTitle} removed from the index (no folder on disk)" - : $"{sequence.DisplayTitle} moved to the trash: {sequence.Folder} → {entry.Name} ({step.Files} files, {step.Bytes} bytes)"); - return entry; } - private static DeleteBlock? Block(Sequence sequence, ArchivePaths paths, bool online, IReadOnlyList locations, - IReadOnlySet busy) + private async Task RemoveRowsAsync(Guid archiveId, Sequence sequence, CancellationToken cancellationToken) + { + await using var tx = await _db.BeginAsync(cancellationToken).ConfigureAwait(false); + await tx.Sequences.DeleteAsync(sequence.Id, cancellationToken).ConfigureAwait(false); + // A sequence without a folder has no scan state; the root's belongs to a folder adopted in place. + if (sequence.Folder.Length > 0) await tx.Archives.DeleteFolderStateAsync(archiveId, sequence.Folder, cancellationToken).ConfigureAwait(false); + await tx.CommitAsync(cancellationToken).ConfigureAwait(false); + } + + /// Undoes a folder move after a failed index step; false (logged) when the folder cannot move back either. + private static bool MoveBack(string from, string to) { - if (!online) return DeleteBlock.Offline; - if (busy.Contains(sequence.Id)) return DeleteBlock.Busy; - // An empty folder is the archive root of a folder adopted in place, or a server sequence still waiting for its first frame. - if (sequence.Folder.Length == 0) return sequence.FrameCount > 0 ? DeleteBlock.ArchiveRoot : null; - var prefix = sequence.Folder + "/"; - if (locations.Any(l => l.Id != sequence.Id && l.Folder.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))) return DeleteBlock.ContainsSequences; - var sidecar = paths.Sequence(sequence.Folder).ManifestPath; try { - if (File.Exists(sidecar) && ManifestStore.ReadSequence(sidecar).Id != sequence.Id) return DeleteBlock.ForeignSidecar; + Directory.Move(from, to); + return true; } - catch (InvalidDataException) + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { - return DeleteBlock.ForeignSidecar; + Log.Error("archive", $"{from} could not move back to {to}; it stays where it is", ex); + return false; } - return null; } - /// Sequences a running or paused job works on (an import, a render, a transfer, a proxy pass). - private async Task> BusySequencesAsync(CancellationToken cancellationToken) + private async Task ContextAsync(Dictionary known, Guid archiveId, CancellationToken cancellationToken) + { + if (known.TryGetValue(archiveId, out var context)) return context; + if (await _db.Archives.GetAsync(archiveId, cancellationToken).ConfigureAwait(false) is { } archive) + { + var paths = new ArchivePaths(archive.RootPath); + context = new ArchiveContext(paths, ArchiveVolume.Probe(paths), + await _db.Sequences.ListLocationsAsync(archive.Id, cancellationToken).ConfigureAwait(false)); + } + known[archiveId] = context; + return context; + } + + private static DeleteBlock? Block(Sequence sequence, ArchiveContext context, IReadOnlySet busy) + { + if (context.Availability != ArchiveAvailability.Online) return DeleteBlock.Offline; + if (busy.Contains(sequence.Id) || busy.Contains(sequence.ArchiveId)) return DeleteBlock.Busy; + // An empty folder is the archive root of a folder adopted in place, or a server sequence still waiting for its first frame. + if (sequence.Folder.Length == 0) return sequence.FrameCount > 0 ? DeleteBlock.ArchiveRoot : null; + var folder = context.Paths.Sequence(sequence.Folder); + if (!Directory.Exists(folder.Folder)) return DeleteBlock.FolderMissing; + var prefix = sequence.Folder + "/"; + if (context.Locations.Any(l => l.Id != sequence.Id && l.Folder.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))) return DeleteBlock.ContainsSequences; + return File.Exists(folder.ManifestPath) && SidecarId(folder.ManifestPath) != sequence.Id ? DeleteBlock.ForeignSidecar : null; + } + + /// + /// What running and paused jobs hold: the sequences they target (renders, analyses, proxies, transfers) and the + /// archives of archive-wide ones (scan, rebuild, import, maintenance, a verify of everything). An import's folders + /// are known only to its plan, so it holds its whole archive; a verify of named sequences holds only those. + /// + private async Task> BusyAsync(CancellationToken cancellationToken) { var busy = new HashSet(); foreach (var state in new[] { JobState.Running, JobState.Paused }) @@ -324,7 +429,7 @@ public sealed class SequenceTrash do { var page = await _db.Jobs.ListAsync(state, JobPage, cursor, cancellationToken).ConfigureAwait(false); - foreach (var job in page.Items) busy.UnionWith(job.TargetIds); + foreach (var job in page.Items) busy.UnionWith(Holds(job)); cursor = page.NextCursor; } while (cursor is not null); @@ -332,6 +437,50 @@ public sealed class SequenceTrash return busy; } + private static IReadOnlyList Holds(Job job) + { + if (job.Kind != JobKind.Verify) return job.TargetIds; + try + { + return ArchiveJobJson.Read(job, ArchiveJobJson.Default.VerifyParameters, new VerifyParameters(null)).SequenceIds ?? job.TargetIds; + } + catch (JsonException) + { + return job.TargetIds; + } + } + + /// + /// The id a sidecar names, from its head (the id is written second), so checking a 35 MB sidecar does not parse it; + /// the whole file is read only when the head does not hold the id. Null when the file is unreadable. + /// + private static Guid? SidecarId(string path) + { + try + { + var head = new byte[SidecarHead]; + int length; + using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)) + length = stream.ReadAtLeast(head, head.Length, throwOnEndOfStream: false); + var reader = new Utf8JsonReader(head.AsSpan(0, length), isFinalBlock: length < head.Length, state: default); + while (reader.Read()) + { + if (reader.TokenType != JsonTokenType.PropertyName || reader.CurrentDepth != 1) continue; + if (reader.ValueTextEquals("id"u8)) + { + if (!reader.Read()) break; + return reader.TokenType == JsonTokenType.String && reader.TryGetGuid(out var id) ? id : null; + } + if (!reader.TrySkip()) break; + } + return ManifestStore.ReadSequence(path).Id; + } + catch (Exception ex) when (ex is JsonException or InvalidDataException or IOException or UnauthorizedAccessException) + { + return null; + } + } + private static (int Files, long Bytes) Measure(string folder, CancellationToken cancellationToken) { int files = 0; @@ -385,6 +534,9 @@ public sealed class SequenceTrash return null; } } + + /// An archive as the plan sees it: where it is, whether it can be written, and where its sequences are. + private sealed record ArchiveContext(ArchivePaths Paths, ArchiveAvailability Availability, IReadOnlyList Locations); } /// What the trash keeps next to a deleted folder: the index row and renders the sidecar does not carry. diff --git a/tests/Titano.Data.Tests/Archiving/ArchiveIndexTests.cs b/tests/Titano.Data.Tests/Archiving/ArchiveIndexTests.cs index 71d41e21..1d6c4542 100644 --- a/tests/Titano.Data.Tests/Archiving/ArchiveIndexTests.cs +++ b/tests/Titano.Data.Tests/Archiving/ArchiveIndexTests.cs @@ -177,4 +177,22 @@ public sealed class ArchiveIndexTests(TestContext context) Assert.SequenceEqual(["Night"], (await fx.Db.Sequences.GetAsync(comet.Id))!.Tags); Assert.Equal(0, (await fx.ScanAsync()).Indexed); } + + [Test] + public async Task AnEditOfOneFieldKeepsWhatChangedSinceTheRowWasRead() + { + await using var fx = await CreateAsync(context); + Populate(fx.Paths); + await fx.ScanAsync(); + var comet = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == "Trips/Comet"); + var stale = (await fx.Db.Sequences.GetAsync(comet.Id))!; + var edited = await fx.Service.SetSequenceInfoAsync(comet.Id, "Comet 2026", ["night"], 2, "Tripod", fx.Ct); + + var rated = await fx.Service.EditSequenceInfoAsync(stale.Id, info => info with { Rating = 5 }, fx.Ct); + + Assert.Equal(("Comet 2026", "night", 5, "Tripod"), (rated.Title, rated.Tags.Single(), rated.Rating, rated.Notes)); + Assert.Equal(edited.SettingsVersion + 1, rated.SettingsVersion); + var manifest = ManifestStore.ReadSequence(fx.Paths.Sequence(comet.Folder).ManifestPath); + Assert.Equal(("Comet 2026", "night", 5, "Tripod"), (manifest.Title, manifest.Tags.Single(), manifest.Rating, manifest.Notes)); + } } diff --git a/tests/Titano.Data.Tests/Archiving/SequenceTrashTests.cs b/tests/Titano.Data.Tests/Archiving/SequenceTrashTests.cs index c2dc3eb0..8d06282a 100644 --- a/tests/Titano.Data.Tests/Archiving/SequenceTrashTests.cs +++ b/tests/Titano.Data.Tests/Archiving/SequenceTrashTests.cs @@ -57,6 +57,40 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con return render; } + private static Job Running(JobKind kind, IReadOnlyList targets, string? parameters = null) => new() + { + Id = Guid.CreateVersion7(), + Kind = kind, + TargetIds = targets, + ParametersJson = parameters, + State = JobState.Running, + NodeId = "test#0", + Created = DateTimeOffset.UtcNow, + Started = DateTimeOffset.UtcNow, + }; + + /// Makes the next write of on the sequences table fail, as a lost database connection would. + private async Task FailSequencesAsync(ArchiveFixture fx, string operation) + { + await using var session = await fx.Db.Database.OpenAsync(fx.Ct); + await session.ExecuteScriptAsync(ForDialect( + $"CREATE TRIGGER fail_{operation} BEFORE {operation} ON sequences BEGIN SELECT RAISE(ABORT, 'injected'); END;", + $"CREATE FUNCTION fail_{operation}() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'injected'; END $$; " + + $"CREATE TRIGGER fail_{operation} BEFORE {operation} ON sequences FOR EACH ROW EXECUTE FUNCTION fail_{operation}();"), fx.Ct); + } + + private async Task HealSequencesAsync(ArchiveFixture fx, string operation) + { + await using var session = await fx.Db.Database.OpenAsync(fx.Ct); + await session.ExecuteScriptAsync(ForDialect($"DROP TRIGGER fail_{operation};", $"DROP TRIGGER fail_{operation} ON sequences;"), fx.Ct); + } + + /// Reports on the calling thread, so a test can act between two sequences. + private sealed class Inline(Action report) : IProgress + { + public void Report(int value) => report(value); + } + [Test] public async Task TheDryRunCountsWhatMovesAndChangesNothing() { @@ -65,7 +99,7 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con var before = await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id); var folder = fx.Paths.Sequence(sequences[0].Folder).Folder; - var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], fx.Ct); + var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], null, fx.Ct); Assert.Empty(plan.Blocked); Assert.Count(2, plan.Steps); var (files, bytes) = OnDisk(folder); @@ -88,7 +122,7 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con var folder = fx.Paths.Sequence(victim.Folder).Folder; var (files, bytes) = OnDisk(folder); - var plan = await fx.Service.PlanDeleteAsync([victim.Id], fx.Ct); + var plan = await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct); var entries = await fx.Service.DeleteAsync(plan, "alberto", null, fx.Ct); var entry = Assert.Contains(entries, e => e.SequenceId == victim.Id); @@ -123,7 +157,7 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con var before = await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id); var settings = (await fx.Db.Sequences.GetAsync(victim.Id))!.SettingsJson; - var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], fx.Ct), null, null, fx.Ct)).Single(); + var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single(); var restored = await fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct); Assert.Equal(victim.Folder, restored.Folder); @@ -136,7 +170,7 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con Assert.Equal(0, (await fx.ScanAsync()).Indexed); // Deleted again: the trash takes it again under the same name. - var again = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], fx.Ct), null, null, fx.Ct)).Single(); + var again = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single(); Assert.Equal(entry.Name, again.Name); } @@ -147,7 +181,7 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con var sequences = await PopulateAsync(fx); var victim = sequences[2]; await RenderAsync(fx, victim); - var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], fx.Ct), null, null, fx.Ct)).Single(); + var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single(); Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "c"), Start.AddDays(5), 2, firstSeed: 40); await fx.ScanAsync(); @@ -165,14 +199,20 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con { var fx = await FixtureAsync(); var sequences = await PopulateAsync(fx); - var victim = sequences[1]; - var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], fx.Ct), null, null, fx.Ct)).Single(); + var victim = await fx.Service.SetSequenceInfoAsync(sequences[1].Id, "Ridge", ["fog"], 4, "Tripod", fx.Ct); + var hero = (await fx.Db.Frames.ListBySequenceAsync(victim.Id)).Last().Id; + await fx.Db.Sequences.UpsertAsync(victim with { HeroFrameId = hero }, fx.Ct); + var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single(); var trashed = fx.Paths.Sequence(fx.Paths.ToRelative(Path.Combine(SequenceTrash.TrashDirectory(fx.Paths), entry.Name))); File.Delete(trashed.ManifestPath); var restored = await fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct); Assert.Equal(victim.Id, restored.Id); + Assert.Null(restored.HeroFrameId, "the frames were adopted with new ids"); + var sidecar = ManifestStore.ReadSequence(fx.Paths.Sequence(victim.Folder).ManifestPath); + Assert.Equal(("Ridge", "fog", 4, "Tripod"), (sidecar.Title, sidecar.Tags.Single(), sidecar.Rating, sidecar.Notes)); + Assert.Equal(("Ridge", 4), (restored.Title, restored.Rating)); Assert.Equal(victim.Folder, restored.Folder); Assert.Equal(3, restored.FrameCount); Assert.Count(3, await fx.Db.Frames.ListBySequenceAsync(victim.Id)); @@ -187,21 +227,11 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con var sequences = await PopulateAsync(fx); Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "a", "night"), Start.AddDays(3), 2, firstSeed: 30); await fx.ScanAsync(); - var running = new Job - { - Id = Guid.CreateVersion7(), - Kind = JobKind.Proxies, - TargetIds = [sequences[1].Id], - State = JobState.Running, - NodeId = "test#0", - Created = DateTimeOffset.UtcNow, - Started = DateTimeOffset.UtcNow, - }; - await fx.Db.Jobs.EnqueueAsync(running); + await fx.Db.Jobs.EnqueueAsync(Running(JobKind.Proxies, [sequences[1].Id])); // The folder of the third sequence now holds the sidecar of another sequence (copied over by hand). File.Copy(fx.Paths.Sequence(sequences[0].Folder).ManifestPath, fx.Paths.Sequence(sequences[2].Folder).ManifestPath, overwrite: true); - var plan = await fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], fx.Ct); + var plan = await fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], null, fx.Ct); Assert.Empty(plan.Steps); Assert.SequenceEqual([DeleteBlock.ContainsSequences, DeleteBlock.Busy, DeleteBlock.ForeignSidecar], plan.Blocked.OrderBy(b => b.Sequence.Folder, StringComparer.Ordinal).Select(b => b.Reason)); @@ -217,7 +247,7 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con var location = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(); Assert.Equal(string.Empty, location.Folder); - var plan = await fx.Service.PlanDeleteAsync([location.Id], fx.Ct); + var plan = await fx.Service.PlanDeleteAsync([location.Id], null, fx.Ct); Assert.Equal(DeleteBlock.ArchiveRoot, plan.Blocked.Single().Reason); } @@ -226,7 +256,7 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con { var fx = await FixtureAsync(); var sequences = await PopulateAsync(fx); - var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], fx.Ct); + var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], null, fx.Ct); await fx.Service.ApplyRenameAsync(await fx.Service.PlanRenameAsync(fx.Archive.Id, [sequences[1].Id], "moved/{date}", null, fx.Ct), null, fx.Ct); var stale = await Assert.ThrowsAsync(() => fx.Service.DeleteAsync(plan, null, null, fx.Ct)); @@ -236,16 +266,136 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con } [Test] - public async Task ARowWithoutAFolderLeavesOnlyTheIndex() + public async Task ARowWhoseFolderIsMissingStaysForTheOrphansCheck() { var fx = await FixtureAsync(); var sequences = await PopulateAsync(fx); Directory.Delete(fx.Paths.Sequence(sequences[0].Folder).Folder, recursive: true); - var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id], fx.Ct); + var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id], null, fx.Ct); + Assert.Empty(plan.Steps); + Assert.Equal(DeleteBlock.FolderMissing, plan.Blocked.Single().Reason); + Assert.NotNull(await fx.Db.Sequences.GetAsync(sequences[0].Id)); + } + + [Test] + public async Task ASequenceWithoutAFolderYetLosesOnlyItsRows() + { + var fx = await FixtureAsync(); + var empty = new Sequence + { + Id = Guid.CreateVersion7(), + ArchiveId = fx.Archive.Id, + Title = "Waiting for photos", + Folder = string.Empty, + Origin = SequenceOrigin.Server, + SyncState = SyncState.InSync, + UpdatedAt = DateTimeOffset.UtcNow, + }; + await fx.Db.Sequences.UpsertAsync(empty, fx.Ct); + + var plan = await fx.Service.PlanDeleteAsync([empty.Id], null, fx.Ct); Assert.Null(plan.Steps.Single().TrashFolder); Assert.Empty(await fx.Service.DeleteAsync(plan, null, null, fx.Ct)); + Assert.Null(await fx.Db.Sequences.GetAsync(empty.Id)); + } + + [Test] + public async Task JobsOnTheWholeArchiveHoldEverySequenceOfIt() + { + var fx = await FixtureAsync(); + var sequences = await PopulateAsync(fx); + var ids = sequences.Select(s => s.Id).ToList(); + + // A verify of one named sequence holds only that one. + var verifyOne = Running(JobKind.Verify, [fx.Archive.Id], ArchiveJobs.Verify(fx.Archive, [sequences[2].Id]).ParametersJson); + await fx.Db.Jobs.EnqueueAsync(verifyOne); + var plan = await fx.Service.PlanDeleteAsync(ids, null, fx.Ct); + Assert.Equal(sequences[2].Id, plan.Blocked.Single(b => b.Reason == DeleteBlock.Busy).Sequence.Id); + Assert.Count(2, plan.Steps); + + // An import (whose folders only its plan knows) holds the whole archive, and so does a paused one. + var import = Running(JobKind.Import, [fx.Archive.Id]) with { State = JobState.Paused }; + await fx.Db.Jobs.EnqueueAsync(import); + plan = await fx.Service.PlanDeleteAsync(ids, null, fx.Ct); + Assert.Empty(plan.Steps); + Assert.True(plan.Blocked.All(b => b.Reason == DeleteBlock.Busy)); + + // A plan made before the job started is refused when it runs. + await fx.Db.Jobs.SetStateAsync(import.Id, JobState.Done, null, fx.Ct); + var before = await fx.Service.PlanDeleteAsync([sequences[0].Id], null, fx.Ct); + await fx.Db.Jobs.EnqueueAsync(Running(JobKind.Scan, [fx.Archive.Id])); + await Assert.ThrowsAsync(() => fx.Service.DeleteAsync(before, null, null, fx.Ct)); + Assert.True(Directory.Exists(fx.Paths.Sequence(sequences[0].Folder).Folder)); + } + + [Test] + public async Task WhenTheIndexCannotLetGoTheFolderComesBack() + { + var fx = await FixtureAsync(); + var sequences = await PopulateAsync(fx); + var victim = sequences[0]; + var folder = fx.Paths.Sequence(victim.Folder).Folder; + var before = await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id); + var plan = await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct); + + await FailSequencesAsync(fx, "DELETE"); + await Assert.ThrowsAsync(() => fx.Service.DeleteAsync(plan, null, null, fx.Ct)); + + Assert.True(Directory.Exists(folder), "the folder is back where it was"); + Assert.Equal(before, await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id)); + Assert.Empty(Directory.EnumerateFileSystemEntries(SequenceTrash.TrashDirectory(fx.Paths))); + await HealSequencesAsync(fx, "DELETE"); + Assert.Count(1, await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)); + } + + [Test] + public async Task ARestoreThatCannotBeIndexedLeavesTheEntryInTheTrash() + { + var fx = await FixtureAsync(); + var sequences = await PopulateAsync(fx); + var victim = sequences[1]; + var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single(); + + await FailSequencesAsync(fx, "INSERT"); + await Assert.ThrowsAsync(() => fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct)); + + Assert.False(Directory.Exists(fx.Paths.Sequence(victim.Folder).Folder)); + Assert.Null(await fx.Db.Sequences.GetAsync(victim.Id)); + Assert.Equal(entry.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name); + await HealSequencesAsync(fx, "INSERT"); + Assert.Equal(victim.Folder, (await fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct)).Folder); + } + + [Test] + public async Task CancellingStopsBetweenTwoWholeSequences() + { + var fx = await FixtureAsync(); + var sequences = await PopulateAsync(fx); + var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], null, fx.Ct); + using var cancel = CancellationTokenSource.CreateLinkedTokenSource(fx.Ct); + + await Assert.ThrowsAsync(() => fx.Service.DeleteAsync(plan, null, new Inline(_ => cancel.Cancel()), cancel.Token)); + Assert.Null(await fx.Db.Sequences.GetAsync(sequences[0].Id)); + Assert.Count(1, await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)); + Assert.NotNull(await fx.Db.Sequences.GetAsync(sequences[1].Id)); + Assert.True(Directory.Exists(fx.Paths.Sequence(sequences[1].Folder).Folder)); + } + + [Test] + public async Task ACancelledDryRunStopsAndReportsWhatItChecked() + { + var fx = await FixtureAsync(); + var sequences = await PopulateAsync(fx); + var checkedCounts = new List(); + var plan = await fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], new Inline(checkedCounts.Add), fx.Ct); + Assert.SequenceEqual([1, 2, 3], checkedCounts); + Assert.Count(3, plan.Steps); + + using var cancel = CancellationTokenSource.CreateLinkedTokenSource(fx.Ct); + await Assert.ThrowsAsync(() => + fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], new Inline(_ => cancel.Cancel()), cancel.Token)); } }