fix(archive): mass rename refuses a folder that gained a sequence after the dry run
A scan can index a sequence inside a folder the plan moves after the dry run was shown (photos copied into a subfolder). The folder would then move with it while its index row stayed behind. Apply now lists the index again before anything moves and under each moving step's leases just before the move, and throws StaleRenamePlanException naming the newcomer. A resumed journal drops such a step while its folder has not moved yet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
2 files changed
+94
-3
No files matched your search
@@ -2,10 +2,14 @@ using Titano.Core.Archiving;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Core.Model;
|
||||
using Titano.Data.Repositories;
|
||||
|
||||
namespace Titano.Data.Archiving;
|
||||
|
||||
/// <summary>The plan no longer matches the archive (a sequence moved or vanished since it was made).</summary>
|
||||
/// <summary>
|
||||
/// The plan no longer matches the archive: a sequence moved or vanished since it was made, or one was indexed inside a
|
||||
/// folder the plan moves.
|
||||
/// </summary>
|
||||
public sealed class StaleRenamePlanException(Guid sequenceId)
|
||||
: InvalidOperationException(Loc.L("Archive.Error.StalePlan"))
|
||||
{
|
||||
@@ -62,7 +66,8 @@ public sealed class MassRenamer
|
||||
private static RenameSubject Subject(Sequence s) => new(s.Id, s.Folder, s.Title, s.FirstCapture, s.CameraMake, s.CameraModel, s.Lens);
|
||||
|
||||
/// <summary>Applies a plan; each completed step is journaled before the next starts.</summary>
|
||||
/// <exception cref="StaleRenamePlanException">A sequence is no longer where the plan expects it; nothing of that step was changed.</exception>
|
||||
/// <exception cref="StaleRenamePlanException">A sequence is no longer where the plan expects it, or a folder that moves holds
|
||||
/// a sequence the plan does not take along; nothing of that step was changed.</exception>
|
||||
public Task ApplyAsync(Archive archive, RenamePlan plan, IProgress<int>? progress = null, CancellationToken cancellationToken = default) =>
|
||||
RunAsync(archive, new RenameJournal(plan, []), resuming: false, progress, cancellationToken);
|
||||
|
||||
@@ -85,12 +90,17 @@ public sealed class MassRenamer
|
||||
var completed = journal.Completed.ToHashSet();
|
||||
if (!resuming)
|
||||
{
|
||||
// A plan made before another change is refused before anything moves.
|
||||
// A plan made before another change is refused before anything moves: a sequence moved, or one was indexed
|
||||
// inside a folder that moves (a scan adopted a subfolder copied in since the dry run).
|
||||
foreach (var step in journal.Plan.Steps)
|
||||
{
|
||||
if ((await _db.Sequences.GetAsync(step.SequenceId, cancellationToken).ConfigureAwait(false))?.Folder != step.FromFolder)
|
||||
throw new StaleRenamePlanException(step.SequenceId);
|
||||
}
|
||||
var planned = journal.Plan.Steps.Select(s => s.SequenceId).ToHashSet();
|
||||
if (await StrangerInsideAsync(archive, journal.Plan.Steps.Where(s => s.MovesFolder && !s.Carried), planned, cancellationToken)
|
||||
.ConfigureAwait(false) is { } stranger)
|
||||
throw new StaleRenamePlanException(stranger.Id);
|
||||
}
|
||||
RenameJournal.Write(paths, journal);
|
||||
var steps = journal.Plan.Steps;
|
||||
@@ -147,6 +157,7 @@ public sealed class MassRenamer
|
||||
{
|
||||
if (await StandsAsync(c, resuming, cancellationToken).ConfigureAwait(false)) follow.Add(c);
|
||||
}
|
||||
if (!await CarriesAllInsideAsync(archive, paths, step, carried, resuming, cancellationToken).ConfigureAwait(false)) return;
|
||||
RenamePlanner.MoveFolder(paths, step);
|
||||
await RecordAsync(archive, paths, step, cancellationToken).ConfigureAwait(false);
|
||||
// Moved with their carrier: only their sidecars and index rows follow.
|
||||
@@ -170,6 +181,35 @@ public sealed class MassRenamer
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether every sequence the index has inside the folder of a moving step moves with it as planned, checked again under
|
||||
/// the step's leases just before the folder moves. One indexed there since the dry run would move without its index
|
||||
/// row following, and was never shown in the plan: the step is refused, or dropped when resuming a folder that has not
|
||||
/// moved yet (a folder moved before the interruption goes on; the next scan indexes the newcomer where it ended up).
|
||||
/// </summary>
|
||||
/// <exception cref="StaleRenamePlanException">Not resuming, and such a sequence is inside the folder.</exception>
|
||||
private async Task<bool> CarriesAllInsideAsync(Archive archive, ArchivePaths paths, RenameStep step, IReadOnlyList<RenameStep> carried, bool resuming,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
if (!step.MovesFolder) return true;
|
||||
var taken = carried.Select(c => c.SequenceId).ToHashSet();
|
||||
if (await StrangerInsideAsync(archive, [step], taken, cancellationToken).ConfigureAwait(false) is not { } stranger) return true;
|
||||
if (!resuming) throw new StaleRenamePlanException(stranger.Id);
|
||||
if (!Directory.Exists(paths.Sequence(step.FromFolder).Folder)) return true;
|
||||
Log.Warning("archive", $"Rename of {step.FromFolder} dropped: {stranger.Folder} was indexed inside it after the plan was made");
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>A sequence the index has inside the folder of one of <paramref name="moving"/> that is not in <paramref name="taken"/>; null when there is none.</summary>
|
||||
private async Task<SequenceLocation?> StrangerInsideAsync(Archive archive, IEnumerable<RenameStep> moving, IReadOnlySet<Guid> taken,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var folders = moving.Select(s => s.FromFolder).ToList();
|
||||
if (folders.Count == 0) return null;
|
||||
return (await _db.Sequences.ListLocationsAsync(archive.Id, cancellationToken).ConfigureAwait(false))
|
||||
.FirstOrDefault(l => !taken.Contains(l.Id) && folders.Any(f => RenamePlanner.IsInside(f, l.Folder)));
|
||||
}
|
||||
|
||||
/// <summary>Sidecar title, then index (folder, frames' paths); each part is idempotent so a resumed step can repeat it.</summary>
|
||||
private async Task RecordAsync(Archive archive, ArchivePaths paths, RenameStep step, CancellationToken cancellationToken)
|
||||
{
|
||||
|
||||
@@ -105,6 +105,57 @@ public sealed class MassRenameTests(TestContext context)
|
||||
Assert.True(Directory.Exists(fx.Paths.FromRelative(other.Steps[0].ToFolder)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ASequenceIndexedInsideAMovingFolderAfterTheDryRunMakesThePlanStale()
|
||||
{
|
||||
await using var fx = await CreateAsync(context);
|
||||
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips"), Start, 2);
|
||||
await fx.ScanAsync();
|
||||
var trips = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single();
|
||||
var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, [trips.Id], "moved/{date}", null, fx.Ct);
|
||||
Assert.Count(1, plan.Steps);
|
||||
|
||||
// Photos copied into a subfolder and indexed by the next scan, after the dry run was shown.
|
||||
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips", "day2"), Start.AddDays(1), 2, firstSeed: 10);
|
||||
await fx.ScanAsync();
|
||||
var day2 = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == "trips/day2");
|
||||
|
||||
var stale = await Assert.ThrowsAsync<StaleRenamePlanException>(() => fx.Service.ApplyRenameAsync(plan, null, fx.Ct));
|
||||
Assert.Equal(day2.Id, stale.SequenceId);
|
||||
Assert.Empty(RenameJournal.ListPending(fx.Paths));
|
||||
Assert.SequenceEqual(["trips|trips|trips/IMG_0001.JPG,trips/IMG_0002.JPG", "trips/day2|day2|trips/day2/IMG_0001.JPG,trips/day2/IMG_0002.JPG"],
|
||||
await StateAsync(fx, [trips.Id, day2.Id]));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AFolderThatGainedASequenceWhileTheRenameRanStaysWhereItIs()
|
||||
{
|
||||
await using var fx = await CreateAsync(context);
|
||||
var ids = await PopulateAsync(fx);
|
||||
var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, [ids[0], ids[1]], "renamed/{date}", null, fx.Ct);
|
||||
Assert.SequenceEqual(["inbox/a", "inbox/b"], plan.Steps.Select(s => s.FromFolder));
|
||||
|
||||
// Once the first folder moved, a scan indexes photos copied into the second one.
|
||||
var late = Path.Combine(fx.Paths.Root, "inbox", "b", "late");
|
||||
var progress = new SyncProgress(done =>
|
||||
{
|
||||
if (done != 1) return;
|
||||
Photos.WriteSeries(late, Start.AddDays(5), 2, firstSeed: 40);
|
||||
fx.ScanAsync().GetAwaiter().GetResult();
|
||||
});
|
||||
await Assert.ThrowsAsync<StaleRenamePlanException>(() => fx.Service.ApplyRenameAsync(plan, progress, fx.Ct));
|
||||
var newcomer = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == "inbox/b/late");
|
||||
Assert.True(Directory.Exists(late), "the folder did not move");
|
||||
Assert.Count(1, RenameJournal.ListPending(fx.Paths).Single().Completed);
|
||||
|
||||
// Resumed, the rest of the plan runs but that step is dropped: every index row still names its files.
|
||||
Assert.Equal(1, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct));
|
||||
Assert.Empty(RenameJournal.ListPending(fx.Paths));
|
||||
var state = await StateAsync(fx, [ids[0], ids[1], newcomer.Id]);
|
||||
Assert.SequenceEqual(["renamed/2026-09-28", "inbox/b", "inbox/b/late"], state.Select(s => s.Split('|')[0]));
|
||||
Assert.Equal(0, (await fx.ScanAsync()).Indexed);
|
||||
}
|
||||
|
||||
/// <summary>"trips" with photos of its own, "trips/day2" inside it and "trips/day2/dawn" inside that: three nested sequences.</summary>
|
||||
private static async Task<List<Guid>> NestedAsync(ArchiveFixture fx)
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user