BRIEF §14.5 asks for an explicit conflict prompt when both sides changed. A save of a server sequence that meets settings someone changed to other values on the server now stops (the change stays pending) and the editor asks: Keep mine saves the editor's values over the server's, Take server (the safe default) shows the server's values as one undoable step, so Ctrl+Z brings the editor's back. Both first take in what only the server changed. Settings changed on one side only still merge silently; a reload after an analysis never merges over a conflicting pending change. The Export "Sync" box moves under Save to so neither is cut in longer languages. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
189 lines
7.5 KiB
C#
189 lines
7.5 KiB
C#
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 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; } = [];
|
|
|
|
public Dictionary<Guid, JobDto> Jobs { get; } = [];
|
|
|
|
/// <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>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) => _events.Writer.TryWrite(e);
|
|
|
|
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()));
|
|
}
|
|
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)
|
|
{
|
|
while (await _events.Reader.WaitToReadAsync(cancellationToken))
|
|
{
|
|
while (_events.Reader.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"));
|
|
}
|
|
}
|