diff --git a/i18n/en/Editor.resx b/i18n/en/Editor.resx index f6a59fbb..402b1f0c 100644 --- a/i18n/en/Editor.resx +++ b/i18n/en/Editor.resx @@ -52,6 +52,7 @@ Nothing to restore Undo Pick a sequence in the Library + Photos are being added to this sequence; wait a moment and try again.long The frames of this sequence changed on the server; get its proxies again.long This sequence is no longer in the archive.long Jobs cannot run until the archive index is open.long diff --git a/i18n/it/Editor.it.resx b/i18n/it/Editor.it.resx index 1e8570ad..bfc1a2d8 100644 --- a/i18n/it/Editor.it.resx +++ b/i18n/it/Editor.it.resx @@ -51,6 +51,7 @@ Niente da ripristinare Annulla Scegli una sequenza in Libreria + Si stanno aggiungendo foto a questa sequenza; attendi un momento e riprova. I fotogrammi di questa sequenza sono cambiati sul server; scarica di nuovo i proxy. Questa sequenza non è più nell’archivio. I lavori non possono partire finché l’indice dell’archivio non è aperto. diff --git a/src/Titano.App/Editor/EditorSession.cs b/src/Titano.App/Editor/EditorSession.cs index 9b7f63a6..3905649b 100644 --- a/src/Titano.App/Editor/EditorSession.cs +++ b/src/Titano.App/Editor/EditorSession.cs @@ -13,12 +13,17 @@ namespace Titano.App.Editor; /// and redo, and the actions of every section — edit, Optimise (§10.4), Reset, exclusions and hero, analysis and render /// jobs. Every change is saved shortly after it is made (); a change stored meanwhile by /// someone else (an analysis job, another client) is merged in. On a server sequence, settings both sides changed to -/// different values wait for the user's choice (). Call from one thread (the UI thread). +/// different values wait for the user's choice (). Frames inserted under the editor (a sync +/// download, an import of earlier photos, a scan) are read again before the next save or render, and the project's frame +/// positions, its undo steps included, move with their frames as the stored ones did. Call from one thread (the UI thread). /// public sealed class EditorSession : IAsyncDisposable { public static readonly TimeSpan DefaultSaveDelay = TimeSpan.FromMilliseconds(400); + /// Times a save reads the frames again when frames keep changing under it. + private const int FollowAttempts = 3; + /// Sections "Optimise all" walks through, in panel order. public static IReadOnlyList OptimisedSections { get; } = [AdvisorSection.Frames, AdvisorSection.Timing, AdvisorSection.Exposure, AdvisorSection.Motion, AdvisorSection.Camera, AdvisorSection.Export]; @@ -27,6 +32,12 @@ public sealed class EditorSession : IAsyncDisposable private readonly ProjectSaver _saver; private ProjectSettings _basis; + /// + /// 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) { ArgumentNullException.ThrowIfNull(source); @@ -201,19 +212,46 @@ public sealed class EditorSession : IAsyncDisposable public Task SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken = default) => Source.SubmitAsync(request, cancellationToken); - /// Reads the sequence again (an analysis finished): new reports and advice, the stored project merged into the open one. + /// + /// 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, + /// 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 content = await Source.LoadAsync(cancellationToken); - (Content, Context, Advice, Presets) = Analyse(content, _codecs); - // A server's settings that conflict with the editor's waiting change are not merged over it: that change's - // retry meets them and asks (Conflict). - if (Conflict is null && (!IsRemote || ProjectMerge.Conflicts(_basis, Project, content.Project).Count == 0)) + var taken = await BeginReadAsync(); + try { - var merged = ProjectMerge.Merge(_basis, Project, content.Project); - _basis = content.Project; - History.Replace(merged); + var content = await Source.LoadAsync(cancellationToken); + Follow(content); + // A server's settings that conflict with the editor's waiting change are not merged over it: that change's + // retry meets them and asks (Conflict). + if (Conflict is null && (!IsRemote || ProjectMerge.Conflicts(_basis, Project, content.Project).Count == 0)) + { + var merged = ProjectMerge.Merge(_basis, Project, content.Project); + _basis = content.Project; + History.Replace(merged); + } + } + finally + { + taken.SetResult(); } ContentChanged?.Invoke(); } @@ -233,6 +271,42 @@ public sealed class EditorSession : IAsyncDisposable await Source.DisposeAsync(); } + /// + /// 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. Call while the read is under way (). + /// + 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; + 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); + + 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 }; + private static (SequenceContent, SequenceContext, AdvisorResult, IReadOnlyList) Analyse(SequenceContent content, IReadOnlyList codecs) { @@ -271,21 +345,49 @@ public sealed class EditorSession : IAsyncDisposable private async Task SaveAsync(ProjectSettings project) { - ProjectSettings stored; - try + if (!_reading.IsCompleted) { - stored = await Source.SaveProjectAsync(project, _basis, CancellationToken.None); + // A read under way decides the frames the project's positions name. Once it is taken, the project as it is + // then contains this change (projects are whole snapshots), with its positions on those frames. + while (!_reading.IsCompleted) await _reading; + project = Project; } - catch (ProjectConflictException ex) + ProjectSettings stored; + for (var attempt = 1; ; attempt++) { - var found = Conflict is null; - Conflict = ex; - if (found) + try { - Log.Info("editor", $"Settings of {Content.Sequence.DisplayTitle} changed on the server too: {string.Join(", ", ex.Differences.Select(d => d.Path))}"); - ConflictFound?.Invoke(ex); + stored = await Source.SaveProjectAsync(project, _basis, CancellationToken.None); + break; + } + catch (FramesChangedException) when (attempt < FollowAttempts) + { + // Frames were inserted under the editor and the stored positions moved with them: the frames are read + // 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) + { + var found = Conflict is null; + Conflict = ex; + if (found) + { + Log.Info("editor", $"Settings of {Content.Sequence.DisplayTitle} changed on the server too: {string.Join(", ", ex.Differences.Select(d => d.Path))}"); + ConflictFound?.Invoke(ex); + } + throw; } - throw; } Conflict = null; _basis = stored; 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 2105978f..300491ee 100644 --- a/src/Titano.App/Editor/LocalSequenceSource.cs +++ b/src/Titano.App/Editor/LocalSequenceSource.cs @@ -23,7 +23,10 @@ namespace Titano.App.Editor; /// project in .titano/project.json mirrored in the index's settings column (with its hero frame, which the /// Library shows), jobs on this PC's engine. Project writes follow the archive engine's protocol: under the sequence's /// lease file (so the server and the job engine wait for it), file first (atomically), then the index with its settings -/// version as an optimistic check. +/// version as an optimistic check. Project settings name frames by position, and frames inserted while the sequence is +/// open (a sync download, an import of earlier photos, a scan) move the stored positions with their frames: a save made +/// against the frames read earlier is refused () until the editor has read them again +/// and moved its own positions the same way (). /// public sealed class LocalSequenceSource : ISequenceSource { @@ -31,6 +34,9 @@ public sealed class LocalSequenceSource : ISequenceSource private const int SaveAttempts = 3; private const int JobsListed = 200; + /// Times the frames are listed again when an insertion lands while they are read. + private const int ReadAttempts = 3; + private readonly TitanoDatabase _db; private readonly Guid _sequenceId; private readonly ImageDecoder _decoder; @@ -41,6 +47,10 @@ public sealed class LocalSequenceSource : ISequenceSource /// The JPEG of each GPR frame that an import keeps in another sequence (), by position. private string?[] _companions = []; private Guid[] _frameIds = []; + + /// The frames version of the frames last read (), whose order the project's positions follow. + private int _framesVersion = -1; + private ArchivePaths? _paths; private SequencePaths? _folder; @@ -74,15 +84,8 @@ public sealed class LocalSequenceSource : ISequenceSource public async Task LoadAsync(CancellationToken cancellationToken) { - var sequence = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + var (sequence, frames) = await ReadFramesAsync(cancellationToken); var archive = await _db.Archives.GetAsync(sequence.ArchiveId, cancellationToken) ?? throw Missing(); - var frames = new List(); - while (true) - { - var page = await _db.Frames.ListBySequenceAsync(_sequenceId, frames.Count > 0 ? frames[^1].Index : -1, PageSize, cancellationToken); - frames.AddRange(page); - if (page.Count < PageSize) break; - } var renders = await _db.Renders.ListBySequenceAsync(_sequenceId, cancellationToken); var companions = await GprCompanions.FindAsync(_db, archive, frames, cancellationToken); return await Task.Run(() => @@ -95,13 +98,21 @@ public sealed class LocalSequenceSource : ISequenceSource if ((frames[i].Flags & FrameFlags.Missing) == 0) files[i] = paths.FromRelative(frames[i].RelativePath); } _companions = [.. frames.Select(f => companions.GetValueOrDefault(f.Id))]; - (_paths, _folder, _files, _frameIds) = (paths, folder, files, [.. frames.Select(f => f.Id)]); + (_paths, _folder, _files, _frameIds, _framesVersion) = (paths, folder, files, [.. frames.Select(f => f.Id)], sequence.FramesVersion); var context = SequenceContext.FromFrames(frames); return new SequenceContent(sequence, frames, ReadProject(sequence, folder), LightAnalyzer.Analyze(frames), ReadReport(folder, frames.Count), context.SourceWidth, context.SourceHeight, folder.Exports, [.. renders.OrderByDescending(r => r.Created)], SavedCopies.List(folder.MetaDirectory)); }, 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; @@ -127,7 +138,7 @@ public sealed class LocalSequenceSource : ISequenceSource { ArgumentNullException.ThrowIfNull(project); ArgumentNullException.ThrowIfNull(basis); - var (paths, folder, frameIds) = (_paths, _folder, _frameIds); + var (paths, folder, frameIds, framesVersion) = (_paths, _folder, _frameIds, _framesVersion); if (paths is null || folder is null) throw new InvalidOperationException("LoadAsync first."); return Task.Run(async () => { @@ -137,13 +148,16 @@ public sealed class LocalSequenceSource : ISequenceSource for (var attempt = 1; ; attempt++) { var row = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + // Frames were inserted or removed since the editor read them, so its positions name the old order. Insertions + // hold this lease, so the frames do not change again before this save ends. + if (row.FramesVersion != framesVersion) throw new FramesChangedException(Loc.L("Editor.Error.FramesArriving")); var stored = ReadProject(row, folder); var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored); var json = merged.ToJson(); if (json == stored.ToJson()) return merged; AtomicFile.WriteAllText(folder.ProjectPath, json); var edit = new SequenceEdit { SettingsJson = json, HeroFrameId = merged.HeroFrame == stored.HeroFrame ? null : HeroFrameId(merged, frameIds) }; - var result = await _db.Sequences.EditAsync(_sequenceId, edit, row.SettingsVersion, cancellationToken); + var result = await _db.Sequences.EditAsync(_sequenceId, edit, row.SettingsVersion, framesVersion, cancellationToken); switch (result.Outcome) { case SequenceEditOutcome.Updated: @@ -151,7 +165,8 @@ public sealed class LocalSequenceSource : ISequenceSource return merged; case SequenceEditOutcome.NotFound: throw Missing(); - // The settings moved in the index meanwhile (server API): merge again on top of them; the file follows the next write. + // The settings moved in the index meanwhile (server API): merge again on top of them, or find the frames that + // moved; the file follows the next write. case SequenceEditOutcome.Conflict when attempt == SaveAttempts: throw new EditorException(Loc.L("Editor.Error.SaveConflict")); } @@ -181,6 +196,30 @@ public sealed class LocalSequenceSource : ISequenceSource return ValueTask.CompletedTask; } + /// + /// The sequence row with its frames as one state: the frames are listed between two reads of the row that find the + /// same frames version (an insertion renumbers the frames and moves the row's positions in one transaction, and + /// bumps the version), so the project's positions name these frames. + /// + /// The sequence is gone, or an insertion landed during every attempt. + private async Task<(Sequence Row, List Frames)> ReadFramesAsync(CancellationToken cancellationToken) + { + for (var attempt = 0; attempt < ReadAttempts; attempt++) + { + var before = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + var frames = new List(); + while (true) + { + var page = await _db.Frames.ListBySequenceAsync(_sequenceId, frames.Count > 0 ? frames[^1].Index : -1, PageSize, cancellationToken); + frames.AddRange(page); + if (page.Count < PageSize) break; + } + var after = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + if (after.FramesVersion == before.FramesVersion) return (after, frames); + } + throw new EditorException(Loc.L("Editor.Error.FramesArriving")); + } + /// The settings in force: the index copy, else project.json, else defaults. /// The settings are not a project or come from a newer Titano. internal static ProjectSettings ReadProject(Sequence sequence, SequencePaths folder) @@ -221,3 +260,9 @@ public sealed class LocalSequenceSource : ISequenceSource private static EditorException Missing() => new(Loc.L("Editor.Error.Missing")); } + +/// +/// The frames of a sequence of this PC changed since the editor read them (frames inserted or removed): nothing was +/// saved. The editor reads them again, moves its positions as the index moved the stored ones, and saves again. +/// +public sealed class FramesChangedException(string message) : EditorException(message); diff --git a/src/Titano.App/Editor/ProjectHistory.cs b/src/Titano.App/Editor/ProjectHistory.cs index 3622b17c..c90b1a95 100644 --- a/src/Titano.App/Editor/ProjectHistory.cs +++ b/src/Titano.App/Editor/ProjectHistory.cs @@ -78,6 +78,25 @@ public sealed class ProjectHistory(ProjectSettings initial, int capacity = 200) Changed?.Invoke(); } + /// + /// Rewrites the project and every undo and redo snapshot with , without an undo step: a change + /// of what the values mean rather than of the values (frame positions following frames inserted under the editor), so + /// undo and redo keep naming the same frames. + /// + public void Remap(Func remap) + { + ArgumentNullException.ThrowIfNull(remap); + foreach (var steps in new[] { _undo, _redo }) + { + for (var node = steps.First; node is not null; node = node.Next) node.Value = remap(node.Value); + } + var current = remap(Current); + if (ProjectMerge.SameValues(current, Current)) return; + _runKey = null; + Current = current; + Changed?.Invoke(); + } + private static void Rebase(LinkedList steps, ProjectMerge.Rebase rebase) { for (var node = steps.First; node is not null; node = node.Next) node.Value = rebase.Apply(node.Value); diff --git a/src/Titano.App/Editor/RemoteSequenceSource.cs b/src/Titano.App/Editor/RemoteSequenceSource.cs index c581489b..1a4bddf8 100644 --- a/src/Titano.App/Editor/RemoteSequenceSource.cs +++ b/src/Titano.App/Editor/RemoteSequenceSource.cs @@ -31,7 +31,8 @@ namespace Titano.App.Editor; /// local archive. Analyses and renders are server jobs; their state and progress come from the server's events. /// Project settings name frames by position, so the cached frames must be the server's: a load that finds other frames /// throws , and frames that change on the server while the sequence is open make -/// it (read-only, nothing saved or rendered). +/// it (read-only, nothing saved or rendered). Saves name the frames version the editor's frames +/// are at, so the server refuses one made against frames it no longer has even before its event arrives. /// public sealed class RemoteSequenceSource : ISequenceSource { @@ -129,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; @@ -150,19 +158,24 @@ public sealed class RemoteSequenceSource : ISequenceSource if (changedThere && ProjectMerge.Conflicts(basis, project, stored) is { Count: > 0 } conflicts) throw new ProjectConflictException(Loc.L("Editor.Error.SaveConflict"), stored, conflicts); var hero = merged.HeroFrame == stored.HeroFrame ? (Guid?)null : HeroFrameId(merged); + // The positions name the frames this editor holds: the server refuses them (409 frames_conflict) once its + // frames changed, also before its event says so. A server that predates the check ignores it. + var request = new UpdateSequenceRequest(null, null, null, null, merged.ToJson(), version, hero, Volatile.Read(ref _framesVersion)); try { - var updated = await Call(() => _api.UpdateSequenceAsync(Id, new UpdateSequenceRequest(null, null, null, null, merged.ToJson(), version, hero), - cancellationToken)); + var updated = await Call(() => _api.UpdateSequenceAsync(Id, request, cancellationToken)); Volatile.Write(ref _stored, new Stored(merged, updated.SettingsVersion)); return merged; } catch (TitanoApiException ex) when (ex.Status == HttpStatusCode.Conflict) { - // Changed on the server since this editor read it: merge again on top of the server's settings. - if (attempt == SaveAttempts) throw new EditorException(Loc.L("Editor.Error.SaveConflict"), ex); + // Changed on the server since this editor read it, its settings or its frames: other frames make the + // editor outdated (its proxies are not the server's), otherwise the edit merges again on top of the + // server's settings, at the frames version they are at. var manifest = await Call(() => _api.GetManifestAsync(Id, cancellationToken)); if (!SameFrames(manifest)) throw Outdated(); + if (attempt == SaveAttempts) throw new EditorException(Loc.L("Editor.Error.SaveConflict"), ex); + Volatile.Write(ref _framesVersion, manifest.FramesVersion); Volatile.Write(ref _stored, new Stored(Parse(manifest.SettingsJson), manifest.SettingsVersion)); } } @@ -219,7 +232,7 @@ public sealed class RemoteSequenceSource : ISequenceSource /// /// Follows the server's events until the editor closes, reconnecting with a growing delay (job states lost meanwhile - /// are read back from the jobs). Nothing that fails on the way ends it. + /// are read back from the jobs, and the frames are compared again). Nothing that fails on the way ends it. /// private async Task ListenAsync(CancellationToken cancellationToken) { @@ -244,6 +257,8 @@ public sealed class RemoteSequenceSource : ISequenceSource var delay = Math.Min(MaxBackoff.Ticks, MinBackoff.Ticks << Math.Min(failures++, 10)); await Task.Delay(TimeSpan.FromTicks(delay), cancellationToken).ConfigureAwait(false); await RefreshTrackedAsync(cancellationToken).ConfigureAwait(false); + // A frames change announced while the socket was down is found now rather than at the next save. + if (Volatile.Read(ref _framesVersion) >= 0) await CheckFramesAsync(cancellationToken).ConfigureAwait(false); } catch (Exception ex) when (ex is not OutOfMemoryException) { @@ -297,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)) @@ -336,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/src/Titano.Core/Project/FramePhotos.cs b/src/Titano.Core/Project/FramePhotos.cs index 880b2169..5a674717 100644 --- a/src/Titano.Core/Project/FramePhotos.cs +++ b/src/Titano.Core/Project/FramePhotos.cs @@ -26,12 +26,13 @@ public sealed record FramePhoto(string? Sha256, long Size, DateTime? CapturedAt) /// /// The photos of one copy's frames by frame index (positions in capture order, BRIEF §5), and where a photo is among -/// them. Immutable once built, so parallel workers may share it. +/// them. A copy may hold one photo more than once (a folder adopted with 'IMG_0001.JPG' and 'IMG_0001 (1).JPG'); those +/// frames are told apart by their order (). Immutable once built, so parallel workers may share it. /// public sealed class FramePhotos { private readonly FramePhoto?[] _byIndex; - private readonly Dictionary _bySha = new(StringComparer.Ordinal); + private readonly Dictionary> _bySha = new(StringComparer.Ordinal); private readonly Dictionary<(long Size, long Time), List> _bySizeAndTime = []; /// Each frame's index and photo, in any order. @@ -44,7 +45,12 @@ public sealed class FramePhotos for (var i = 0; i < _byIndex.Length; i++) { if (_byIndex[i] is not { } photo) continue; - if (photo.IsHashed) _bySha.TryAdd(photo.Sha256!.ToLowerInvariant(), i); + if (photo.IsHashed) + { + var sha = photo.Sha256!.ToLowerInvariant(); + if (!_bySha.TryGetValue(sha, out var copies)) _bySha[sha] = copies = []; + copies.Add(i); + } if (photo.CapturedAt is not { } time) continue; var key = (photo.Size, FramePhoto.Millisecond(time)); if (!_bySizeAndTime.TryGetValue(key, out var same)) _bySizeAndTime[key] = same = []; @@ -60,17 +66,39 @@ public sealed class FramePhotos /// Some frame is not hashed yet: matching it needs capture times. public bool HasUnhashed => _byIndex.Any(p => p is { IsHashed: false }); - /// The index of the first frame holding (); null when none does. - public int? IndexOf(FramePhoto photo) + /// + /// The index of the first frame holding (), or with + /// n of the (n+1)-th in index order; null when fewer frames hold it. + /// + public int? IndexOf(FramePhoto photo, int occurrence = 0) { ArgumentNullException.ThrowIfNull(photo); + ArgumentOutOfRangeException.ThrowIfNegative(occurrence); + var holding = Holding(photo); + return occurrence < holding.Count ? holding[occurrence] : null; + } + + /// + /// Which of the frames holding the photo at it is, in index order: 0 for the first (and for + /// a photo held once), 1 for the second, … A position translated to another copy names the same one there. + /// + public int Occurrence(int index) => this[index] is { } photo ? Math.Max(Holding(photo).BinarySearch(index), 0) : 0; + + /// + /// The indices of the frames holding , ascending. A hashed photo is the frames with its SHA-256 + /// when there are any: a frame not hashed yet with the same size and capture time may be another photo (a RAW of + /// constant size in a burst without sub-second times), so it counts only when no frame has the hash. + /// + private List Holding(FramePhoto photo) + { if (photo.IsHashed && _bySha.TryGetValue(photo.Sha256!.ToLowerInvariant(), out var hashed)) return hashed; - if (photo.CapturedAt is not { } time || !_bySizeAndTime.TryGetValue((photo.Size, FramePhoto.Millisecond(time)), out var candidates)) return null; + var holding = new List(1); + if (photo.CapturedAt is not { } time || !_bySizeAndTime.TryGetValue((photo.Size, FramePhoto.Millisecond(time)), out var candidates)) return holding; foreach (var index in candidates) { - if (_byIndex[index]!.Matches(photo)) return index; + if (_byIndex[index]!.Matches(photo)) holding.Add(index); } - return null; + return holding; } /// Both lists hold the same photos at the same indices: a position names the same photo on both. diff --git a/src/Titano.Core/Project/ProjectSettings.cs b/src/Titano.Core/Project/ProjectSettings.cs index 6e5402e2..60fc2eae 100644 --- a/src/Titano.Core/Project/ProjectSettings.cs +++ b/src/Titano.Core/Project/ProjectSettings.cs @@ -1,6 +1,7 @@ using System.Text.Json; using System.Text.Json.Nodes; using System.Text.Json.Serialization; +using Titano.Core.Model; namespace Titano.Core.Project; @@ -59,6 +60,13 @@ public sealed record PendingFrame public long Size { get; init; } public DateTime? CapturedAt { get; init; } + /// + /// Which of the frames holding the photo it names, in capture order, when a copy holds the photo more than once + /// (): 0, the first, is not written. + /// + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)] + public int Occurrence { get; init; } + /// The photo is excluded from renders. public bool Excluded { get; init; } @@ -317,6 +325,39 @@ public sealed record ProjectSettings } } + /// + /// A project written against the frames (frame ids, by index) moved to the frames + /// (in index order) the way the archive index moves its own copy when it takes them + /// (ProjectPositions in Titano.Data): while every frame of is still there, its positions + /// move with their frames (), otherwise they stay; either way pending frames whose + /// photos are now there take their place (). An editor that read the frames + /// before frames were inserted saves its edit in the new order this way. Null when nothing changes. + /// + public static string? FollowFrames(string json, IReadOnlyList before, IReadOnlyList after) + { + ArgumentNullException.ThrowIfNull(before); + ArgumentNullException.ThrowIfNull(after); + var now = new Dictionary(after.Count); + for (var i = 0; i < after.Count; i++) now[after[i].Id] = i; + Dictionary? moves = []; + for (var i = 0; i < before.Count; i++) + { + if (!now.TryGetValue(before[i], out var index)) + { + moves = null; + break; + } + if (index != i) moves[i] = index; + } + var moved = moves is null ? null : MoveFramePositions(json, moves); + var current = moved ?? json; + // Most projects wait for no photo: the frames' photos are gathered only for those that do. + var placed = current.Contains("pendingFrames", StringComparison.OrdinalIgnoreCase) + ? TranslateFramePositions(current, null, new FramePhotos(after.Select((f, i) => (i, new FramePhoto(f.Sha256, f.Size, f.CapturedAt))))) + : null; + return placed ?? moved; + } + private static bool Move(JsonNode? position, Action replace, IReadOnlyDictionary moves) { if (position is not JsonValue value || !value.TryGetValue(out var old) || !moves.TryGetValue(old, out var now) || now == old) return false; @@ -347,7 +388,9 @@ public sealed record ProjectSettings /// Translates the frame positions of a project written against the frames of another copy of the sequence /// (; a server sequence and a PC's copy hold the same photos, though not always all of them, /// BRIEF §14.5) to the frames of , by photo: each exclusion, the hero and each camera keyframe - /// moves to the frame of holding its photo. One whose photo lacks becomes + /// moves to the frame of holding its photo, and a position on the n-th frame holding a photo + /// holds more than once to the n-th such frame (), so + /// duplicates stay apart. One whose photo (or that copy of it) lacks becomes /// a , and pending frames whose photo holds become positions again; a /// pending hero only while no other hero is chosen (a hero chosen since one was left pending is newer, so that one no /// longer waits even when the chosen one must wait in turn), a pending keyframe only where no keyframe is. With @@ -370,7 +413,7 @@ public sealed record ProjectSettings foreach (var node in stored) { // An entry naming no photo is not this Titano's to place: it stays as it is. - if (node is JsonObject entry && PhotoOf(entry) is { } photo) pending.Add(new Parked(photo, entry.DeepClone().AsObject())); + if (node is JsonObject entry && PhotoOf(entry) is { } photo) pending.Add(new Parked(photo, OccurrenceOf(entry), entry.DeepClone().AsObject())); else unreadable.Add(node?.DeepClone()); } } @@ -409,14 +452,14 @@ public sealed record ProjectSettings { if (!IsPosition(node, out var at)) kept.Add(node?.DeepClone()); else if (from[at] is not { } photo) changed = true; - else if (to.IndexOf(photo) is { } now) + else if (to.IndexOf(photo, from.Occurrence(at)) is { } now) { kept.Add(JsonValue.Create(now)); changed |= now != at; } else { - Park(pending, photo).Entry["excluded"] = true; + Park(pending, photo, from.Occurrence(at)).Entry["excluded"] = true; changed = true; } } @@ -425,8 +468,8 @@ public sealed record ProjectSettings if (project["heroFrame"] is JsonValue hero && hero.TryGetValue(out var heroAt)) { var photo = from[heroAt]; - var now = photo is null ? null : to.IndexOf(photo); - if (photo is not null && now is null) Park(pending, photo).Entry["hero"] = true; + var now = photo is null ? null : to.IndexOf(photo, from.Occurrence(heroAt)); + if (photo is not null && now is null) Park(pending, photo, from.Occurrence(heroAt)).Entry["hero"] = true; if (now != heroAt) { project["heroFrame"] = now; @@ -448,7 +491,7 @@ public sealed record ProjectSettings { changed = true; } - else if (to.IndexOf(photo) is { } now) + else if (to.IndexOf(photo, from.Occurrence(at)) is { } now) { copy["frame"] = now; kept.Add(copy); @@ -456,7 +499,7 @@ public sealed record ProjectSettings } else { - var parked = Park(pending, photo).Entry; + var parked = Park(pending, photo, from.Occurrence(at)).Entry; if (parked["keyframes"] is not JsonArray keys) parked["keyframes"] = keys = new JsonArray(); keys.Add(copy); changed = true; @@ -473,7 +516,7 @@ public sealed record ProjectSettings var changed = false; foreach (var parked in pending) { - if (to.IndexOf(parked.Photo) is not { } at) continue; + if (to.IndexOf(parked.Photo, parked.Occurrence) is not { } at) continue; parked.Placed = changed = true; if (Flag(parked.Entry, "excluded")) { @@ -523,18 +566,19 @@ public sealed record ProjectSettings } } - /// The pending entry of , added when there is none. - private static Parked Park(List pending, FramePhoto photo) + /// The pending entry of (the copy of it names), added when there is none. + private static Parked Park(List pending, FramePhoto photo, int occurrence) { - if (pending.FirstOrDefault(p => p.Photo.Matches(photo)) is { } known) return known; + if (pending.FirstOrDefault(p => p.Occurrence == occurrence && p.Photo.Matches(photo)) is { } known) return known; var entry = new JsonObject(); if (photo.IsHashed) entry["sha256"] = photo.Sha256!.ToLowerInvariant(); entry["size"] = photo.Size; if (photo.CapturedAt is { } captured) entry["capturedAt"] = captured; + if (occurrence > 0) entry["occurrence"] = occurrence; entry["excluded"] = false; entry["hero"] = false; entry["keyframes"] = new JsonArray(); - var parked = new Parked(photo, entry); + var parked = new Parked(photo, occurrence, entry); pending.Add(parked); return parked; } @@ -548,6 +592,9 @@ public sealed record ProjectSettings return string.IsNullOrEmpty(sha) && (captured is null || size < 0) ? null : new FramePhoto(sha, size, captured); } + /// Which copy of its photo a pending entry names; the first when it says nothing (or nothing readable). + private static int OccurrenceOf(JsonObject entry) => entry["occurrence"] is JsonValue o && o.TryGetValue(out var occurrence) && occurrence > 0 ? occurrence : 0; + private static bool Flag(JsonObject entry, string name) => entry[name] is JsonValue value && value.TryGetValue(out var set) && set; /// A pending entry still has a position to give its photo. @@ -566,10 +613,11 @@ public sealed record ProjectSettings foreach (var node in copy) array.Add(node); } - /// A pending entry being edited: its photo, its JSON, and whether its photo took its place. - private sealed class Parked(FramePhoto photo, JsonObject entry) + /// A pending entry being edited: its photo (and which copy of it), its JSON, and whether its photo took its place. + private sealed class Parked(FramePhoto photo, int occurrence, JsonObject entry) { public FramePhoto Photo { get; } = photo; + public int Occurrence { get; } = occurrence; public JsonObject Entry { get; } = entry; public bool Placed { get; set; } } diff --git a/src/Titano.Data/Sync/SyncAgent.cs b/src/Titano.Data/Sync/SyncAgent.cs index 1d47748d..caa6e992 100644 --- a/src/Titano.Data/Sync/SyncAgent.cs +++ b/src/Titano.Data/Sync/SyncAgent.cs @@ -1,9 +1,11 @@ using System.Collections.Concurrent; +using System.Text.Json; using System.Threading.Channels; using Titano.Core.Diagnostics; using Titano.Core.Model; using Titano.Data.Jobs; using Titano.Protocol; +using Titano.Protocol.Client; namespace Titano.Data.Sync; @@ -48,6 +50,10 @@ public sealed class SyncAgent : IAsyncDisposable private readonly Dictionary _proxyJobs = []; private readonly Dictionary _proxyFailures = []; + + /// The server's update time at which a cache holding thumbnails in place of proxies was last compared with its manifest. + private readonly Dictionary _standInsCompared = []; + private readonly SemaphoreSlim _refreshing = new(1, 1); private Task _running = Task.CompletedTask; private SyncSnapshot? _snapshot; @@ -220,7 +226,9 @@ public sealed class SyncAgent : IAsyncDisposable /// /// Queues (background priority) the proxies of server sequences this PC keeps proxies of, without local originals, - /// whose cache is stale; a sequence whose last download failed waits for its backoff. + /// whose cache is stale: frames changed on a server that has the sequence's proxies, or the server now offers the + /// proxy of a frame the cache holds a thumbnail for (). A sequence whose last + /// download failed waits for its backoff. /// private async Task QueueProxiesAsync(SyncSnapshot snapshot, CancellationToken cancellationToken) { @@ -229,6 +237,9 @@ public sealed class SyncAgent : IAsyncDisposable var job = await _sync.Database.Jobs.GetAsync(jobId, cancellationToken).ConfigureAwait(false); if (job?.State is JobState.Queued or JobState.Running or JobState.Paused) continue; _proxyJobs.Remove(remoteId); + // A download of stand-ins' proxies that did not finish compares the cache with the manifest again (after its + // backoff when it failed): the server's sequence may never change again to ask for it. + if (job?.State != JobState.Done) _standInsCompared.Remove(remoteId); if (job?.State == JobState.Failed) { var failures = _proxyFailures.GetValueOrDefault(remoteId).Failures + 1; @@ -241,14 +252,47 @@ public sealed class SyncAgent : IAsyncDisposable } foreach (var entry in snapshot.Entries) { - if (entry is not { Local: null, Transfer: null, Link: { ProxiesCached: > 0, ServerHasProxies: true, ProxiesStale: true } link }) continue; + if (entry is not { Local: null, Transfer: null, Link: { ProxiesCached: > 0, ProxiesStale: true } link }) continue; if (_proxyFailures.TryGetValue(link.RemoteId, out var failed) && DateTime.UtcNow < failed.NotBefore) continue; + if (!link.ServerHasProxies && !await OffersProxiesAsync(link, cancellationToken).ConfigureAwait(false)) continue; var job = await _sync.EnqueueDownloadAsync(_engine!, Server, link.RemoteId, link.Title, SyncDownloadMode.Proxies, null, JobPriority.Background, cancellationToken).ConfigureAwait(false); _proxyJobs[link.RemoteId] = job.Id; + // Compared at this update time once the download that brings what the server offers is queued. + if (!link.ServerHasProxies) _standInsCompared[link.RemoteId] = link.RemoteUpdatedAt; } } + /// + /// Whether the server now offers the proxy of a frame whose cached file only stands in for one (a thumbnail, a file + /// of a cache that did not record its kind) or that has no cached file. The sequence's proxy flag cannot say: it waits + /// for every frame, a missing or damaged one never gets a proxy, and clients and render nodes send the other frames' + /// proxies one by one. The manifest is read once per change of the server's sequence, since a proxy that arrives + /// leaves a new update time (the proxy pass it queues records the sequence's state). A comparison that offers nothing + /// is recorded here; one that offers proxies is recorded when their download is queued, and dropped when that + /// download does not finish (). + /// + private async Task OffersProxiesAsync(SyncLink link, CancellationToken cancellationToken) + { + if (_standInsCompared.TryGetValue(link.RemoteId, out var compared) && SyncService.SameMoment(compared, link.RemoteUpdatedAt)) return false; + SequenceManifest manifest; + try + { + manifest = await _remote.GetManifestAsync(link.RemoteId, cancellationToken).ConfigureAwait(false); + } + catch (Exception ex) when (ex is TitanoApiException or HttpRequestException or JsonException + || (ex is OperationCanceledException && !cancellationToken.IsCancellationRequested)) + { + // Compared again at the next refresh; the other sequences go on. + Log.Info(LogCategory, $"The proxies of {link.Title} on {Server} could not be compared: {ex.Message}"); + return false; + } + var cached = _sync.Proxies.Kinds(Server, link.RemoteId); + if (manifest.Frames.Any(f => f.HasProxy && cached.GetValueOrDefault(f.Id) != ProxyCache.Proxy)) return true; + _standInsCompared[link.RemoteId] = link.RemoteUpdatedAt; + return false; + } + /// Waits for a wake-up or the delay; false when stopping. private static async Task WaitAsync(ChannelReader wake, TimeSpan delay, CancellationToken cancellationToken) { diff --git a/src/Titano.Data/Sync/SyncService.cs b/src/Titano.Data/Sync/SyncService.cs index 647d8085..35d4ff1c 100644 --- a/src/Titano.Data/Sync/SyncService.cs +++ b/src/Titano.Data/Sync/SyncService.cs @@ -710,7 +710,7 @@ public sealed class SyncService private static DateTime Second(DateTime time) => new(time.Ticks - time.Ticks % TimeSpan.TicksPerSecond, DateTimeKind.Unspecified); /// The same instant as databases keep it (to the microsecond). - private static bool SameMoment(DateTimeOffset a, DateTimeOffset b) => a.UtcTicks / 10 == b.UtcTicks / 10; + internal static bool SameMoment(DateTimeOffset a, DateTimeOffset b) => a.UtcTicks / 10 == b.UtcTicks / 10; /// /// Writes the server's payload into the local index, project and sidecar in one step (settings version + 1) under the 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 7015300d..c4f8e0c2 100644 --- a/tests/Titano.App.Tests/Editor/EditorSessionTests.cs +++ b/tests/Titano.App.Tests/Editor/EditorSessionTests.cs @@ -98,6 +98,160 @@ public sealed class EditorSessionTests } } + [Test] + public async Task AnEditMadeBeforeInsertedFramesWereReadIsSavedOnTheFramesItNamed() + { + var (session, source) = OpenShort(); + await using (session) + { + Assert.True(session.SetExcluded([3], true)); + Assert.True(await session.FlushAsync()); + // Two earlier photos are inserted (a download, an import, a scan): the stored exclusion moved with its frame. + var frames = session.Content.Frames; + InsertEarlier(source, 2); + source.Stored = source.Stored with { ExcludedFrames = [5] }; + source.FailNextSave = new FramesChangedException("frames changed"); + + // The editor still shows the frames it read when the user excludes another one. + Assert.True(session.SetExcluded([6], true)); + Assert.True(await session.FlushAsync()); + + Assert.Equal(frames.Count + 2, session.Content.Count, "the frames were read again"); + Assert.SequenceEqual([5, 8], source.Stored.ExcludedFrames); + Assert.SequenceEqual([frames[3].Id, frames[6].Id], session.Project.ExcludedFrames.Select(i => session.Content.Frames[i].Id)); + Assert.True(session.Undo()); + Assert.SequenceEqual([5], session.Project.ExcludedFrames, "undo steps name the same frames"); + Assert.True(session.Undo()); + Assert.Empty(session.Project.ExcludedFrames); + } + } + + [Test] + public async Task AReadAfterFramesWereInsertedMovesTheOpenProjectWithThem() + { + var (session, source) = OpenShort(); + await using (session) + { + Assert.True(session.SetExcluded([3], true)); + Assert.True(session.SetHero(4)); + Assert.True(await session.FlushAsync()); + InsertEarlier(source, 2); + source.Stored = source.Stored with { ExcludedFrames = [5], HeroFrame = 6 }; + + await session.ReloadAsync(); + + Assert.SequenceEqual([5], session.Project.ExcludedFrames); + Assert.Equal(6, session.Project.HeroFrame); + Assert.True(session.Undo()); + Assert.Null(session.Project.HeroFrame); + Assert.SequenceEqual([5], session.Project.ExcludedFrames, "the step before Set hero names the same frame"); + Assert.True(await session.FlushAsync()); + Assert.SequenceEqual([5], source.Stored.ExcludedFrames); + Assert.Null(source.Stored.HeroFrame); + } + } + + [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() + { + var sequence = EditorFixture.Sequence(12); + var content = EditorFixture.Content(sequence, deep: false); + var source = new FakeSequenceSource(sequence, content); + return (new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)), source); + } + + /// Photos captured before the first frame join the source's sequence, as an insertion renumbers it. + private static void InsertEarlier(FakeSequenceSource source, int count) + { + var first = source.Content.Frames[0]; + var early = Enumerable.Range(0, count).Select(i => first with { Id = Guid.CreateVersion7(), CapturedAt = first.CapturedAt!.Value.AddMinutes(i - count) }); + IReadOnlyList frames = [.. early.Concat(source.Content.Frames).Select((f, i) => f with { Index = i })]; + source.Content = source.Content with { Frames = frames, Light = LightAnalyzer.Analyze(frames) }; + } + [Test] public async Task AFailedSaveStaysPendingUntilItIsStored() { 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 495f7cfe..7b1a6e51 100644 --- a/tests/Titano.App.Tests/Editor/FakeRemoteSequenceApi.cs +++ b/tests/Titano.App.Tests/Editor/FakeRemoteSequenceApi.cs @@ -1,4 +1,5 @@ using System.Collections.Concurrent; +using System.IO; using System.Net; using System.Runtime.CompilerServices; using System.Threading.Channels; @@ -17,7 +18,8 @@ namespace Titano.App.Tests.Editor; internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList frames) : IRemoteSequenceApi { private readonly Lock _gate = new(); - private readonly Channel _events = Channel.CreateUnbounded(); + 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). public IReadOnlyList Frames { get; set; } = frames; @@ -54,12 +56,18 @@ 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, state == "queued" ? null : DateTimeOffset.UtcNow, state is "done" or "failed" ? DateTimeOffset.UtcNow : null); - public void Publish(ServerEvent e) => _events.Writer.TryWrite(e); + public void Publish(ServerEvent e) => Volatile.Read(ref _events).Writer.TryWrite(e); + + /// The event socket drops: the stream open now fails, and the next one starts empty. + public void DropEvents() => Interlocked.Exchange(ref _events, Channel.CreateUnbounded()).Writer.TryComplete(new IOException("connection lost")); public Task GetSequenceAsync(Guid id, CancellationToken cancellationToken) { @@ -98,6 +106,11 @@ internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList EventsAsync([EnumeratorCancellation] CancellationToken cancellationToken) { - while (await _events.Reader.WaitToReadAsync(cancellationToken)) + var events = Volatile.Read(ref _events).Reader; + _subscribed.TrySetResult(); + while (await events.WaitToReadAsync(cancellationToken)) { - while (_events.Reader.TryRead(out var e)) yield return e; + 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 ab55c4a9..6fd23079 100644 --- a/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs +++ b/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs @@ -138,6 +138,83 @@ public sealed class ProjectStoreTests(TestContext context) } } + [Test] + public async Task AnEditorOpenWhileEarlierPhotosArriveSavesOnTheFramesTheUserChose() + { + 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(session.SetHero(6)); + Assert.True(await session.FlushAsync()); + + // 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. + 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); + + // The editor still shows the ten frames it read; the user excludes the eighth of them. + Assert.Equal(10, session.Content.Count); + Assert.True(session.SetExcluded([7], true)); + Assert.True(await session.FlushAsync()); + + Assert.Equal(13, session.Content.Count, "the frames were read again before the save"); + Assert.SequenceEqual([8, 10], session.Project.ExcludedFrames); + Assert.Equal(9, session.Project.HeroFrame); + var row = (await db.Sequences.GetAsync(sequenceId))!; + var stored = ProjectSettings.FromJson(row.SettingsJson!); + var frames = session.Content.Frames; + Assert.SequenceEqual([content.Frames[5].Id, content.Frames[7].Id], stored.ExcludedFrames.Select(i => frames[i].Id), "the photos the user chose"); + Assert.Equal(content.Frames[6].Id, frames[stored.HeroFrame!.Value].Id); + Assert.Equal(content.Frames[6].Id, row.HeroFrameId); + Assert.Equal(row.SettingsJson, File.ReadAllText(Path.Combine(root, "Synthetic", ".titano", "project.json"))); + + // Undo takes back the user's last step on the new frames too. + Assert.True(session.Undo()); + Assert.True(await session.FlushAsync()); + Assert.SequenceEqual([8], ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!).ExcludedFrames); + } + } + } + + [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() { @@ -192,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 1ef3ec8a..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"); @@ -433,6 +433,77 @@ public sealed class RemoteSequenceSourceTests(TestContext context) } } + [Test] + public async Task SavesNameTheirFramesAndTheServerRefusesThemOnceItsFramesChanged() + { + var (source, api, remote) = Open(); + await using (source) + { + var content = await source.LoadAsync(context.Cancellation); + var stored = await source.SaveProjectAsync(content.Project with { ExcludedFrames = [1] }, content.Project, context.Cancellation); + + // A new frames version over the same frames: the save goes through at that version. + api.FramesVersion = 2; + stored = await source.SaveProjectAsync(stored with { HeroFrame = 2 }, stored, context.Cancellation); + Assert.SequenceEqual([1, 1, 2], api.Edits.Select(e => e.Request.ExpectedFramesVersion ?? -1)); + Assert.SequenceEqual([true, false, true], api.Edits.Select(e => e.Accepted)); + + // An earlier photo reaches the server (a scan, an upload) and its positions move with their frames, before + // any event reaches this editor: the server refuses the edit made on the old frames, which stays unsaved. + api.Frames = [Guid.CreateVersion7(), .. remote.Frames.Select(f => f.Id)]; + api.FramesVersion = 3; + api.SettingsJson = (ProjectSettings.FromJson(api.SettingsJson!) with { ExcludedFrames = [2], HeroFrame = 3 }).ToJson(); + var refused = await Assert.ThrowsAsync(() => + source.SaveProjectAsync(stored with { ExcludedFrames = [1, 4] }, stored, context.Cancellation)); + Assert.Equal(Loc.L("Editor.Error.FramesChanged"), refused.Message); + Assert.True(source.IsOutdated); + Assert.False(api.Edits[^1].Accepted); + Assert.SequenceEqual([2], ProjectSettings.FromJson(api.SettingsJson!).ExcludedFrames, "the server keeps the positions it moved"); + } + } + + [Test] + public async Task FramesChangedWhileTheEventsWereLostAreFoundOnReconnecting() + { + var (source, api, remote) = Open(); + 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; + // The listener reconnects after its first delay (2 s) and compares the frames again. + await WaitAsync(() => source.IsOutdated); + Assert.True(source.IsReadOnly); + } + } + + [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() { @@ -546,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++) diff --git a/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs b/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs index 08943aa5..b005c4f8 100644 --- a/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs +++ b/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs @@ -167,6 +167,47 @@ public sealed class ProjectSettingsTests Assert.Null(ProjectSettings.MoveFramePositions("""{ "heroFrame": 1, "HeroFrame": 1 }""", new Dictionary { [1] = 2 })); } + [Test] + public void AnEditorsPositionsFollowFramesInsertedUnderItAsTheIndexMovedTheStoredOnes() + { + // An editor read four frames; a download then inserted two earlier photos, one of which an exclusion waited for. + var photos = Enumerable.Range(0, 6).Select(Photo).ToList(); + var ids = Enumerable.Range(0, 6).Select(_ => Guid.CreateVersion7()).ToList(); + IReadOnlyList before = ids[2..]; + var after = ids.Select((id, i) => new Titano.Core.Model.Frame + { + Id = id, + SequenceId = Guid.Empty, + Index = i, + RelativePath = $"s/IMG_{i}.JPG", + FileName = $"IMG_{i}.JPG", + Sha256 = photos[i].Sha256, + Size = photos[i].Size, + CapturedAt = photos[i].CapturedAt, + }).ToList(); + var project = new ProjectSettings + { + ExcludedFrames = [1, 3], + HeroFrame = 0, + Camera = new CameraSettings { Keyframes = [new CameraKey(2, 0.5, 0.5, 1, 0)] }, + Exposure = new ExposureSettings { DeflickerWindow = new Auto().WithManual(41) }, + PendingFrames = [new PendingFrame { Sha256 = photos[1].Sha256, Size = photos[1].Size, Excluded = true }], + }; + + var followed = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.FollowFrames(project.ToJson(), before, after))); + + Assert.SequenceEqual([1, 3, 5], followed.ExcludedFrames); + Assert.Equal(2, followed.HeroFrame); + Assert.SequenceEqual([4], followed.Camera.Keyframes.Select(k => k.Frame)); + Assert.Equal(41, followed.Exposure.DeflickerWindow.Manual); + Assert.Null(followed.PendingFrames); + + // The same frames: nothing moves. A frame the editor read that is gone: positions stay, as the index leaves them. + Assert.Null(ProjectSettings.FollowFrames(new ProjectSettings { ExcludedFrames = [1] }.ToJson(), ids, after)); + var removed = after.Where(f => f.Id != ids[3]).Select((f, i) => f with { Index = i }).ToList(); + Assert.Null(ProjectSettings.FollowFrames(new ProjectSettings { ExcludedFrames = [1, 3] }.ToJson(), before, removed)); + } + [Test] public void PositionsCrossToAnotherCopyByPhotoAndWaitForPhotosItLacks() { @@ -283,6 +324,102 @@ public sealed class ProjectSettingsTests Assert.Null(cleared.PendingFrames); } + [Test] + public void APhotoHeldTwiceKeepsEachCopysPositions() + { + // The server adopted a folder holding photo 1 twice ('IMG_0001.JPG', 'IMG_0001 (1).JPG'); this PC keeps it once. + var photos = Enumerable.Range(0, 3).Select(Photo).ToList(); + var server = Frames([photos[0], photos[1], photos[1], photos[2]]); + var here = Frames(photos); + var project = new ProjectSettings + { + ExcludedFrames = [2], + HeroFrame = 2, + Camera = new CameraSettings { Keyframes = [new CameraKey(1, 0.1, 0.5, 1, 0), new CameraKey(2, 0.2, 0.5, 1, 0)] }, + }; + + // The second copy, which the deep analysis flags as a duplicate, is excluded there: this PC still renders its only copy. + var taken = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(project.ToJson(), server, here))); + Assert.Empty(taken.ExcludedFrames); + Assert.Null(taken.HeroFrame); + Assert.SequenceEqual([1], taken.Camera.Keyframes.Select(k => k.Frame)); + Assert.Equal(0.1, taken.Camera.Keyframes[0].CenterX); + var waiting = Assert.NotNull(taken.PendingFrames); + Assert.Count(1, waiting); + Assert.True(waiting[0] is { Excluded: true, Hero: true, Occurrence: 1 } && waiting[0].Sha256 == photos[1].Sha256); + Assert.Count(1, waiting[0].Keyframes); + Assert.Equal(0.2, waiting[0].Keyframes[0].CenterX); + Assert.Contains("\"occurrence\": 1", taken.ToJson()); + + // Sent back after an edit of something else, every position lands on the copy it named. + var edited = taken with { Exposure = new ExposureSettings { ExposureOffsetEv = 0.3 } }; + var back = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(edited.ToJson(), here, server))); + Assert.SequenceEqual([2], back.ExcludedFrames); + Assert.Equal(2, back.HeroFrame); + Assert.SequenceEqual([1, 2], back.Camera.Keyframes.Select(k => k.Frame)); + Assert.SequenceEqual([0.1, 0.2], back.Camera.Keyframes.Select(k => k.CenterX)); + Assert.Null(back.PendingFrames); + + // Both copies excluded there: this PC excludes its copy, and the server gets both back. + var both = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(new ProjectSettings { ExcludedFrames = [1, 2] }.ToJson(), server, here))); + Assert.SequenceEqual([1], both.ExcludedFrames); + var excluded = Assert.NotNull(both.PendingFrames); + Assert.Count(1, excluded); + Assert.True(excluded[0] is { Excluded: true, Hero: false, Occurrence: 1 }); + var returned = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(both.ToJson(), here, server))); + Assert.SequenceEqual([1, 2], returned.ExcludedFrames); + Assert.Null(returned.PendingFrames); + } + + [Test] + public void TheCopiesOfAPhotoAreToldApartByTheirOrder() + { + var time = new DateTime(2026, 9, 28, 18, 0, 0); + var hashed = new FramePhoto(new string('a', 64), 100, time); + var other = new FramePhoto(new string('b', 64), 200, time); + var unhashed = new FramePhoto(null, 100, time); + // The frame at 3 has not been hashed yet: it may be a copy of the photo, or another photo of the same size taken in + // the same second. The frames with the photo's hash are its copies; size and capture time match the unhashed one. + var frames = Frames([other, hashed, other, unhashed, hashed]); + + Assert.SequenceEqual([1, 4], new[] { 0, 1, 2 }.Select(n => frames.IndexOf(hashed, n)).OfType()); + Assert.Null(frames.IndexOf(hashed, 2)); + Assert.SequenceEqual([1, 3, 4], new[] { 0, 1, 2 }.Select(n => frames.IndexOf(unhashed, n)).OfType()); + Assert.SequenceEqual([0, 0, 1, 1, 1], Enumerable.Range(0, 5).Select(frames.Occurrence)); + Assert.Equal(0, frames.Occurrence(9)); + Assert.Equal(2, frames.IndexOf(new FramePhoto(new string('B', 64), 0, null), 1)); + // Without a frame holding its hash, a hashed photo is the frames not hashed yet with its size and capture time. + Assert.Equal(3, frames.IndexOf(new FramePhoto(new string('c', 64), 100, time))); + } + + [Test] + public void APhotoNotHashedYetDoesNotTakeThePositionsOfAnotherWithItsSizeAndTime() + { + // Two photos of a burst share size and capture time (a RAW of constant size, no sub-second times). The server has + // not hashed the first yet; this PC has hashed both and does not have the third photo yet. + var time = new DateTime(2026, 9, 28, 18, 0, 0); + var (first, second) = (new FramePhoto(new string('a', 64), 100, time), new FramePhoto(new string('b', 64), 100, time)); + var server = Frames([first with { Sha256 = null }, second, Photo(3)]); + var here = Frames([first, second]); + + // The second photo excluded on the server is the second here, and back; the first stays the hero on both. + var project = new ProjectSettings { ExcludedFrames = [1, 2], HeroFrame = 0 }; + var taken = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(project.ToJson(), server, here))); + Assert.SequenceEqual([1], taken.ExcludedFrames); + Assert.Equal(0, taken.HeroFrame); + var waiting = Assert.NotNull(taken.PendingFrames); + Assert.True(waiting is [{ Excluded: true, Occurrence: 0 }] && waiting[0].Sha256 == Photo(3).Sha256, "only the third photo waits"); + var back = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(taken.ToJson(), here, server))); + Assert.SequenceEqual([1, 2], back.ExcludedFrames); + Assert.Equal(0, back.HeroFrame); + Assert.Null(back.PendingFrames); + + // A copy that has not hashed its first frame still finds the second photo by its hash, not on that frame. + Assert.Equal(1, server.IndexOf(second)); + Assert.Equal(0, server.Occurrence(1)); + Assert.Equal(0, server.IndexOf(first)); + } + [Test] public void AProjectNamingNoFrameCrossesAsItIs() { diff --git a/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs b/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs index c795358e..dbcc567b 100644 --- a/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs +++ b/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs @@ -174,6 +174,8 @@ internal sealed class FakeSyncRemote : ISyncRemote "original" when CorruptOnce == frameId => [.. frame.Bytes.Select(b => (byte)~b)], "original" => frame.Bytes, "proxy" or "thumb" when FailAssets => throw new TitanoApiException(HttpStatusCode.InternalServerError, new ApiError("internal", "failed")), + // A proxy a client or render node sent is served as soon as it is filed, like the manifest says. + "proxy" when SentProxies.TryGetValue(frameId, out var sent) => sent, "proxy" when (sequence.Status & SequenceStatus.ProxiesBuilt) != 0 => frame.Proxy, "thumb" when (sequence.Status & SequenceStatus.ThumbsBuilt) != 0 => frame.Proxy[..Math.Min(frame.Proxy.Length, 64)], _ => throw NotFound(), diff --git a/tests/Titano.Data.Tests/Sync/SyncAgentTests.cs b/tests/Titano.Data.Tests/Sync/SyncAgentTests.cs index cfdc577a..5c12e86d 100644 --- a/tests/Titano.Data.Tests/Sync/SyncAgentTests.cs +++ b/tests/Titano.Data.Tests/Sync/SyncAgentTests.cs @@ -159,6 +159,74 @@ public sealed class SyncAgentTests(TestContext context) Assert.Equal(2, (await DownloadsAsync(f)).Count); } + [Test] + public async Task ThumbnailsStandingInAreReplacedOnceTheServerOffersTheirProxies() + { + await using var f = await SyncFixture.CreateAsync(context); + // The server cannot decode these originals and waits for their proxies; one frame (missing or damaged) never gets + // one, so the sequence's proxy flag never comes. + var remote = f.Remote.Add("Fog", f.NewPhotos(3), status: SequenceStatus.ThumbsBuilt); + remote.Undecodable = true; + var engine = await f.StartEngineAsync(); + await f.RefreshAsync(); + var first = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Fog", SyncDownloadMode.Proxies, null); + await f.Archive.WaitForAsync(first.Id, JobState.Done); + Assert.True(Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id)).Files.All(file => new FileInfo(file!).Length == 64), "thumbnails stand in"); + await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(KeepProxiesOffline: true), engine, EventsOnly); + agent.Start(); + await WaitAsync(() => agent.Snapshot is not null, "first comparison"); + await agent.RefreshAsync(f.Ct); + Assert.Count(1, await DownloadsAsync(f)); + + // Another PC sends the proxies of two frames; the server's proxy pass then records the sequence's state. + foreach (var frame in remote.Frames.Take(2)) f.Remote.SentProxies[frame.Id] = frame.Proxy; + remote.UpdatedAt = DateTimeOffset.UtcNow.AddSeconds(1); + await agent.RefreshAsync(f.Ct); + var refresh = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id); + await f.Archive.WaitForAsync(refresh.Id, JobState.Done); + + var opened = Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id)); + Assert.SequenceEqual([remote.Frames[0].Proxy.Length, remote.Frames[1].Proxy.Length, 64], opened.Files.Select(file => (int)new FileInfo(file!).Length)); + // The frame still waiting keeps its thumbnail; nothing is queued again until the server's sequence changes. + await agent.RefreshAsync(f.Ct); + Assert.Count(2, await DownloadsAsync(f)); + } + + [Test] + public async Task AStandInDownloadThatFailedIsQueuedAgainAfterItsBackoff() + { + await using var f = await SyncFixture.CreateAsync(context); + var remote = f.Remote.Add("Fog", f.NewPhotos(3), status: SequenceStatus.ThumbsBuilt); + remote.Undecodable = true; + var engine = await f.StartEngineAsync(); + await f.RefreshAsync(); + var first = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Fog", SyncDownloadMode.Proxies, null); + await f.Archive.WaitForAsync(first.Id, JobState.Done); + await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(KeepProxiesOffline: true), engine, EventsOnly); + agent.Start(); + await WaitAsync(() => agent.Snapshot is not null, "first comparison"); + + // Two frames' proxies reach the server, but their download fails (the server restarts meanwhile). + foreach (var frame in remote.Frames.Take(2)) f.Remote.SentProxies[frame.Id] = frame.Proxy; + remote.UpdatedAt = DateTimeOffset.UtcNow.AddSeconds(1); + f.Remote.FailAssets = true; + await agent.RefreshAsync(f.Ct); + var failed = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id); + await f.Archive.WaitForAsync(failed.Id, JobState.Failed); + + // The server's sequence does not change again: once the backoff has passed, the download is queued anyway. + f.Remote.FailAssets = false; + await WaitAsync(async () => + { + await agent.RefreshAsync(f.Ct); + return (await DownloadsAsync(f)).Count == 3; + }, "the download queued again"); + var retry = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id && j.Id != failed.Id); + await f.Archive.WaitForAsync(retry.Id, JobState.Done); + var opened = Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id)); + Assert.SequenceEqual([remote.Frames[0].Proxy.Length, remote.Frames[1].Proxy.Length, 64], opened.Files.Select(file => (int)new FileInfo(file!).Length)); + } + private static async Task> DownloadsAsync(SyncFixture f) => (await f.Db.Jobs.ListAsync(null, JobKind.Download, 100, null, f.Ct)).Items;