diff --git a/i18n/en/Advisor.resx b/i18n/en/Advisor.resx index 655316d0..20b6c7c3 100644 --- a/i18n/en/Advisor.resx +++ b/i18n/en/Advisor.resx @@ -55,6 +55,7 @@ Deep analysis of {0}: frames {1}, warnings {2}.job log line; {0} sequence title; {1} frame count; {2} warning count {0} could not be analysed: {1}long: job log line; {0} sequence title; {1} reason The photos of {0} changed during the analysis, so its results were not applied; a light analysis follows.job log line; {0} sequence title + Another Titano changed the photos of {0}, so the results of the analysis were not applied; the next scan indexes them.job log line; {0} sequence title Light analysis of {0}: frames {1}, warnings {2}.job log line; {0} sequence title; {1} frame count; {2} warning count Suggested presets: {0}job log line; {0} preset names separated by dots The project settings of {0} cannot be read; their automatic values were left as they were.job log line; {0} sequence title diff --git a/i18n/it/Advisor.it.resx b/i18n/it/Advisor.it.resx index 9d9e0a73..6e2b682a 100644 --- a/i18n/it/Advisor.it.resx +++ b/i18n/it/Advisor.it.resx @@ -55,6 +55,7 @@ Analisi approfondita di {0}: fotogrammi {1}, avvisi {2}. Impossibile analizzare {0}: {1} Le foto di {0} sono cambiate durante l'analisi, quindi i risultati non sono stati applicati; segue un'analisi rapida. + Un altro Titano ha cambiato le foto di {0}, quindi i risultati dell'analisi non sono stati applicati; la prossima scansione le indicizza. Analisi rapida di {0}: fotogrammi {1}, avvisi {2}. Preset suggeriti: {0} Le impostazioni del progetto di {0} non sono leggibili; i valori automatici sono rimasti invariati. diff --git a/src/Titano.Data/Processing/Jobs/AnalyseJobHandler.cs b/src/Titano.Data/Processing/Jobs/AnalyseJobHandler.cs index 04ba56f9..2297eda2 100644 --- a/src/Titano.Data/Processing/Jobs/AnalyseJobHandler.cs +++ b/src/Titano.Data/Processing/Jobs/AnalyseJobHandler.cs @@ -44,7 +44,7 @@ internal sealed class AnalyseJobHandler(TitanoDatabase db, SequenceAnalyser anal var outcome = await analyser.AnalyseAsync(targets[i], deep, progress, context.Cancellation).ConfigureAwait(false); await chain.FlushAsync().ConfigureAwait(false); if (outcome is null) context.Log(Loc.L("Archive.Log.SequenceMissing", targets[i])); - else if (outcome.FramesChanged) await AnalyseAgainAsync(context, outcome.Sequence).ConfigureAwait(false); + else if (outcome.FramesChanged != FramesChange.None) await NotRecordedAsync(context, outcome).ConfigureAwait(false); else Report(context, outcome, deep); } catch (Exception ex) when (ex is not (OperationCanceledException or ArchiveOfflineException)) @@ -65,12 +65,19 @@ internal sealed class AnalyseJobHandler(TitanoDatabase db, SequenceAnalyser anal } /// - /// A sequence whose frames changed while it was analysed, with no light analysis queued for it: nothing was recorded - /// from the frames the analysis read, so a light analysis of the frames as they are is queued (the deep report it saved - /// counts only for the frames it describes). + /// A sequence whose frames changed while it was analysed: nothing was recorded from the frames the analysis read (the + /// deep report it saved counts only for the frames it describes). When this index holds the frames as they are, and no + /// light analysis is queued for it, one is queued; frames another process changed are analysed by that process, and + /// indexed here by the next scan (). /// - private async Task AnalyseAgainAsync(JobContext context, Sequence sequence) + private async Task NotRecordedAsync(JobContext context, AnalysisOutcome outcome) { + var sequence = outcome.Sequence; + if (outcome.FramesChanged == FramesChange.NotIndexed) + { + context.Log(Loc.L("Advisor.Log.FramesChangedElsewhere", sequence.DisplayTitle)); + return; + } context.Log(Loc.L("Advisor.Log.FramesChanged", sequence.DisplayTitle)); await AnalysisFollowUp.QueueAsync(db, context, [sequence.Id], sequence.DisplayTitle).ConfigureAwait(false); } diff --git a/src/Titano.Data/Processing/SequenceAnalyser.cs b/src/Titano.Data/Processing/SequenceAnalyser.cs index 331d9c29..5cc5994f 100644 --- a/src/Titano.Data/Processing/SequenceAnalyser.cs +++ b/src/Titano.Data/Processing/SequenceAnalyser.cs @@ -16,10 +16,29 @@ namespace Titano.Data.Processing; /// The advisor changed Auto values of the project. /// The project could not be read, so its Auto values were left alone. /// Sequence presets that fit the content (deep analysis only). -/// Frames were added, removed or renumbered while it ran and no light analysis was queued to -/// cover them: nothing was recorded from the frames it read, and a light analysis must run for the frames as they are. +/// How the frames it read were no longer the sequence's when it recorded: anything but +/// means nothing was recorded from them. internal sealed record AnalysisOutcome(Sequence Sequence, int Frames, int Warnings, bool SettingsChanged, bool SettingsUnreadable, - IReadOnlyList Presets, bool FramesChanged = false); + IReadOnlyList Presets, FramesChange FramesChanged = FramesChange.None); + +/// How the frames an analysis read had changed by the time it recorded, under the sequence lock. +internal enum FramesChange +{ + /// Still the sequence's frames, or changed in this index with a light analysis queued to replace what it records. + None, + + /// + /// Added, removed or renumbered in this index (an upload, an import, a scan), with no light analysis queued: one must + /// run here for the frames as they are. + /// + Indexed, + + /// + /// Changed in the sidecar by another process (a desktop sharing a server's archive, or that server), which analyses + /// them; this index holds them only after its next scan, which on a server queues their analysis here too. + /// + NotIndexed, +} /// /// Light (BRIEF §10.1) and deep (§10.2) analysis of archived sequences, followed by the advisor (§10.3–10.4) filling the @@ -74,11 +93,14 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti // proxy that arrived while it ran (for hours) makes its verdict on that frame's original stale. The light analysis // the proxy queued then either ran before this, and the advice, status and warnings stay without the report as it // left them, or runs after. A pass whose frames were added to, removed or renumbered since it read them records - // nothing (SupersededAsync), and a light analysis of the frames as they are runs instead. + // nothing (FramesChangeAsync), and a light analysis of the frames as they are runs instead, here or where they + // were changed. await using (await writer.LockAsync(paths, sequence.Id, cancellationToken).ConfigureAwait(false)) { - if (await SupersededAsync(sequence, cancellationToken).ConfigureAwait(false)) - return new AnalysisOutcome(sequence, frames.Count, 0, SettingsChanged: false, SettingsUnreadable: false, [], FramesChanged: true); + var manifest = SequenceWriter.ReadLocked(folder, sequence.Id); + var change = await FramesChangeAsync(sequence, manifest, cancellationToken).ConfigureAwait(false); + if (change != FramesChange.None) + return new AnalysisOutcome(sequence, frames.Count, 0, SettingsChanged: false, SettingsUnreadable: false, [], change); if (deep) { var now = await SequenceFrames.LoadAsync(db, archive, sequence, useProxies: false, options.Archive.Decoder, cancellationToken).ConfigureAwait(false); @@ -105,7 +127,6 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti | (warnings > 0 ? SequenceStatus.HasWarnings : SequenceStatus.None); // Without a current report (none, or made before frames were added) the deep status no longer holds. var clear = (report is null ? SequenceStatus.AnalyzedDeep : SequenceStatus.None) | (warnings > 0 ? SequenceStatus.None : SequenceStatus.HasWarnings); - var manifest = SequenceWriter.ReadLocked(folder, sequence.Id); var inStep = await indexer.InStepAsync(archive, folder, manifest, cancellationToken).ConfigureAwait(false); var status = (manifest.Status | set) & ~clear; if (status != manifest.Status) ManifestStore.WriteSequence(folder.ManifestPath, manifest with { Status = status, UpdatedAt = DateTimeOffset.UtcNow }); @@ -120,22 +141,29 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti } /// - /// Whether, under the sequence lock, the index no longer holds the frames this pass read, and no light analysis is - /// queued to analyse them as they are. The row's frames version moved since the pass read the row: every writer of - /// the index's frames bumps it with them under the same lock (an upload or import, a scan reconciling photos copied in - /// by hand or indexing frames another process listed in the sidecar). What the pass found then describes other frames: + /// How the frames this pass read had changed by now, under the sequence lock. Every writer of this index's frames bumps + /// the row's frames version with them under the same lock (an upload or import, a scan reconciling photos copied in by + /// hand or indexing frames another process listed in the sidecar), and every writer of the sidecar's frames bumps its + /// version (, read under the lock). What the pass found then describes other frames: /// recorded, it would mark the new ones analysed, with Auto values and warnings counted on the old ones, over what an - /// analysis of the frames as they are may have recorded already. A light analysis already queued for the sequence runs - /// after this on the frames as they are then, so the pass still records meanwhile, as an image pass keeps its flag - /// (): during an upload burst every pass is overtaken, and a sequence being shot would - /// otherwise show no analysis until uploads paused. The sidecar's version is not compared: frames another process - /// listed there reach the index through a scan, which queues their analysis, and comparing with it would queue the - /// analysis again and again until then. + /// analysis of the frames as they are may have recorded already, in the shared sidecar and project.json too. + /// A sidecar at another version than the row lists frames another process changed and this index does not hold yet + /// (): nothing is queued here, since a light analysis would read this index as + /// it is and find it behind the sidecar again until the next scan indexes them. A row whose version moved since the + /// pass read it holds the frames as they are, and a light analysis here covers them (). + /// One already queued for the sequence runs after this on the frames as they are then, so the pass still records + /// meanwhile, as an image pass keeps its flag (): during an upload burst every pass is + /// overtaken, and a sequence being shot would otherwise show no analysis until uploads paused. /// - private async Task SupersededAsync(Sequence sequence, CancellationToken cancellationToken) => - await db.Sequences.GetAsync(sequence.Id, cancellationToken).ConfigureAwait(false) is { } row - && row.FramesVersion != sequence.FramesVersion - && !await db.Jobs.IsQueuedAsync(JobKind.LightAnalyse, sequence.Id, cancellationToken).ConfigureAwait(false); + private async Task FramesChangeAsync(Sequence sequence, SequenceManifest manifest, CancellationToken cancellationToken) + { + if (await db.Sequences.GetAsync(sequence.Id, cancellationToken).ConfigureAwait(false) is not { } row) return FramesChange.None; + if (manifest.Versions.Frames != row.FramesVersion) return FramesChange.NotIndexed; + return row.FramesVersion == sequence.FramesVersion + || await db.Jobs.IsQueuedAsync(JobKind.LightAnalyse, sequence.Id, cancellationToken).ConfigureAwait(false) + ? FramesChange.None + : FramesChange.Indexed; + } /// /// The saved deep report when it describes as this host reads them now: also stale when a diff --git a/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs b/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs index 24279498..93262ac4 100644 --- a/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs +++ b/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs @@ -17,6 +17,7 @@ using Titano.Core.Model; using Titano.Core.Project; using Titano.Data.Archiving; using Titano.Data.Archiving.Jobs; +using Titano.Data.Jobs; using Titano.Data.Processing; using Titano.Data.Processing.Jobs; using Titano.Data.Repositories; @@ -291,6 +292,42 @@ public sealed class AnalysisJobTests(TestContext context) Assert.Equal(advice, await ProjectJsonAsync(fx, folder)); } + [Test] + public async Task AnAnalysisOvertakenWhileALightAnalysisWaitsRecordsAndThatOneReplacesIt() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Flickering(12)); + var folder = fx.Folder(sequence); + await fx.StartEngineAsync(); + + // A deep analysis starts on twelve frames on the only worker; while it runs a thirteenth photo is indexed, and its + // light analysis waits in the queue, as during an upload burst. + fx.Decoder.HoldFrame(0); + var deep = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); + await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); + await fx.AddAsync(Flickering(13), first: 12); + var light = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); + fx.Decoder.Hold = null; + fx.Decoder.Release(); + // The light analysis waits on the new photo's probe, so what the deep pass left can be seen. + fx.Decoder.HoldProbeOf(12); + var done = await fx.WaitForAsync(deep.Id, JobState.Done); + + // The deep pass records the analysis of the frames it read meanwhile, and queues nothing more. + var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; + Assert.Contains(Loc.L("Advisor.Log.DeepDone", sequence.DisplayTitle, 12, row.WarningCount), done.LogTail); + Assert.False(done.LogTail!.Contains(Loc.L("Advisor.Log.FramesChanged", sequence.DisplayTitle), StringComparison.Ordinal), done.LogTail); + Assert.True(row.Status.HasFlag(SequenceStatus.AnalyzedLight), "index status"); + Assert.True(ManifestStore.ReadSequence(folder.ManifestPath).Status.HasFlag(SequenceStatus.AnalyzedLight), "sidecar status"); + Assert.SequenceEqual([light.Id], (await LightJobsAsync(fx)).Select(j => j.Id)); + + // The light analysis that waited replaces it with the analysis of all thirteen. + await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); + fx.Decoder.Release(); + await fx.WaitForAsync(light.Id, JobState.Done); + Assert.Contains("13", ProjectSettings.FromJson(await ProjectJsonAsync(fx, folder)).Timing.FrameRate.ReasonArgs!); + } + [Test] public async Task ALightAnalysisOvertakenByAScanMarksNothingAnalysedAndRunsAgain() { @@ -326,6 +363,64 @@ public sealed class AnalysisJobTests(TestContext context) Assert.Contains("13", ProjectSettings.FromJson(await ProjectJsonAsync(fx, folder)).Timing.FrameRate.ReasonArgs!); } + [Test] + public async Task AnAnalysisOfPhotosAnotherTitanoChangedLeavesWhatThatTitanoRecorded() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Flickering(12)); + var folder = fx.Folder(sequence); + await fx.StartEngineAsync(); + // A server sharing this desktop's archive, with its own index and analysis. + await using var serverDb = await TitanoDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory("server"), "titano.db")), fx.Ct); + var serverOptions = fx.Processing.Options with + { + Archive = new ArchiveServiceOptions { Decoder = new ImageDecoder([new ManagedDecoderProvider()]), Owner = "server", LeaseWait = TimeSpan.FromSeconds(20) }, + }; + var server = new ArchiveService(serverDb, serverOptions.Archive); + var archive = await server.OpenAsync(fx.Archive.Archive.RootPath, fx.Ct); + await server.Indexer.ScanAsync(archive, ScanMode.Incremental, null, _ => ValueTask.CompletedTask, fx.Ct); + await using var serverEngine = new JobEngine(serverDb, new ProcessingService(serverDb, serverOptions).CreateJobHandlers(), + new JobEngineOptions { Workers = 1, WorkerId = "server", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }); + await serverEngine.StartAsync(fx.Ct); + + // A light analysis here reads twelve frames; before it records, the server takes a thirteenth photo and analyses + // the sequence as it is now, in the shared sidecar and project. + fx.Decoder.HoldProbeOf(0); + var light = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); + await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); + var staged = fx.Archive.Stage(new DateTime(2024, 6, 21, 19, 2, 0), seed: 90); + await server.Ingest.CommitAsync(new IngestRequest(archive.Id, sequence.Id, null, null, staged.Path, "IMG_0013.JPG", staged.Size, staged.Sha256, null, null), + fx.Ct); + var analysed = await serverEngine.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id]), cancellationToken: fx.Ct); + for (var until = DateTime.UtcNow.AddSeconds(60); (await serverDb.Jobs.GetAsync(analysed.Id, fx.Ct))!.State != JobState.Done;) + { + Assert.True(DateTime.UtcNow < until, "the server's light analysis ends"); + await Task.Delay(20, fx.Ct); + } + var advice = await ProjectJsonAsync(fx, folder); + Assert.Contains("13", ProjectSettings.FromJson(advice).Timing.FrameRate.ReasonArgs!); + var status = ManifestStore.ReadSequence(folder.ManifestPath).Status; + Assert.True(status.HasFlag(SequenceStatus.AnalyzedLight), "the server's status"); + fx.Decoder.Release(); + var done = await fx.WaitForAsync(light.Id, JobState.Done); + + // This index still holds twelve frames: the analysis here records nothing over the server's, and queues nothing. + Assert.Contains(Loc.L("Advisor.Log.FramesChangedElsewhere", sequence.DisplayTitle), done.LogTail); + Assert.Equal(advice, await ProjectJsonAsync(fx, folder)); + Assert.Equal(status, ManifestStore.ReadSequence(folder.ManifestPath).Status); + var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; + Assert.Equal(12, row.FrameCount); + Assert.False(row.Status.HasFlag(SequenceStatus.AnalyzedLight), "index status"); + Assert.SequenceEqual([light.Id], (await LightJobsAsync(fx)).Select(j => j.Id)); + + // The next scan here indexes the photo with the server's analysis, which a desktop keeps. + Assert.Contains(sequence.Id, (await fx.Archive.ScanAsync()).Sequences); + row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; + Assert.Equal(13, row.FrameCount); + Assert.True(row.Status.HasFlag(SequenceStatus.AnalyzedLight), "index status"); + Assert.Equal(advice, await ProjectJsonAsync(fx, folder)); + } + [Test] public async Task AFrameTheDeepAnalysisCouldNotReadIsReadAgainOnceItsProxyArrives() {