Settings (UI-01, UI-02, UI-03, UI-09, RF-4): - New Import, Analysis and Formats pages, in the order of Settings.html. Import holds the defaults of new cards (session rules, subfolders, verification, duplicates, after-import actions); Analysis the deep-analysis width cap, night and star-field thresholds and deep analysis after import or scan; Formats the decode tier of every format on this PC with a notice and Store install link per missing codec extension. - Archive gains thumbnail size and rescan interval; its templates, proxy size and thumbnail size are the open archive's own (archive.json) and new archives' defaults. - Rendering quality, parallelism and background priority now drive the jobs: quality maps to preparation size, read-ahead and default flow quality; parallelism sets the engine's workers live and caps per-job threads; background priority raises the UI thread while Titano is in front. - Advanced gains Restore (daily backups, dry-run summary, destructive confirmation, staged for the next start) and Reset all. - The naming preview's sample title is a catalog string. Engine (ENG-03, ENG-04, ENG-06): - ArchiveService.GetSettingsAsync/UpdateSettingsAsync rewrite archive.json atomically under a lease, then the index row; the server endpoint and the desktop use them, and the desktop creates archives with Settings › Archive. ThumbnailPolicy in archive.json sizes the thumbnails. - DatabaseBackups: daily VACUUM INTO copies kept x3 on the desktop and on a server on SQLite (DatabaseBackupService), staged restore checked and preceded by a fresh copy. - Maintenance vacuums the SQLite index when 10 % or more is free (dry run reports it). - JobEngine.SetWorkers; ProcessingOptions.Tune applies host tuning per job. Archive setup toasts say why in a localized sentence (RF-1). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
148 lines
7.8 KiB
C#
148 lines
7.8 KiB
C#
using Titano.Core.Archiving;
|
|
using Titano.Core.Diagnostics.Synthetic;
|
|
using Titano.Core.Import;
|
|
using Titano.Core.Model;
|
|
using Titano.Core.Project;
|
|
using Titano.Data.Archiving;
|
|
using Titano.Data.Tests.Archiving;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.Data.Tests.Processing;
|
|
|
|
/// <summary>New sequences get their light analysis (and so their Auto values) without any user action (BRIEF §1.1).</summary>
|
|
[Category("processing")]
|
|
public sealed class AnalysisFollowUpTests(TestContext context)
|
|
{
|
|
[Test]
|
|
public async Task AnAdoptingScanQueuesLightAnalysisOfTheNewSequencesOnly()
|
|
{
|
|
await using var fx = await ProcessingFixture.CreateAsync(context);
|
|
fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof");
|
|
await fx.StartEngineAsync(withArchive: true);
|
|
|
|
var scan = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full: true));
|
|
await fx.WaitForAsync(scan.Id, JobState.Done);
|
|
var light = Assert.NotNull(await SingleLightJobAsync(fx));
|
|
await fx.WaitForAsync(light.Id, JobState.Done);
|
|
|
|
var sequence = (await fx.Db.Sequences.GetAsync(light.TargetIds.Single(), fx.Ct))!;
|
|
Assert.Equal("Roof", sequence.Folder);
|
|
Assert.True(sequence.Status.HasFlag(SequenceStatus.AnalyzedLight), "analysed");
|
|
Assert.True(ProjectSettings.FromJson(await File.ReadAllTextAsync(fx.Folder(sequence).ProjectPath, fx.Ct)).Timing.Mode.HasAdvice, "advised");
|
|
|
|
// Scans that find nothing new queue nothing more.
|
|
foreach (var full in new[] { false, true })
|
|
{
|
|
var again = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full));
|
|
await fx.WaitForAsync(again.Id, JobState.Done);
|
|
}
|
|
Assert.Equal(light.Id, (await SingleLightJobAsync(fx))?.Id);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnImportQueuesLightAnalysisOfTheSequencesItFilled()
|
|
{
|
|
await using var fx = await ProcessingFixture.CreateAsync(context);
|
|
var card = context.CreateTempDirectory("card");
|
|
Photos.WriteSeries(Path.Combine(card, "DCIM", "100CANON"), ArchiveFixture.Start, 10);
|
|
var plan = await fx.Archive.Service.PlanImportAsync(fx.Archive.Archive.Id, card, new ImportOptions(), null, null, fx.Ct);
|
|
await fx.StartEngineAsync(withArchive: true);
|
|
|
|
var import = await fx.Engine.EnqueueAsync(ArchiveJobs.Import(fx.Archive.Archive, plan, null), createdBy: Guid.CreateVersion7(), cancellationToken: fx.Ct);
|
|
await fx.WaitForAsync(import.Id, JobState.Done);
|
|
var light = Assert.NotNull(await SingleLightJobAsync(fx));
|
|
await fx.WaitForAsync(light.Id, JobState.Done);
|
|
|
|
var sequenceId = await fx.Db.Sequences.FindBySessionKeyAsync(fx.Archive.Archive.Id, plan.Sessions.Single().SessionKey, fx.Ct);
|
|
Assert.SequenceEqual([Assert.NotNull(sequenceId)], light.TargetIds);
|
|
Assert.Equal(import.CreatedBy, light.CreatedBy);
|
|
Assert.Equal(JobPriority.Background, light.Priority);
|
|
Assert.True((await fx.Db.Sequences.GetAsync(sequenceId.Value, fx.Ct))!.Status.HasFlag(SequenceStatus.AnalyzedLight), "analysed");
|
|
}
|
|
|
|
[Test]
|
|
public async Task PhotosAddedToAnAnalysedFolderAreAnalysedAgain()
|
|
{
|
|
await using var fx = await ProcessingFixture.CreateAsync(context);
|
|
var sequence = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof");
|
|
await fx.StartEngineAsync(withArchive: true);
|
|
var first = await fx.EnqueueAsync(Titano.Data.Processing.ProcessingJobs.LightAnalysis([sequence.Id]));
|
|
await fx.WaitForAsync(first.Id, JobState.Done);
|
|
|
|
// The camera kept shooting into the folder: the next scan indexes the new photos and analyses the sequence again.
|
|
fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 18 }), "Roof", first: 12);
|
|
var scan = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive));
|
|
await fx.WaitForAsync(scan.Id, JobState.Done);
|
|
var again = (await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.Single(j => j.Id != first.Id);
|
|
await fx.WaitForAsync(again.Id, JobState.Done);
|
|
|
|
var analysed = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!;
|
|
Assert.Equal(18, analysed.FrameCount);
|
|
Assert.True(analysed.Status.HasFlag(SequenceStatus.AnalyzedLight), "analysed again");
|
|
Assert.True(ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Status.HasFlag(SequenceStatus.AnalyzedLight), "sidecar status");
|
|
}
|
|
|
|
[Test]
|
|
public async Task AScanAskedForDeepAnalysisQueuesItInTheBackgroundForNewSequencesOnly()
|
|
{
|
|
await using var fx = await ProcessingFixture.CreateAsync(context);
|
|
fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof");
|
|
await fx.StartEngineAsync(withArchive: true);
|
|
|
|
var scan = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full: true, deepAnalysis: true));
|
|
await fx.WaitForAsync(scan.Id, JobState.Done);
|
|
var deep = (await fx.Db.Jobs.ListAsync(null, JobKind.DeepAnalyse, cancellationToken: fx.Ct)).Items.Single();
|
|
Assert.Equal(JobPriority.Background, deep.Priority);
|
|
Assert.NotNull(await SingleLightJobAsync(fx));
|
|
var done = await fx.WaitForAsync(deep.Id, JobState.Done);
|
|
|
|
var sequence = (await fx.Db.Sequences.GetAsync(done.TargetIds.Single(), fx.Ct))!;
|
|
Assert.Equal("Roof", sequence.Folder);
|
|
Assert.True(sequence.Status.HasFlag(SequenceStatus.AnalyzedDeep), "analysed in depth");
|
|
|
|
// A scan that indexes nothing new asks for nothing; a scan without the option never does.
|
|
var again = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full: true, deepAnalysis: true));
|
|
await fx.WaitForAsync(again.Id, JobState.Done);
|
|
fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Lake");
|
|
var plain = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive));
|
|
await fx.WaitForAsync(plain.Id, JobState.Done);
|
|
Assert.Count(1, (await fx.Db.Jobs.ListAsync(null, JobKind.DeepAnalyse, cancellationToken: fx.Ct)).Items);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceWaitingForLightAnalysisIsNotQueuedAgain()
|
|
{
|
|
await using var fx = await ProcessingFixture.CreateAsync(context);
|
|
var sequence = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof");
|
|
// Queued before the scan, which runs first (user priority) and finds the sequence not analysed yet.
|
|
var waiting = await QueueAsync(fx, Titano.Data.Processing.ProcessingJobs.LightAnalysis([sequence.Id]));
|
|
var scan = await QueueAsync(fx, ArchiveJobs.Scan(fx.Archive.Archive, full: true));
|
|
await fx.StartEngineAsync(withArchive: true);
|
|
|
|
await fx.WaitForAsync(scan.Id, JobState.Done);
|
|
await fx.WaitForAsync(waiting.Id, JobState.Done);
|
|
Assert.Equal(waiting.Id, (await SingleLightJobAsync(fx))?.Id);
|
|
}
|
|
|
|
/// <summary>Queues a job before the engine starts.</summary>
|
|
private static async Task<Job> QueueAsync(ProcessingFixture fx, Titano.Data.Archiving.Jobs.ArchiveJobRequest request)
|
|
{
|
|
var job = new Job
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
Kind = request.Kind,
|
|
TargetIds = request.Targets,
|
|
TargetLabel = request.Label,
|
|
ParametersJson = request.ParametersJson,
|
|
Priority = request.Priority,
|
|
State = JobState.Queued,
|
|
Created = DateTimeOffset.UtcNow,
|
|
};
|
|
await fx.Db.Jobs.EnqueueAsync(job, fx.Ct);
|
|
return job;
|
|
}
|
|
|
|
private static async Task<Job?> SingleLightJobAsync(ProcessingFixture fx) =>
|
|
(await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.SingleOrDefault();
|
|
}
|