diff --git a/src/Titano.App/Sections/ArchiveViewModel.cs b/src/Titano.App/Sections/ArchiveViewModel.cs
index eb2d11eb..89253226 100644
--- a/src/Titano.App/Sections/ArchiveViewModel.cs
+++ b/src/Titano.App/Sections/ArchiveViewModel.cs
@@ -1002,8 +1002,8 @@ public sealed class ArchiveViewModel : SectionViewModel
{
case OrphanKind.UnlistedFiles or OrphanKind.MissingFiles when row.SequenceId is { } id:
// The photos it indexes are analysed in the background, as after a scan.
- var followUps = Services.Engine;
- await Task.Run(() => archives.ReconcileAsync(id, followUps));
+ var (followUps, deep) = (Services.Engine, Services.Settings.DeepAnalysisAfterScan);
+ await Task.Run(() => archives.ReconcileAsync(id, followUps, deep));
break;
case OrphanKind.MissingSequence when row.SequenceId is { } id:
var confirmed = Services.Dialogs.Confirm(new ConfirmRequest
diff --git a/src/Titano.Data/Archiving/ArchiveService.cs b/src/Titano.Data/Archiving/ArchiveService.cs
index fef451a5..94969be5 100644
--- a/src/Titano.Data/Archiving/ArchiveService.cs
+++ b/src/Titano.Data/Archiving/ArchiveService.cs
@@ -288,15 +288,18 @@ public sealed class ArchiveService : IJobHandlerProvider
///
/// Orphans fix: index the unlisted photos of a sequence and flag its missing files. Photos added, gone or back clear
/// what covered the frames, as a scan's reconcile does (), and what a scan's
- /// follow-ups would make again is queued on (null: nothing): the light analysis and, on a
- /// server (), the thumbnails and proxies. A kind the engine does
- /// not run, or already queued for the sequence, is left out.
+ /// follow-ups would make again is queued on (null: nothing): the light analysis, a
+ /// background deep analysis when asks (as
+ /// does for a scan) and, on a server (), the thumbnails and proxies.
+ /// A kind the engine does not run, or one a queued job of that kind already covers for the sequence, is left out.
///
- public async Task ReconcileAsync(Guid sequenceId, JobEngine? followUps, CancellationToken cancellationToken = default)
+ public async Task ReconcileAsync(Guid sequenceId, JobEngine? followUps, bool deepAnalysis, CancellationToken cancellationToken = default)
{
var (archive, sequence) = await LoadSequenceAsync(sequenceId, cancellationToken).ConfigureAwait(false);
if (!await Indexer.ReconcileAsync(archive, sequence, cancellationToken).ConfigureAwait(false) || followUps is null) return;
List requests = [ProcessingJobs.LightAnalysis([sequenceId], sequence.DisplayTitle)];
+ // BRIEF ยง10.2: background, low priority.
+ if (deepAnalysis) requests.Add(ProcessingJobs.DeepAnalysis([sequenceId], sequence.DisplayTitle) with { Priority = JobPriority.Background });
if (_writer.Options.ImagesAfterScan)
{
requests.Add(ArchiveJobs.Thumbnails([sequenceId], sequence.DisplayTitle));
@@ -305,7 +308,10 @@ public sealed class ArchiveService : IJobHandlerProvider
}
foreach (var request in requests)
{
- if (!followUps.Runs(request.Kind) || await _db.Jobs.IsQueuedAsync(request.Kind, sequenceId, cancellationToken).ConfigureAwait(false)) continue;
+ if (!followUps.Runs(request.Kind)) continue;
+ // A queued job runs after the fix, on the frames as they are then, whatever else it targets (a scan's follow-ups).
+ var queued = await _db.Jobs.ListQueuedAsync(request.Kind, 1000, cancellationToken).ConfigureAwait(false);
+ if (queued.Any(j => j.TargetIds.Contains(sequenceId))) continue;
await followUps.EnqueueAsync(request, cancellationToken: cancellationToken).ConfigureAwait(false);
}
}
diff --git a/tests/Titano.Data.Tests/Archiving/ArchiveIntegrityTests.cs b/tests/Titano.Data.Tests/Archiving/ArchiveIntegrityTests.cs
index b2b4fc2f..d8a4ec4d 100644
--- a/tests/Titano.Data.Tests/Archiving/ArchiveIntegrityTests.cs
+++ b/tests/Titano.Data.Tests/Archiving/ArchiveIntegrityTests.cs
@@ -113,7 +113,7 @@ public sealed class ArchiveIntegrityTests(TestContext context)
Assert.Equal(manifest.Frames[0].Id, orphans.MissingFiles.Single().Id);
Assert.SequenceEqual(["New folder"], report.UnindexedFolders);
- await fx.Service.ReconcileAsync(id, null, fx.Ct);
+ await fx.Service.ReconcileAsync(id, null, deepAnalysis: false, fx.Ct);
var frames = await fx.Db.Frames.ListBySequenceAsync(id);
Assert.Equal(4, frames.Count);
Assert.Equal(FrameFlags.Missing, frames[0].Flags);
@@ -136,9 +136,10 @@ public sealed class ArchiveIntegrityTests(TestContext context)
var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id, fx.Ct))!.Folder);
File.WriteAllBytes(Path.Combine(folder.Originals, "dropped.JPG"), Photos.Jpeg(Start.AddMinutes(5), 50));
- // The fix indexes the photo copied in by hand, and queues the thumbnails and proxies of the frames as they are now.
+ // The fix indexes the photo copied in by hand, and queues the thumbnails and proxies of the frames as they are now;
+ // no analysis, even when asked for one.
var before = (await fx.Db.Jobs.ListAsync(null, null, 100, null, fx.Ct)).Items.Select(j => j.Id).ToHashSet();
- await server.ReconcileAsync(id, engine, fx.Ct);
+ await server.ReconcileAsync(id, engine, deepAnalysis: true, fx.Ct);
var queued = (await fx.Db.Jobs.ListAsync(null, null, 100, null, fx.Ct)).Items.Where(j => !before.Contains(j.Id)).ToList();
Assert.SequenceEqual([JobKind.Proxies, JobKind.Thumbs], queued.Select(j => j.Kind).Order());
foreach (var job in queued)
diff --git a/tests/Titano.Data.Tests/Processing/AnalysisFollowUpTests.cs b/tests/Titano.Data.Tests/Processing/AnalysisFollowUpTests.cs
index 3b90dabe..74acf7d3 100644
--- a/tests/Titano.Data.Tests/Processing/AnalysisFollowUpTests.cs
+++ b/tests/Titano.Data.Tests/Processing/AnalysisFollowUpTests.cs
@@ -101,13 +101,14 @@ public sealed class AnalysisFollowUpTests(TestContext context)
// light analysis it queues waits on the first new photo's probe, so what the fix left can be seen.
fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 18 }), "Roof", first: 12);
fx.Decoder.HoldProbeOf(12);
- await fx.Archive.Service.ReconcileAsync(sequence.Id, fx.Engine, fx.Ct);
+ await fx.Archive.Service.ReconcileAsync(sequence.Id, fx.Engine, deepAnalysis: false, fx.Ct);
const SequenceStatus covering = SequenceStatus.AnalyzedLight | images;
var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!;
Assert.Equal((18, SequenceStatus.None), (row.FrameCount, row.Status & covering));
Assert.Equal(SequenceStatus.None, ManifestStore.ReadSequence(folder.ManifestPath).Status & covering);
var again = (await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.Single(j => j.Id != first.Id);
Assert.SequenceEqual([sequence.Id], again.TargetIds);
+ Assert.Empty((await fx.Db.Jobs.ListAsync(null, JobKind.DeepAnalyse, cancellationToken: fx.Ct)).Items);
await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct);
fx.Decoder.Release();
@@ -118,6 +119,44 @@ public sealed class AnalysisFollowUpTests(TestContext context)
Assert.Contains("18", ProjectSettings.FromJson(await File.ReadAllTextAsync(folder.ProjectPath, fx.Ct)).Timing.FrameRate.ReasonArgs!);
}
+ [Test]
+ public async Task PhotosTheOrphansFixIndexesGetTheDeepAnalysisAScanWouldQueue()
+ {
+ await using var fx = await ProcessingFixture.CreateAsync(context);
+ var sequence = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof");
+ var lake = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Lake");
+ var folder = fx.Folder(sequence);
+ await fx.StartEngineAsync(withArchive: true);
+ Task> QueuedDeepAsync() => fx.Db.Jobs.ListQueuedAsync(JobKind.DeepAnalyse, 50, fx.Ct);
+
+ // The host asks for a deep analysis after scans: the orphans fix queues one in the background too, behind the light
+ // analysis, which waits on the first new photo's probe so the queue can be seen.
+ fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 18 }), "Roof", first: 12);
+ fx.Decoder.HoldProbeOf(12);
+ await fx.Archive.Service.ReconcileAsync(sequence.Id, fx.Engine, deepAnalysis: true, fx.Ct);
+ var light = (await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.Single();
+ var deep = (await QueuedDeepAsync()).Single();
+ Assert.SequenceEqual([sequence.Id], deep.TargetIds);
+ Assert.Equal(JobPriority.Background, deep.Priority);
+ await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct);
+
+ // The user cancels it, and asks for a deep analysis of both sequences instead. More photos and the fix again: the
+ // one waiting covers them, so no other is queued.
+ await fx.Engine.CancelAsync(deep.Id, fx.Ct);
+ var both = await fx.EnqueueAsync(Titano.Data.Processing.ProcessingJobs.DeepAnalysis([lake.Id, sequence.Id]));
+ fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 20 }), "Roof", first: 18);
+ await fx.Archive.Service.ReconcileAsync(sequence.Id, fx.Engine, deepAnalysis: true, fx.Ct);
+ Assert.SequenceEqual([both.Id], (await QueuedDeepAsync()).Select(j => j.Id));
+
+ fx.Decoder.Release();
+ await fx.WaitForAsync(light.Id, JobState.Done);
+ await fx.WaitForAsync(both.Id, JobState.Done);
+ var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!;
+ Assert.Equal(20, row.FrameCount);
+ Assert.True(row.Status.HasFlag(SequenceStatus.AnalyzedDeep), row.Status.ToString());
+ Assert.Equal(20, Titano.Data.Processing.SequenceAnalyser.ReadReport(folder, 20)?.FrameCount);
+ }
+
[Test]
public async Task AScanAskedForDeepAnalysisQueuesItInTheBackgroundForNewSequencesOnly()
{