fix(editor): name the frames version in the remote editor's saves
The desktop editor of a server sequence relied on the server's sequenceChanged event to go read-only when frames changed. Scans publish none, and an event missed while the socket reconnected was never noticed, so a save made meanwhile passed the settings-version check and wrote positions in the old order over the ones the server had moved. The PATCH now carries expectedFramesVersion, the frames version of the proxies the editor holds. On 409 the editor reads the manifest: other frames make it outdated (read-only, Get proxies; the edit stays pending), the same frames at a new version retry at that version. After a lost event socket the frames are compared again. Servers that predate the field ignore it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
3 files changed
+73
-10
No files matched your search
@@ -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 <see cref="ProxiesOutdatedException"/>, and frames that change on the server while the sequence is open make
|
||||
/// it <see cref="IsOutdated"/> (read-only, nothing saved or rendered).
|
||||
/// it <see cref="IsOutdated"/> (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.
|
||||
/// </summary>
|
||||
public sealed class RemoteSequenceSource : ISequenceSource
|
||||
{
|
||||
@@ -150,19 +151,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 +225,7 @@ public sealed class RemoteSequenceSource : ISequenceSource
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
private async Task ListenAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
@@ -244,6 +250,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)
|
||||
{
|
||||
|
||||
@@ -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,7 @@ namespace Titano.App.Tests.Editor;
|
||||
internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList<Guid> frames) : IRemoteSequenceApi
|
||||
{
|
||||
private readonly Lock _gate = new();
|
||||
private readonly Channel<ServerEvent> _events = Channel.CreateUnbounded<ServerEvent>();
|
||||
private Channel<ServerEvent> _events = Channel.CreateUnbounded<ServerEvent>();
|
||||
|
||||
/// <summary>The server's frames in order (another list when frames are added or removed on the server).</summary>
|
||||
public IReadOnlyList<Guid> Frames { get; set; } = frames;
|
||||
@@ -59,7 +60,10 @@ internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList<Gui
|
||||
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);
|
||||
|
||||
/// <summary>The event socket drops: the stream open now fails, and the next one starts empty.</summary>
|
||||
public void DropEvents() => Interlocked.Exchange(ref _events, Channel.CreateUnbounded<ServerEvent>()).Writer.TryComplete(new IOException("connection lost"));
|
||||
|
||||
public Task<SequenceDto> GetSequenceAsync(Guid id, CancellationToken cancellationToken)
|
||||
{
|
||||
@@ -98,6 +102,11 @@ internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList<Gui
|
||||
Edits.Add((request, false));
|
||||
throw new TitanoApiException(HttpStatusCode.Conflict, new ApiError("settings_conflict", "changed", SettingsVersion.ToString()));
|
||||
}
|
||||
if (request.ExpectedFramesVersion is { } frames && frames != FramesVersion)
|
||||
{
|
||||
Edits.Add((request, false));
|
||||
throw new TitanoApiException(HttpStatusCode.Conflict, new ApiError("frames_conflict", "frames changed", FramesVersion.ToString()));
|
||||
}
|
||||
Edits.Add((request, true));
|
||||
SettingsJson = request.SettingsJson ?? SettingsJson;
|
||||
SettingsVersion++;
|
||||
@@ -158,9 +167,10 @@ internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList<Gui
|
||||
|
||||
public async IAsyncEnumerable<ServerEvent> EventsAsync([EnumeratorCancellation] CancellationToken cancellationToken)
|
||||
{
|
||||
while (await _events.Reader.WaitToReadAsync(cancellationToken))
|
||||
var events = Volatile.Read(ref _events).Reader;
|
||||
while (await events.WaitToReadAsync(cancellationToken))
|
||||
{
|
||||
while (_events.Reader.TryRead(out var e)) yield return e;
|
||||
while (events.TryRead(out var e)) yield return e;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -433,6 +433,51 @@ 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<ProxiesOutdatedException>(() =>
|
||||
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);
|
||||
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 AConflictFoundOnOtherFramesIsNotMergedOntoThem()
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user