using System.Collections.Concurrent; using System.IO; using System.Net; using System.Runtime.CompilerServices; using System.Threading.Channels; using Chronos.App.Editor; using Chronos.Core.Model; using Chronos.Protocol; using Chronos.Protocol.Client; namespace Chronos.App.Tests.Editor; /// /// 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. /// internal sealed class FakeRemoteSequenceApi(Sequence sequence, IReadOnlyList frames) : IRemoteSequenceApi { private readonly Lock _gate = new(); 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; 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; } /// Every edit the server accepted or refused, in order. public List<(UpdateSequenceRequest Request, bool Accepted)> Edits { get; } = []; public List Posted { get; } = []; /// Priorities set after jobs were posted (job, wire name). public List<(Guid Job, string Priority)> Priorities { get; } = []; /// The server's jobs; tests change them while the source's event loop reads them. public ConcurrentDictionary Jobs { get; } = new(); /// Thrown by the next read of a job (a failure the editor's event listener does not expect). public Exception? FailNextJobRead { get; set; } /// Thrown by the next edit before it reaches the server (the connection dropped). public Exception? FailNextEdit { get; set; } /// Someone else edits the settings before each of the next edits reaches the server (it is refused with 409). public Queue> EditsBefore { get; } = new(); public bool Disposed { get; private set; } /// Completes 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) => 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) { lock (_gate) return Task.FromResult(Dto(id)); } public Task 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 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 ChronosApiException(HttpStatusCode.Conflict, new ApiError("settings_conflict", "changed", SettingsVersion.ToString())); } if (request.ExpectedFramesVersion is { } frames && frames != FramesVersion) { Edits.Add((request, false)); throw new ChronosApiException(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 GetAnalysisReportAsync(Guid id, CancellationToken cancellationToken) { lock (_gate) { Check(id); return Task.FromResult(Report); } } public Task 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 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 ChronosApiException(HttpStatusCode.NotFound, new ApiError("not_found", "job", "job")); } } public Task> ListActiveJobsAsync(CancellationToken cancellationToken) { lock (_gate) return Task.FromResult>([.. Jobs.Values.Where(j => j.State is "queued" or "running" or "paused")]); } public Task CancelJobAsync(Guid id, CancellationToken cancellationToken) => Change(id, job => job with { State = "cancelled", Finished = DateTimeOffset.UtcNow }); public Task RetryJobAsync(Guid id, CancellationToken cancellationToken) => Change(id, job => job with { State = "queued", Error = null, Finished = null }); public Task SetJobPriorityAsync(Guid id, string priority, CancellationToken cancellationToken) { lock (_gate) Priorities.Add((id, priority)); return Change(id, job => job with { Priority = priority }); } public async IAsyncEnumerable 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 Change(Guid id, Func change) { lock (_gate) { if (!Jobs.TryGetValue(id, out var job)) throw new ChronosApiException(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 ChronosApiException(HttpStatusCode.NotFound, new ApiError("not_found", "gone", "sequence")); } }