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
206 lines
8.6 KiB
C#
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"));
|
|
}
|
|
}
|