Files
Chronos/tests/Titano.App.Tests/Editor/FakeRemoteSequenceApi.cs
T
Claude 827b224ee3 fix(editor): read inserted frames before a render embeds the project
A render queued before the editor had seen frames inserted under it (a sync
download, an import of earlier photos, a scan without an event) embedded the
project's positions in the old frame order. Render now checks first that the
frames read are still the sequence's (ISequenceSource.FramesCurrentAsync: the
row's frames version on this PC, the manifest on a server). On this PC the
sequence is read again and the positions follow the frames; a server
sequence whose frames changed turns outdated and the render is not queued.

Reads of the sequence no longer overlap: a read waits for the one under way,
saves that meet new frames read them through the same slot, and they save
the project as it is once its positions followed. The frame on screen stays
on its photo when frames are inserted or removed before it.

Tests: the event-loss test waits for the listener's subscription before
dropping the stream, and the conflict tests flush once more after the
choice when a retry started before it was still failing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-12 19:59:45 +00:00

206 lines
8.6 KiB
C#

using System.Collections.Concurrent;
using System.IO;
using System.Net;
using System.Runtime.CompilerServices;
using System.Threading.Channels;
using Titano.App.Editor;
using Titano.Core.Model;
using Titano.Protocol;
using Titano.Protocol.Client;
namespace Titano.App.Tests.Editor;
/// <summary>
/// One server sequence as the API serves it to an editor: its frames, settings with a version that refuses stale edits
/// (409), recorded edits and posted jobs (with their priority, cancel and retry), jobs other clients run, an analysis
/// report and an event stream the test feeds.
/// </summary>
internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList<Guid> frames) : IRemoteSequenceApi
{
private readonly Lock _gate = new();
private readonly TaskCompletionSource _subscribed = new(TaskCreationOptions.RunContinuationsAsynchronously);
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;
public int FramesVersion { get; set; } = 1;
public string? SettingsJson { get; set; }
public int SettingsVersion { get; set; } = 3;
public string? Report { get; set; }
public bool Gone { get; set; }
/// <summary>Every edit the server accepted or refused, in order.</summary>
public List<(UpdateSequenceRequest Request, bool Accepted)> Edits { get; } = [];
public List<CreateJobRequest> Posted { get; } = [];
/// <summary>Priorities set after jobs were posted (job, wire name).</summary>
public List<(Guid Job, string Priority)> Priorities { get; } = [];
/// <summary>The server's jobs; tests change them while the source's event loop reads them.</summary>
public ConcurrentDictionary<Guid, JobDto> Jobs { get; } = new();
/// <summary>Thrown by the next read of a job (a failure the editor's event listener does not expect).</summary>
public Exception? FailNextJobRead { get; set; }
/// <summary>Thrown by the next edit before it reaches the server (the connection dropped).</summary>
public Exception? FailNextEdit { get; set; }
/// <summary>Someone else edits the settings before each of the next edits reaches the server (it is refused with 409).</summary>
public Queue<Func<string?, string>> EditsBefore { get; } = new();
public bool Disposed { get; private set; }
/// <summary>Completes once the editor's listener has opened an event stream (the stream open then is the one it reads).</summary>
public Task Subscribed => _subscribed.Task;
/// <summary>A job of the server, as <c>GET /jobs/{id}</c> returns it.</summary>
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) => 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)
{
lock (_gate) return Task.FromResult(Dto(id));
}
public Task<SequenceManifest> GetManifestAsync(Guid id, CancellationToken cancellationToken)
{
lock (_gate)
{
Check(id);
return Task.FromResult(new SequenceManifest(id, FramesVersion, SettingsVersion, SettingsJson, [],
[.. Frames.Select((frame, i) => new ManifestFrame(frame, i, $"IMG_{i:0000}.JPG", 1_000, "00", true, true))], [
new RenderDto(Guid.CreateVersion7(), "4K archive", "hevc", 3840, 2160, 24, 5, 2_000_000_000, DateTimeOffset.UtcNow.AddDays(-1), "studio-pc"),
]));
}
}
public Task<SequenceDto> UpdateSequenceAsync(Guid id, UpdateSequenceRequest request, CancellationToken cancellationToken)
{
lock (_gate)
{
Check(id);
if (FailNextEdit is { } failure)
{
FailNextEdit = null;
throw failure;
}
if (EditsBefore.TryDequeue(out var theirs))
{
SettingsJson = theirs(SettingsJson);
SettingsVersion++;
}
if (request.ExpectedSettingsVersion is { } expected && expected != SettingsVersion)
{
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++;
return Task.FromResult(Dto(id));
}
}
public Task<string?> GetAnalysisReportAsync(Guid id, CancellationToken cancellationToken)
{
lock (_gate)
{
Check(id);
return Task.FromResult(Report);
}
}
public Task<JobDto> CreateJobAsync(CreateJobRequest request, CancellationToken cancellationToken)
{
lock (_gate)
{
Posted.Add(request);
var job = Job(Guid.CreateVersion7(), request.Kind, "queued", request.Target[0]);
Jobs[job.Id] = job;
return Task.FromResult(job);
}
}
public Task<JobDto> GetJobAsync(Guid id, CancellationToken cancellationToken)
{
lock (_gate)
{
if (FailNextJobRead is { } failure)
{
FailNextJobRead = null;
throw failure;
}
return Jobs.TryGetValue(id, out var job)
? Task.FromResult(job)
: throw new TitanoApiException(HttpStatusCode.NotFound, new ApiError("not_found", "job", "job"));
}
}
public Task<IReadOnlyList<JobDto>> ListActiveJobsAsync(CancellationToken cancellationToken)
{
lock (_gate) return Task.FromResult<IReadOnlyList<JobDto>>([.. Jobs.Values.Where(j => j.State is "queued" or "running" or "paused")]);
}
public Task<JobDto> CancelJobAsync(Guid id, CancellationToken cancellationToken) =>
Change(id, job => job with { State = "cancelled", Finished = DateTimeOffset.UtcNow });
public Task<JobDto> RetryJobAsync(Guid id, CancellationToken cancellationToken) => Change(id, job => job with { State = "queued", Error = null, Finished = null });
public Task<JobDto> SetJobPriorityAsync(Guid id, string priority, CancellationToken cancellationToken)
{
lock (_gate) Priorities.Add((id, priority));
return Change(id, job => job with { Priority = priority });
}
public async IAsyncEnumerable<ServerEvent> EventsAsync([EnumeratorCancellation] CancellationToken cancellationToken)
{
var events = Volatile.Read(ref _events).Reader;
_subscribed.TrySetResult();
while (await events.WaitToReadAsync(cancellationToken))
{
while (events.TryRead(out var e)) yield return e;
}
}
public void Dispose() => Disposed = true;
private SequenceDto Dto(Guid id)
{
Check(id);
return new SequenceDto(id, sequence.Title, sequence.DisplayTitle, sequence.Folder, sequence.CameraMake, sequence.CameraModel, null,
sequence.FirstCapture, sequence.LastCapture, sequence.FrameCount, sequence.MedianInterval, 0, (long)SequenceStatus.ProxiesBuilt, 1, null, [], 0,
null, SettingsVersion, 1, 0, null, DateTimeOffset.UtcNow);
}
private Task<JobDto> Change(Guid id, Func<JobDto, JobDto> change)
{
lock (_gate)
{
if (!Jobs.TryGetValue(id, out var job)) throw new TitanoApiException(HttpStatusCode.NotFound, new ApiError("not_found", "job", "job"));
return Task.FromResult(Jobs[id] = change(job));
}
}
private void Check(Guid id)
{
if (Gone || id != sequence.Id) throw new TitanoApiException(HttpStatusCode.NotFound, new ApiError("not_found", "gone", "sequence"));
}
}