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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-05 22:06:31 +00:00
1 parent 69d33b6dd3
commit 2b2d341497
4 files changed
+475 -135

No files matched your search

+32 -12
View File
@@ -115,20 +115,37 @@ public sealed class ArchiveService : IJobHandlerProvider
public static ArchiveAvailability GetAvailability(Archive archive) => ArchiveVolume.Probe(new ArchivePaths(archive.RootPath));
/// <summary>Changes title, tags, rating and notes in the sidecar and the index together (settings version + 1).</summary>
public async Task<Sequence> SetSequenceInfoAsync(Guid sequenceId, string? title, IReadOnlyList<string> tags, int rating, string? notes,
CancellationToken cancellationToken = default)
public Task<Sequence> SetSequenceInfoAsync(Guid sequenceId, string? title, IReadOnlyList<string> tags, int rating, string? notes,
CancellationToken cancellationToken = default) =>
EditSequenceInfoAsync(sequenceId, _ => new SequenceInfo(title, tags, rating, notes), cancellationToken);
/// <summary>
/// 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 <paramref name="edit"/>
/// leaves alone keep any change made since the caller read the sequence. Sidecar and index change together
/// (settings version + 1).
/// </summary>
public async Task<Sequence> EditSequenceInfoAsync(Guid sequenceId, Func<SequenceInfo, SequenceInfo> 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);
/// <summary>Dry run of moving sequences to their archive's trash.</summary>
public Task<DeletePlan> PlanDeleteAsync(IReadOnlyList<Guid> sequenceIds, CancellationToken cancellationToken = default) =>
Trash.PlanAsync(sequenceIds, cancellationToken);
/// <summary>Dry run of moving sequences to their archive's trash; <paramref name="progress"/> counts the sequences checked.</summary>
public Task<DeletePlan> PlanDeleteAsync(IReadOnlyList<Guid> sequenceIds, IProgress<int>? progress = null, CancellationToken cancellationToken = default) =>
Trash.PlanAsync(sequenceIds, progress, cancellationToken);
/// <summary>Moves exactly the planned sequences to the trash; returns the trash entries made.</summary>
public Task<IReadOnlyList<TrashEntry>> DeleteAsync(DeletePlan plan, string? deletedBy = null, IProgress<int>? progress = null,
@@ -222,6 +239,9 @@ public sealed class ArchiveService : IJobHandlerProvider
}
}
/// <summary>The fields of a sequence the user describes it with (sidecar and index).</summary>
public sealed record SequenceInfo(string? Title, IReadOnlyList<string> Tags, int Rating, string? Notes);
/// <summary>Builds the archive jobs; enqueue with <see cref="EnqueueAsync"/>.</summary>
public static class ArchiveJobs
{
+252 -100
View File
@@ -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
/// <summary>Other sequences live in folders below this one; moving it would take them along.</summary>
ContainsSequences,
/// <summary>A job is running on the sequence, or paused in the middle of it.</summary>
/// <summary>A running or paused job works on the sequence, or on its whole archive (a scan, a rebuild, an import, a verify, maintenance).</summary>
Busy,
/// <summary>The folder's sidecar names another sequence: the index is out of date (a scan fixes it).</summary>
ForeignSidecar,
/// <summary>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.</summary>
FolderMissing,
}
/// <summary>One sequence of a delete plan: its folder moves to <see cref="TrashFolder"/> and its index rows go.</summary>
/// <param name="TrashFolder">Archive-relative folder the sequence folder moves to; null when it has no folder on disk (only its rows go).</param>
/// <param name="TrashFolder">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.</param>
/// <param name="Files">Files under the folder (originals, proxies, exports, sidecars).</param>
/// <param name="Bytes">Their size on disk.</param>
public sealed record DeleteStep(Sequence Sequence, string? TrashFolder, int Files, long Bytes);
@@ -61,7 +65,9 @@ public sealed class StaleDeletePlanException(Guid sequenceId) : InvalidOperation
/// run; <see cref="DeleteAsync"/> moves each sequence folder whole — originals, proxies, exports and its sidecars — into
/// <c>.titano/trash/&lt;id&gt;</c> of its archive under the sequence's leases, next to a record of its index row and
/// renders, then removes the index rows. <see cref="RestoreAsync"/> 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.
/// </summary>
public sealed class SequenceTrash
{
@@ -71,6 +77,9 @@ public sealed class SequenceTrash
private const string RecordExtension = ".json";
private const int JobPage = 200;
/// <summary>Bytes of a sidecar read to find its id (written second, after the schema version).</summary>
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);
/// <summary>The dry run: for each sequence, where its folder goes and how many files and bytes it holds, or why it cannot go.</summary>
/// <param name="progress">Sequences checked so far.</param>
/// <exception cref="ArgumentException">A sequence is not in the index.</exception>
public async Task<DeletePlan> PlanAsync(IReadOnlyList<Guid> sequenceIds, CancellationToken cancellationToken = default)
public async Task<DeletePlan> PlanAsync(IReadOnlyList<Guid> sequenceIds, IProgress<int>? progress = null, CancellationToken cancellationToken = default)
{
var busy = await BusySequencesAsync(cancellationToken).ConfigureAwait(false);
var archives = new Dictionary<Guid, (Archive Archive, ArchivePaths Paths, bool Online, IReadOnlyList<Repositories.SequenceLocation> Locations)>();
var busy = await BusyAsync(cancellationToken).ConfigureAwait(false);
var archives = new Dictionary<Guid, ArchiveContext?>();
var steps = new List<DeleteStep>();
var blocked = new List<BlockedDelete>();
var claimed = new HashSet<string>(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.
/// </summary>
/// <param name="deletedBy">Who asked (user name or client), kept in the trash record.</param>
/// <param name="progress">Sequences moved so far.</param>
/// <exception cref="StaleDeletePlanException">A sequence moved, vanished or got busy since the plan; nothing was deleted.</exception>
/// <exception cref="ArchiveOfflineException">An archive went offline; sequences before it are in the trash.</exception>
/// <exception cref="ArchiveOfflineException">An archive is offline; sequences before it are in the trash.</exception>
public async Task<IReadOnlyList<TrashEntry>> DeleteAsync(DeletePlan plan, string? deletedBy = null, IProgress<int>? 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<TrashEntry>(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
/// <summary>
/// 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.
/// </summary>
/// <exception cref="InvalidOperationException">The index already holds that sequence.</exception>
/// <exception cref="DirectoryNotFoundException">The entry is not in the trash.</exception>
@@ -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.");
}
/// <summary>A sidecar for a restored folder that had none (its frames get new ids; the sequence keeps its own).</summary>
private SequenceManifest Adopt(SequencePaths sequence, Guid id, CancellationToken cancellationToken)
/// <summary>
/// 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.
/// </summary>
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;
}
/// <summary>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.</summary>
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);
}
/// <summary>The next incremental scan skips the restored folder; when the stamps cannot be written it only reads the folder again.</summary>
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);
}
}
/// <summary>Checks the plan again just before anything moves, without measuring the folders again; any change refuses it whole.</summary>
private async Task RevalidateAsync(DeletePlan plan, CancellationToken cancellationToken)
{
var busy = await BusyAsync(cancellationToken).ConfigureAwait(false);
var archives = new Dictionary<Guid, ArchiveContext?>();
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<TrashEntry?> 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<string>());
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<string>());
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<Repositories.SequenceLocation> locations,
IReadOnlySet<Guid> 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);
}
/// <summary>Undoes a folder move after a failed index step; false (logged) when the folder cannot move back either.</summary>
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;
}
/// <summary>Sequences a running or paused job works on (an import, a render, a transfer, a proxy pass).</summary>
private async Task<IReadOnlySet<Guid>> BusySequencesAsync(CancellationToken cancellationToken)
private async Task<ArchiveContext?> ContextAsync(Dictionary<Guid, ArchiveContext?> 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<Guid> 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;
}
/// <summary>
/// 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.
/// </summary>
private async Task<IReadOnlySet<Guid>> BusyAsync(CancellationToken cancellationToken)
{
var busy = new HashSet<Guid>();
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<Guid> 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;
}
}
/// <summary>
/// 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.
/// </summary>
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;
}
}
/// <summary>An archive as the plan sees it: where it is, whether it can be written, and where its sequences are.</summary>
private sealed record ArchiveContext(ArchivePaths Paths, ArchiveAvailability Availability, IReadOnlyList<Repositories.SequenceLocation> Locations);
}
/// <summary>What the trash keeps next to a deleted folder: the index row and renders the sidecar does not carry.</summary>
@@ -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));
}
}
@@ -57,6 +57,40 @@ public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(con
return render;
}
private static Job Running(JobKind kind, IReadOnlyList<Guid> 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,
};
/// <summary>Makes the next write of <paramref name="operation"/> on the sequences table fail, as a lost database connection would.</summary>
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);
}
/// <summary>Reports on the calling thread, so a test can act between two sequences.</summary>
private sealed class Inline(Action<int> report) : IProgress<int>
{
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<StaleDeletePlanException>(() => 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<StaleDeletePlanException>(() => 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<DatabaseException>(() => 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<DatabaseException>(() => 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<OperationCanceledException>(() => 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<int>();
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<OperationCanceledException>(() =>
fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], new Inline(_ => cancel.Cancel()), cancel.Token));
}
}