From 827b224ee322e04a5bb4bda7c5e90bf76aabb8b0 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 19:59:45 +0000 Subject: [PATCH] fix(editor): read inserted frames before a render embeds the project A render queued before the editor had seen frames inserted under it (a sync download, an import of earlier photos, a scan without an event) embedded the project's positions in the old frame order. Render now checks first that the frames read are still the sequence's (ISequenceSource.FramesCurrentAsync: the row's frames version on this PC, the manifest on a server). On this PC the sequence is read again and the positions follow the frames; a server sequence whose frames changed turns outdated and the render is not queued. Reads of the sequence no longer overlap: a read waits for the one under way, saves that meet new frames read them through the same slot, and they save the project as it is once its positions followed. The frame on screen stays on its photo when frames are inserted or removed before it. Tests: the event-loss test waits for the listener's subscription before dropping the stream, and the conflict tests flush once more after the choice when a retry started before it was still failing. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.App/Editor/EditorSession.cs | 59 ++++++++++--- src/Titano.App/Editor/EditorViewModel.cs | 28 ++++++- src/Titano.App/Editor/ISequenceSource.cs | 8 ++ src/Titano.App/Editor/LocalSequenceSource.cs | 8 ++ src/Titano.App/Editor/RemoteSequenceSource.cs | 26 +++++- .../Titano.App.Tests/Editor/EditorFixture.cs | 36 +++++++- .../Editor/EditorSessionTests.cs | 83 +++++++++++++++++++ .../Editor/EditorSmokeTests.cs | 31 +++++++ .../Editor/FakeRemoteSequenceApi.cs | 5 ++ .../Editor/ProjectStoreTests.cs | 61 +++++++++++--- .../Editor/RemoteSequenceSourceTests.cs | 37 ++++++++- 11 files changed, 351 insertions(+), 31 deletions(-) diff --git a/src/Titano.App/Editor/EditorSession.cs b/src/Titano.App/Editor/EditorSession.cs index 56b9f2f1..6ee1beea 100644 --- a/src/Titano.App/Editor/EditorSession.cs +++ b/src/Titano.App/Editor/EditorSession.cs @@ -32,7 +32,10 @@ public sealed class EditorSession : IAsyncDisposable private readonly ProjectSaver _saver; private ProjectSettings _basis; - /// The sequence being read again () until its content is taken: saves wait for it. + /// + /// The sequence being read again () until its content is taken: saves and other reads wait + /// for it. + /// private Task _reading = Task.CompletedTask; public EditorSession(ISequenceSource source, SequenceContent content, IReadOnlyList codecs, TimeSpan? saveDelay = null) @@ -209,15 +212,30 @@ public sealed class EditorSession : IAsyncDisposable public Task SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken = default) => Source.SubmitAsync(request, cancellationToken); + /// + /// Makes the project's frame positions name the sequence's frames as they are now, before the project is taken along + /// (a render embeds it): frames inserted since the last read (a sync download, an import of earlier photos, a scan) + /// are read again and the positions follow them (). A server sequence whose frames changed + /// becomes outdated instead (: read-only, its renders refused). + /// + public async Task EnsureFramesAsync(CancellationToken cancellationToken = default) + { + while (!_reading.IsCompleted) await _reading; + var current = await Source.FramesCurrentAsync(cancellationToken); + // A read that began meanwhile (a save that met the new frames) may have taken them already: it ends first. + while (!_reading.IsCompleted) await _reading; + if (!current && !IsRemote) await ReloadAsync(cancellationToken); + } + /// /// Reads the sequence again (an analysis finished): new reports and advice, the frames with the project's positions - /// following them (), the stored project merged into the open one. Saves wait until it is taken. + /// following them (), the stored project merged into the open one. Saves wait until it is taken, + /// and a read waits for the one under way, so each follows the frames the one before it took. /// public async Task ReloadAsync(CancellationToken cancellationToken = default) { await _saver.FlushAsync(); - var taken = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _reading = taken.Task; + var taken = await BeginReadAsync(); try { var content = await Source.LoadAsync(cancellationToken); @@ -257,23 +275,34 @@ public sealed class EditorSession : IAsyncDisposable /// Takes as the sequence. Frames inserted or removed since the last read (a sync download, /// an import of earlier photos, a scan) moved the stored project's frame positions with their frames: the editor's /// project, its undo and redo steps and its basis move the same way (), so - /// they keep naming the frames the user chose. Returns that move (none when the frames are the same). + /// they keep naming the frames the user chose. Call while the read is under way (). /// - private Func Follow(SequenceContent content) + private void Follow(SequenceContent content) { var before = Content.Frames.Select(f => f.Id).ToList(); (Content, Context, Advice, Presets) = Analyse(content, _codecs); - if (before.SequenceEqual(content.Frames.Select(f => f.Id))) return static project => project; + if (before.SequenceEqual(content.Frames.Select(f => f.Id))) return; var after = content.Frames; Log.Info("editor", $"The frames of {content.Sequence.DisplayTitle} changed while it was open; its frame positions follow them"); _basis = Move(_basis); History.Remap(Move); - return Move; ProjectSettings Move(ProjectSettings project) => NamesFrames(project) && ProjectSettings.FollowFrames(project.ToJson(), before, after) is { } moved ? ProjectSettings.FromJson(moved) : project; } + /// + /// Waits for the read under way (two jobs that end together read the sequence one after the other), then marks a new + /// one under way until the returned source is completed. + /// + private async Task BeginReadAsync() + { + while (!_reading.IsCompleted) await _reading; + var taken = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + _reading = taken.Task; + return taken; + } + /// Exclusions, a hero, keyframes or frames waiting for their photos: positions that follow frames. private static bool NamesFrames(ProjectSettings project) => project.ExcludedFrames.Count > 0 || project.HeroFrame is not null || project.Camera.Keyframes.Count > 0 || project.PendingFrames is { Count: > 0 }; @@ -334,8 +363,18 @@ public sealed class EditorSession : IAsyncDisposable catch (FramesChangedException) when (attempt < FollowAttempts) { // Frames were inserted under the editor and the stored positions moved with them: the frames are read - // again, this edit's positions follow them too, and it is saved in the new order. - project = Follow(await Source.LoadAsync(CancellationToken.None))(project); + // again (after a read under way, whose move this edit's snapshot missed), the project's positions follow + // them, and the project as it is then, which contains this edit, is saved in the new order. + var taken = await BeginReadAsync(); + try + { + Follow(await Source.LoadAsync(CancellationToken.None)); + } + finally + { + taken.SetResult(); + } + project = Project; ContentChanged?.Invoke(); } catch (ProjectConflictException ex) diff --git a/src/Titano.App/Editor/EditorViewModel.cs b/src/Titano.App/Editor/EditorViewModel.cs index 2e4ca35a..a3f11ca8 100644 --- a/src/Titano.App/Editor/EditorViewModel.cs +++ b/src/Titano.App/Editor/EditorViewModel.cs @@ -48,6 +48,9 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable private readonly AsyncRelayCommand _cancelServerJob; private PreviewRenderer _renderer; private int _currentIndex; + + /// The frame on screen: it stays on screen when frames are inserted or removed before it. + private Guid _currentFrameId; private EditorTab _selectedTab; private ImageSource? _previewImage; private ImageSource? _originalImage; @@ -111,6 +114,7 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable Tabs = [Frames, Exposure, new MotionTab(this), new CameraTab(this), new TimeTab(this), new StackTab(this), new ExportTab(this)]; _selectedTab = Exposure; _currentIndex = session.Project.HeroFrame is { } hero && (uint)hero < (uint)FrameCount ? hero : 0; + _currentFrameId = FrameId(_currentIndex); // Until the link is read (AttachJobsAsync), a sequence of this PC cannot send its renders. _syncGate = session.IsRemote ? ExportSyncGate.Remote : ExportSyncGate.SignedOut; RenderChoices = [.. ExportPresets.BuiltIn.Select(p => new Choice(p.Id, p.NameKey))]; @@ -233,6 +237,7 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable set { var clamped = FrameCount == 0 ? 0 : int.Clamp(value, 0, FrameCount - 1); + _currentFrameId = FrameId(clamped); if (!Set(ref _currentIndex, clamped)) return; foreach (var tab in Tabs) tab.OnCurrentFrameChanged(); UpdateInfo(); @@ -515,6 +520,10 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable /// public async Task RenderAsync(JobPriority priority, bool batch) { + // The job embeds the project: its frame positions follow frames inserted since the editor read them first. A server + // sequence whose frames changed is outdated instead, and its toast says so and offers fresh proxies. + await Session.EnsureFramesAsync(); + if (IsOutdated) return; var export = batch ? RenderExport : RenderExport with { Batch = [] }; var requests = Session.RenderRequests(export); foreach (var request in requests) await Session.SubmitAsync(request with { Priority = priority }); @@ -801,6 +810,9 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable private void OnContentChanged() { + // The frame on screen stays on screen, wherever frames inserted or removed before it put it (the tabs that reload + // below may seek meanwhile). + var shown = IndexOfFrame(_currentFrameId) ?? int.Min(CurrentIndex, int.Max(0, FrameCount - 1)); _renderer = new PreviewRenderer(Session.Content, Session.Source); Planner = new ExportPlanner(Session.Content, _encoders, _host); if (Thumbnails.Count != FrameCount) Thumbnails = new EditorThumbnails(Session.Source, FrameCount); @@ -808,13 +820,27 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable foreach (var tab in Tabs) tab.OnContentChanged(); OnPropertyChanged(nameof(Summary)); OnPropertyChanged(nameof(FrameCount)); - CurrentIndex = int.Min(CurrentIndex, int.Max(0, FrameCount - 1)); + CurrentIndex = shown; UpdateMarkers(); RequestCorrections(); RequestPlan(); RequestPreview(immediate: true); } + /// The id of frame ; empty when there is none. + private Guid FrameId(int index) => (uint)index < (uint)FrameCount ? Session.Content.Frames[index].Id : Guid.Empty; + + /// Where frame is now; null when the sequence no longer has it. + private int? IndexOfFrame(Guid id) + { + var frames = Session.Content.Frames; + for (var i = 0; i < frames.Count; i++) + { + if (frames[i].Id == id) return i; + } + return null; + } + /// /// The UI language changed: what the tabs keep in objects (chart legends and summaries, the Auto chips of the /// settings), the timeline markers and the preview's info line are made again in the new language. diff --git a/src/Titano.App/Editor/ISequenceSource.cs b/src/Titano.App/Editor/ISequenceSource.cs index 00e089a2..bafab671 100644 --- a/src/Titano.App/Editor/ISequenceSource.cs +++ b/src/Titano.App/Editor/ISequenceSource.cs @@ -44,6 +44,14 @@ public interface ISequenceSource : IAsyncDisposable /// The sequence is gone, or its project cannot be read (corrupt, or written by a newer Titano). Task LoadAsync(CancellationToken cancellationToken); + /// + /// Whether the frames read last are still the sequence's, in the same order: frames inserted + /// or removed since (a sync download, an import of earlier photos, a scan) moved the stored project's positions. A + /// server sequence whose frames changed becomes . + /// + /// The sequence is gone. + Task FramesCurrentAsync(CancellationToken cancellationToken); + /// /// Frame in linear light, oriented, long edge at most ; null /// when the frame cannot be read. The caller owns the buffer. diff --git a/src/Titano.App/Editor/LocalSequenceSource.cs b/src/Titano.App/Editor/LocalSequenceSource.cs index a7d54027..300491ee 100644 --- a/src/Titano.App/Editor/LocalSequenceSource.cs +++ b/src/Titano.App/Editor/LocalSequenceSource.cs @@ -105,6 +105,14 @@ public sealed class LocalSequenceSource : ISequenceSource }, cancellationToken); } + /// An insertion bumps the row's frames version in the transaction that renumbers the frames. + public async Task FramesCurrentAsync(CancellationToken cancellationToken) + { + var framesVersion = _framesVersion; + var row = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + return row.FramesVersion == framesVersion; + } + public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { if ((uint)index >= (uint)_files.Length || _files[index] is not { } file) return null; diff --git a/src/Titano.App/Editor/RemoteSequenceSource.cs b/src/Titano.App/Editor/RemoteSequenceSource.cs index 97993e95..1a4bddf8 100644 --- a/src/Titano.App/Editor/RemoteSequenceSource.cs +++ b/src/Titano.App/Editor/RemoteSequenceSource.cs @@ -130,6 +130,13 @@ public sealed class RemoteSequenceSource : ISequenceSource }, cancellationToken); } + /// Read from the server's manifest: a sequence whose frames are not this PC's becomes outdated. + public async Task FramesCurrentAsync(CancellationToken cancellationToken) + { + if (IsOutdated) return false; + return Compare(await Call(() => _api.GetManifestAsync(Id, cancellationToken))); + } + public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { if ((uint)index >= (uint)_remote.Frames.Count) return null; @@ -305,9 +312,7 @@ public sealed class RemoteSequenceSource : ISequenceSource { try { - var manifest = await _api.GetManifestAsync(Id, cancellationToken).ConfigureAwait(false); - if (SameFrames(manifest)) Volatile.Write(ref _framesVersion, manifest.FramesVersion); - else MarkOutdated(); + Compare(await _api.GetManifestAsync(Id, cancellationToken).ConfigureAwait(false)); } catch (Exception ex) when (ex is TitanoApiException or HttpRequestException or JsonException || (ex is OperationCanceledException && !cancellationToken.IsCancellationRequested)) @@ -344,6 +349,21 @@ public sealed class RemoteSequenceSource : ISequenceSource JobChanged?.Invoke(job); } + /// + /// Takes the server's frames as lists them: their frames version when they are this PC's + /// (saves name it), outdated otherwise. Returns whether they are. + /// + private bool Compare(SequenceManifest manifest) + { + if (!SameFrames(manifest)) + { + MarkOutdated(); + return false; + } + Volatile.Write(ref _framesVersion, manifest.FramesVersion); + return true; + } + /// The server's frames are the cached ones, in the same order (frame positions in the project mean the same frames). private bool SameFrames(SequenceManifest manifest) => manifest.Frames.OrderBy(f => f.Index).Select(f => f.Id).SequenceEqual(_remote.Frames.Select(f => f.Id)); diff --git a/tests/Titano.App.Tests/Editor/EditorFixture.cs b/tests/Titano.App.Tests/Editor/EditorFixture.cs index 2099ebd1..3a950da9 100644 --- a/tests/Titano.App.Tests/Editor/EditorFixture.cs +++ b/tests/Titano.App.Tests/Editor/EditorFixture.cs @@ -77,6 +77,9 @@ internal sealed class FakeSequenceSource(SyntheticSequence sequence, SequenceCon { private readonly SyntheticFrameSource _pixels = new(sequence); + /// The frames the session read last (opened with, or loaded since). + private IReadOnlyList _read = content.Frames; + public ProjectSettings Stored { get; set; } = content.Project; public SequenceContent Content { get; set; } = content; @@ -114,11 +117,36 @@ internal sealed class FakeSequenceSource(SyntheticSequence sequence, SequenceCon /// Thrown by the next load (the sequence read again after a job). public Exception? FailNextLoad { get; set; } - public Task LoadAsync(CancellationToken cancellationToken) + /// Awaited by the next load once it has read the sequence (a read that is slow to complete). + public Task? NextLoadGate { get; set; } + + /// Times the sequence was read (). + public int Loads { get; private set; } + + public async Task LoadAsync(CancellationToken cancellationToken) { - if (FailNextLoad is not { } failure) return Task.FromResult(Content with { Project = Stored }); - FailNextLoad = null; - return Task.FromException(failure); + if (FailNextLoad is { } failure) + { + FailNextLoad = null; + throw failure; + } + Loads++; + var content = Content with { Project = Stored }; + if (NextLoadGate is { } gate) + { + NextLoadGate = null; + await gate; + } + _read = content.Frames; + return content; + } + + /// Whether holds the frames read last; a server sequence becomes outdated when not. + public Task FramesCurrentAsync(CancellationToken cancellationToken) + { + var current = _read.Select(f => f.Id).SequenceEqual(Content.Frames.Select(f => f.Id)); + if (!current && IsRemote) MarkOutdated(); + return Task.FromResult(current); } public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) diff --git a/tests/Titano.App.Tests/Editor/EditorSessionTests.cs b/tests/Titano.App.Tests/Editor/EditorSessionTests.cs index 9b9a5b44..c4f8e0c2 100644 --- a/tests/Titano.App.Tests/Editor/EditorSessionTests.cs +++ b/tests/Titano.App.Tests/Editor/EditorSessionTests.cs @@ -151,6 +151,89 @@ public sealed class EditorSessionTests } } + [Test] + public async Task ARenderAfterFramesWereInsertedEmbedsThePositionsOfTheFramesTheUserChose() + { + var (session, source) = OpenShort(); + await using (session) + { + Assert.True(session.SetExcluded([3], true)); + Assert.True(session.SetHero(4)); + Assert.True(await session.FlushAsync()); + var frames = session.Content.Frames; + // Two earlier photos are inserted and the index moves the stored positions; the user renders without an edit. + InsertEarlier(source, 2); + source.Stored = source.Stored with { ExcludedFrames = [5], HeroFrame = 6 }; + + await session.EnsureFramesAsync(); + var requests = session.RenderRequests(session.Project.Export); + + Assert.Equal(frames.Count + 2, session.Content.Count, "the frames were read again"); + var parameters = JsonSerializer.Deserialize(requests[0].ParametersJson!, ProtocolJson.Default.RenderJobParameters)!; + var embedded = ProjectSettings.FromJson(parameters.SettingsJson!); + Assert.SequenceEqual([5], embedded.ExcludedFrames); + Assert.Equal(6, embedded.HeroFrame); + Assert.Equal(frames[3].Id, session.Content.Frames[embedded.ExcludedFrames[0]].Id); + Assert.Equal(frames[4].Id, session.Content.Frames[embedded.HeroFrame!.Value].Id); + Assert.True(session.Undo()); + Assert.Null(session.Project.HeroFrame); + Assert.SequenceEqual([5], session.Project.ExcludedFrames, "undo steps name the same frames"); + + // Frames that did not change are not read again. + var loads = source.Loads; + await session.EnsureFramesAsync(); + Assert.Equal(loads, source.Loads); + } + } + + [Test] + public async Task AServerSequenceWhoseFramesChangedIsOutdatedBeforeItsRender() + { + var sequence = EditorFixture.Sequence(12); + var content = EditorFixture.Content(sequence, deep: false); + var source = new FakeSequenceSource(sequence, content) { IsRemote = true }; + var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); + await using (session) + { + InsertEarlier(source, 1); + + await session.EnsureFramesAsync(); + + Assert.True(source.IsOutdated); + Assert.True(session.IsReadOnly); + Assert.Equal(0, source.Loads, "its proxies are not the server's frames: nothing is read"); + Assert.Equal(12, session.Content.Count); + } + } + + [Test] + public async Task ReadsThatOverlapFollowTheFramesInTheOrderTheyWereRead() + { + var (session, source) = OpenShort(); + await using (session) + { + Assert.True(session.SetExcluded([3], true)); + Assert.True(await session.FlushAsync()); + var frames = session.Content.Frames; + // A job ends after an earlier photo was inserted, and its read of the sequence is slow to complete. + InsertEarlier(source, 1); + source.Stored = source.Stored with { ExcludedFrames = [4] }; + var slow = new TaskCompletionSource(); + source.NextLoadGate = slow.Task; + var first = session.ReloadAsync(); + // Another job ends after two more were inserted: its read waits for the first one and follows its frames. + InsertEarlier(source, 2); + source.Stored = source.Stored with { ExcludedFrames = [6] }; + var second = session.ReloadAsync(); + slow.SetResult(); + await Task.WhenAll(first, second); + + Assert.Equal(frames.Count + 3, session.Content.Count); + Assert.SequenceEqual([6], session.Project.ExcludedFrames); + Assert.Equal(frames[3].Id, session.Content.Frames[6].Id); + } + } + /// A short sequence without its analysis, whose frame ids are all different (the synthetic ids repeat every 64 frames). private static (EditorSession Session, FakeSequenceSource Source) OpenShort() { diff --git a/tests/Titano.App.Tests/Editor/EditorSmokeTests.cs b/tests/Titano.App.Tests/Editor/EditorSmokeTests.cs index 70ccf97b..6d7289b6 100644 --- a/tests/Titano.App.Tests/Editor/EditorSmokeTests.cs +++ b/tests/Titano.App.Tests/Editor/EditorSmokeTests.cs @@ -14,6 +14,7 @@ using Titano.App.Sections; using Titano.App.Shell; using Titano.App.Tests.Windows; using Titano.Core.Advice; +using Titano.Core.Analysis; using Titano.Core.Export; using Titano.Core.Localization; using Titano.Core.Model; @@ -299,6 +300,36 @@ public sealed class EditorSmokeTests } }); + /// + /// Frames inserted under the editor (a sync download, an import of earlier photos) move the frame on screen with its + /// photo: what the frame actions (Exclude, Set hero, a keyframe) apply to stays the photo the user looks at. + /// + [Test] + public Task TheFrameOnScreenStaysWhenFramesAreInsertedBeforeIt() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + var content = EditorFixture.Content(EditorFixture.Sunset, deep: false); + var source = new FakeSequenceSource(EditorFixture.Sunset, content); + var editor = new EditorViewModel(app.Shell, new EditorSession(source, content, []), [], EncoderHost.Client); + await using (editor) + { + editor.CurrentIndex = 5; + var shown = content.Frames[5].Id; + // An earlier photo arrives and the last frame goes: as many frames as before, each one place later. + var first = content.Frames[0]; + IReadOnlyList frames = + [.. new[] { first with { Id = Guid.CreateVersion7(), CapturedAt = first.CapturedAt!.Value.AddMinutes(-1) } }.Concat(content.Frames.SkipLast(1)) + .Select((f, i) => f with { Index = i })]; + source.Content = content with { Frames = frames, Light = LightAnalyzer.Analyze(frames) }; + + await editor.Session.ReloadAsync(); + + Assert.Equal(6, editor.CurrentIndex); + Assert.Equal(shown, editor.Session.Content.Frames[editor.CurrentIndex].Id); + Assert.Equal(6, editor.Frames.Selected?.Index); + } + }); + /// The measuring tool of each section has content. private static void ExpectMeasure(SequenceView view, EditorTab tab) { diff --git a/tests/Titano.App.Tests/Editor/FakeRemoteSequenceApi.cs b/tests/Titano.App.Tests/Editor/FakeRemoteSequenceApi.cs index 05a9c11c..7b1a6e51 100644 --- a/tests/Titano.App.Tests/Editor/FakeRemoteSequenceApi.cs +++ b/tests/Titano.App.Tests/Editor/FakeRemoteSequenceApi.cs @@ -18,6 +18,7 @@ namespace Titano.App.Tests.Editor; internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList frames) : IRemoteSequenceApi { private readonly Lock _gate = new(); + private readonly TaskCompletionSource _subscribed = new(TaskCreationOptions.RunContinuationsAsynchronously); private Channel _events = Channel.CreateUnbounded(); /// The server's frames in order (another list when frames are added or removed on the server). @@ -55,6 +56,9 @@ internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyListCompletes once the editor's listener has opened an event stream (the stream open then is the one it reads). + public Task Subscribed => _subscribed.Task; + /// A job of the server, as GET /jobs/{id} returns it. public JobDto Job(Guid id, string kind, string state, Guid? target = null, long done = 0, long total = 0) => new(id, kind, [target ?? sequence.Id], sequence.DisplayTitle, state, "user", done, total, null, null, null, null, 0, null, DateTimeOffset.UtcNow, @@ -168,6 +172,7 @@ internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList EventsAsync([EnumeratorCancellation] CancellationToken cancellationToken) { var events = Volatile.Read(ref _events).Reader; + _subscribed.TrySetResult(); while (await events.WaitToReadAsync(cancellationToken)) { while (events.TryRead(out var e)) yield return e; diff --git a/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs b/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs index 4a8d4de5..6fd23079 100644 --- a/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs +++ b/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs @@ -156,17 +156,7 @@ public sealed class ProjectStoreTests(TestContext context) // Three photos taken before the others are found in the folder (a sync download, an import or a scan // inserts them the same way): the index moves the stored positions with their frames. - var sequence = EditorFixture.Sequence(3); - var first = content.Frames[0].CapturedAt!.Value; - for (var i = 0; i < 3; i++) - { - using var image = sequence.Render(i); - var exif = ExifWriter.BuildJpegApp1(sequence.Metadata[i] with { CapturedAt = first.AddMinutes(i - 3) }); - File.WriteAllBytes(Path.Combine(root, "Synthetic", $"EARLY_{i + 1}.JPG"), - JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] })); - } - var archive = (await db.Archives.GetAsync(content.Sequence.ArchiveId, context.Cancellation))!; - await new ArchiveService(db, options).Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation); + await InsertEarlierAsync(db, root, content, options, 3); var moved = ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!); Assert.SequenceEqual([8], moved.ExcludedFrames); Assert.Equal(9, moved.HeroFrame); @@ -195,6 +185,36 @@ public sealed class ProjectStoreTests(TestContext context) } } + [Test] + public async Task ARenderAfterEarlierPhotosArriveEmbedsTheFramesTheUserChose() + { + var (db, sequenceId, root) = await ArchiveAsync(10); + await using (db) + { + var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; + await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options); + var content = await source.LoadAsync(context.Cancellation); + var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); + await using (session) + { + Assert.True(session.SetExcluded([5], true)); + Assert.True(await session.FlushAsync()); + Assert.True(await source.FramesCurrentAsync(context.Cancellation)); + + // Earlier photos arrive while the editor is open; the user renders without another edit. + await InsertEarlierAsync(db, root, content, options, 3); + Assert.False(await source.FramesCurrentAsync(context.Cancellation)); + await session.EnsureFramesAsync(context.Cancellation); + var request = session.RenderRequests(session.Project.Export)[0]; + + Assert.True(await source.FramesCurrentAsync(context.Cancellation)); + Assert.Equal(13, session.Content.Count); + var embedded = ProjectSettings.FromJson(ProcessingJobs.ReadRender(request.ParametersJson).Parameters.SettingsJson!); + Assert.SequenceEqual([content.Frames[5].Id], embedded.ExcludedFrames.Select(i => session.Content.Frames[i].Id), "the photo the user excluded"); + } + } + } + [Test] public async Task ASaveThatDoesNotReachTheIndexThrows() { @@ -249,6 +269,25 @@ public sealed class ProjectStoreTests(TestContext context) } } + /// + /// Writes photos taken before the sequence's first frame into its folder and scans the + /// archive: they are inserted in front, and the index moves the stored positions with their frames. + /// + private async Task InsertEarlierAsync(TitanoDatabase db, string root, SequenceContent content, ArchiveServiceOptions options, int count) + { + var sequence = EditorFixture.Sequence(count); + var first = content.Frames[0].CapturedAt!.Value; + for (var i = 0; i < count; i++) + { + using var image = sequence.Render(i); + var exif = ExifWriter.BuildJpegApp1(sequence.Metadata[i] with { CapturedAt = first.AddMinutes(i - count) }); + File.WriteAllBytes(Path.Combine(root, "Synthetic", $"EARLY_{i + 1}.JPG"), + JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] })); + } + var archive = (await db.Archives.GetAsync(content.Sequence.ArchiveId, context.Cancellation))!; + await new ArchiveService(db, options).Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation); + } + /// A temporary archive with one adopted folder of synthetic JPEGs, indexed. private async Task<(TitanoDatabase Db, Guid SequenceId, string Root)> ArchiveAsync(int frames) { diff --git a/tests/Titano.App.Tests/Editor/RemoteSequenceSourceTests.cs b/tests/Titano.App.Tests/Editor/RemoteSequenceSourceTests.cs index 9a6c9043..fee4899b 100644 --- a/tests/Titano.App.Tests/Editor/RemoteSequenceSourceTests.cs +++ b/tests/Titano.App.Tests/Editor/RemoteSequenceSourceTests.cs @@ -159,7 +159,7 @@ public sealed class RemoteSequenceSourceTests(TestContext context) Assert.Same(conflict, session.Conflict); Assert.False(await session.FlushAsync(), "the change waits for the choice"); Assert.True(session.ResolveConflict(keepMine: true)); - Assert.True(await session.FlushAsync()); + Assert.True(await FlushAfterChoiceAsync(session)); Assert.Null(session.Conflict); var stored = ProjectSettings.FromJson(api.SettingsJson!); @@ -181,7 +181,7 @@ public sealed class RemoteSequenceSourceTests(TestContext context) await found.Task.WaitAsync(TimeSpan.FromSeconds(10)); Assert.True(session.ResolveConflict(keepMine: false)); - Assert.True(await session.FlushAsync()); + Assert.True(await FlushAfterChoiceAsync(session)); var stored = ProjectSettings.FromJson(api.SettingsJson!); Assert.Equal((0.3, -0.2, (int?)2), (stored.Exposure.ExposureOffsetEv, stored.Camera.OffsetY, stored.HeroFrame), "the server's values where both changed; the editor's other change is saved"); @@ -469,6 +469,8 @@ public sealed class RemoteSequenceSourceTests(TestContext context) await using (source) { await source.LoadAsync(context.Cancellation); + // The listener reads the stream open when it subscribes: it must have subscribed for the drop to reach it. + await api.Subscribed.WaitAsync(TimeSpan.FromSeconds(10), context.Cancellation); api.DropEvents(); api.Frames = [.. remote.Frames.Skip(1).Select(f => f.Id)]; api.FramesVersion = 2; @@ -478,6 +480,30 @@ public sealed class RemoteSequenceSourceTests(TestContext context) } } + [Test] + public async Task ARenderIsRefusedOnceTheServersFramesChangedWithoutAnEvent() + { + var (source, api, remote) = Open(); + await using (source) + { + await source.LoadAsync(context.Cancellation); + // A new frames version over the same frames: they are still this PC's. + api.FramesVersion = 2; + Assert.True(await source.FramesCurrentAsync(context.Cancellation)); + Assert.False(source.IsOutdated); + + // A server scan inserts an earlier photo and sends no event: the check before a render finds it. + api.Frames = [Guid.CreateVersion7(), .. remote.Frames.Select(f => f.Id)]; + api.FramesVersion = 3; + Assert.False(await source.FramesCurrentAsync(context.Cancellation)); + Assert.True(source.IsOutdated); + var refused = await Assert.ThrowsAsync(() => + source.SubmitAsync(ProcessingJobs.Render(remote.Sequence, new ExportSettings(), 1920, 1080), context.Cancellation)); + Assert.Equal(Loc.L("Editor.Error.FramesChanged"), refused.Message); + Assert.Empty(api.Posted); + } + } + [Test] public async Task AConflictFoundOnOtherFramesIsNotMergedOntoThem() { @@ -591,6 +617,13 @@ public sealed class RemoteSequenceSourceTests(TestContext context) lock (seen) return seen[^1]; } + /// + /// Stores the change after the user settled a conflict. The test's thread is not the saver's: a retry that started + /// before the choice may still be failing on the old basis, and a flush that arrives meanwhile reports it, so one more + /// flush (on the UI thread the choice cannot land inside a retry) is answered by the attempt made after the choice. + /// + private static async Task FlushAfterChoiceAsync(EditorSession session) => await session.FlushAsync() || await session.FlushAsync(); + private static async Task WaitAsync(Func condition) { for (var i = 0; i < 200; i++)