Photos not sent: automatic photos of an integrated pair that failed three times in a row are now told with an error toast that shows the row, and the row reads "not sent" with the last reason. The matches-found and linked toasts of background detections run from their Windows notification too. Maintenance now clears a merge's or an integration's journal whose job is done, cancelled, or deleted without a cancel and untouched for the history's days. Tests pin the matches jobs in the priority queue, the owner's defaults (ask always, union, copy across), the dialog starting from the settings, Choose each preselecting nothing, no automatic photos for a pair whose server copy is gone, the repair of a corrupt local frame by an Integrate, and the owner's whole scenario end to end against a real in-process server. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
524 lines
26 KiB
C#
524 lines
26 KiB
C#
using System.Net;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Security.Cryptography;
|
|
using System.Threading.Channels;
|
|
using Chronos.Core.Metadata;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Data.Sync;
|
|
using Chronos.Protocol;
|
|
using Chronos.Protocol.Client;
|
|
|
|
namespace Chronos.Data.Tests.Sync;
|
|
|
|
/// <summary>An in-memory Chronos Server for the sync engine: sequences with versions, originals, proxies, thumbnails and events.</summary>
|
|
internal sealed class FakeSyncRemote : ISyncRemote
|
|
{
|
|
private readonly Lock _gate = new();
|
|
private readonly Channel<ServerEvent> _events = Channel.CreateUnbounded<ServerEvent>();
|
|
private readonly Dictionary<string, FakeSequence> _sessions = [];
|
|
|
|
/// <summary>The server's key: an address key unless a test names one by id (<c>id:<N></c>).</summary>
|
|
public string Server { get; init; } = "https://nas.test:8443";
|
|
|
|
public Dictionary<Guid, FakeSequence> Sequences { get; } = [];
|
|
|
|
/// <summary>Manifest requests so far (comparisons skip them while frame counters stand still).</summary>
|
|
public int ManifestCalls { get; private set; }
|
|
|
|
/// <summary>Listings still to fail with a network error.</summary>
|
|
public int FailingListings { get; set; }
|
|
|
|
/// <summary>Event streams still to be lost right after they opened.</summary>
|
|
public int FailingEvents { get; set; }
|
|
|
|
/// <summary>The next original download of this frame returns damaged bytes.</summary>
|
|
public Guid? CorruptOnce { get; set; }
|
|
|
|
/// <summary>Sequences the listing skips (a page boundary moved while it was read); they are still there.</summary>
|
|
public HashSet<Guid> Unlisted { get; } = [];
|
|
|
|
/// <summary>Sequences whose manifest the server refuses (403), as for an account that lost a right.</summary>
|
|
public HashSet<Guid> Refused { get; } = [];
|
|
|
|
/// <summary>Proxy and thumbnail downloads fail with a server error.</summary>
|
|
public bool FailAssets { get; set; }
|
|
|
|
/// <summary>
|
|
/// Assets (frame id, kind) the sequence's flags offer that the server has not drawn yet: frames added since its last
|
|
/// thumbnail or proxy pass answer 404 until that pass ends, as the real endpoints do.
|
|
/// </summary>
|
|
public HashSet<(Guid Frame, string Kind)> Undrawn { get; } = [];
|
|
|
|
/// <summary>Proxies clients sent, by frame id (for sequences the server cannot decode).</summary>
|
|
public Dictionary<Guid, byte[]> SentProxies { get; } = [];
|
|
|
|
/// <summary>Edits the server accepted, in order.</summary>
|
|
public List<UpdateSequenceRequest> Updates { get; } = [];
|
|
|
|
/// <summary>The settings format the server announces (an older server's 1).</summary>
|
|
public int SettingsFormat { get; set; } = Chronos.Core.Project.ProjectSettings.CurrentVersion;
|
|
|
|
public Task<int> SettingsFormatAsync(CancellationToken cancellationToken) => Task.FromResult(SettingsFormat);
|
|
|
|
/// <summary>
|
|
/// The capabilities the server announces (<see cref="ServerCapabilities"/>): none by default, an older server's path
|
|
/// (owner review 6, #73); tests of the lookup and of uploads into a target opt in.
|
|
/// </summary>
|
|
public HashSet<string> Capabilities { get; } = new(StringComparer.Ordinal);
|
|
|
|
public Task<IReadOnlySet<string>> CapabilitiesAsync(CancellationToken cancellationToken)
|
|
{
|
|
lock (_gate) return Task.FromResult<IReadOnlySet<string>>(new HashSet<string>(Capabilities, StringComparer.Ordinal));
|
|
}
|
|
|
|
/// <summary>Lookup requests so far, as received.</summary>
|
|
public List<PhotoLookupRequest> Lookups { get; } = [];
|
|
|
|
/// <summary>Uploads into a target so far (<see cref="UploadFileIntoAsync"/>), and how many the server filed from a copy it held elsewhere.</summary>
|
|
public int IntoUploads { get; private set; }
|
|
|
|
public int CopiedInto { get; private set; }
|
|
|
|
/// <summary>Frame deletions refused with 403, as for an account that is neither the owner nor an admin.</summary>
|
|
public bool ForbidFrameDeletes { get; set; }
|
|
|
|
/// <summary>Frames moved to the server's trash so far, by sequence.</summary>
|
|
public List<(Guid SequenceId, FakeFrame Frame)> Trashed { get; } = [];
|
|
|
|
/// <summary>Files <paramref name="sequence"/> under <paramref name="sessionKey"/>, as an upload with that key would.</summary>
|
|
public void FileUnder(string sessionKey, FakeSequence sequence)
|
|
{
|
|
lock (_gate) _sessions[sessionKey] = sequence;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Like the server (owner review 6, #73): per probe, the sequences holding its hashes in a frame (a sequence it never
|
|
/// hashed lists none), tombstoning them (by the photo's or its replacement's SHA-256), holding a frame of its unhashed keys
|
|
/// by size and capture millisecond, or filed under its session key. 404 without <see cref="ServerCapabilities.PhotoLookup"/>,
|
|
/// 413 beyond the limits.
|
|
/// </summary>
|
|
public Task<PhotoLookupResponse> LookupPhotosAsync(PhotoLookupRequest request, CancellationToken cancellationToken)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (!Capabilities.Contains(ServerCapabilities.PhotoLookup)) throw new ChronosApiException(HttpStatusCode.NotFound, new ApiError("not_found", "route"));
|
|
if (request.Probes.Count > PhotoLookupRequest.MaxProbes || request.CountItems() > PhotoLookupRequest.MaxItems)
|
|
throw new ChronosApiException(HttpStatusCode.RequestEntityTooLarge, new ApiError("too_many", "probes"));
|
|
Lookups.Add(request);
|
|
var results = new List<ProbeResult>();
|
|
foreach (var probe in request.Probes)
|
|
{
|
|
var hashes = probe.Sha256.Select(h => h.ToLowerInvariant()).ToHashSet(StringComparer.Ordinal);
|
|
var keys = (probe.Unhashed ?? []).Select(k => (k.Size, Ms(k.CapturedAt))).ToHashSet();
|
|
var filed = probe.SessionKey is { } key && _sessions.TryGetValue(key, out var held) ? held : null;
|
|
var hits = new List<PhotoLookupHit>();
|
|
foreach (var sequence in Sequences.Values)
|
|
{
|
|
var inFrames = sequence.Unhashed ? 0 : sequence.Frames.Select(f => f.Sha256).Where(hashes.Contains).Distinct(StringComparer.Ordinal).Count();
|
|
var removed = hashes.Count(h => sequence.Removed.Any(r => r.Sha256 == h || r.Replacement == h));
|
|
var unhashed = keys.Count(k => sequence.Frames.Any(f => f.CapturedAt is { } at && f.Bytes.Length == k.Size && Ms(at) == k.Item2));
|
|
var session = ReferenceEquals(filed, sequence);
|
|
if (inFrames + removed + unhashed > 0 || session) hits.Add(new PhotoLookupHit(sequence.Id, inFrames, removed, unhashed, session));
|
|
}
|
|
results.Add(new ProbeResult(probe.Key, hits));
|
|
}
|
|
return Task.FromResult(new PhotoLookupResponse(results));
|
|
}
|
|
|
|
static long Ms(DateTime at) => at.Ticks / TimeSpan.TicksPerMillisecond;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Like the server with <see cref="ServerCapabilities.UploadInto"/>: the photo is filed into the target even when another
|
|
/// sequence holds it (a server-side copy, counted in <see cref="CopiedInto"/>); one the target holds answers its frame, one
|
|
/// it tombstoned answers none. Without the capability the server ignores the flag: an upload as before.
|
|
/// </summary>
|
|
public async Task<CompleteUploadResponse?> UploadFileIntoAsync(string path, Guid sequenceId, string sha256, DateTime? capturedAt,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
bool capable;
|
|
lock (_gate) capable = Capabilities.Contains(ServerCapabilities.UploadInto);
|
|
if (!capable) return await UploadFileAsync(path, sequenceId, null, sha256, capturedAt, cancellationToken);
|
|
var bytes = await File.ReadAllBytesAsync(path, cancellationToken);
|
|
if (Convert.ToHexStringLower(SHA256.HashData(bytes)) != sha256)
|
|
throw new ChronosApiException(HttpStatusCode.BadRequest, new ApiError("hash_mismatch", "hash"));
|
|
lock (_gate)
|
|
{
|
|
IntoUploads++;
|
|
var target = Find(sequenceId);
|
|
if (target.Removed.Any(r => r.Sha256 == sha256)) return null;
|
|
var index = target.Frames.FindIndex(f => f.Sha256 == sha256);
|
|
if (index >= 0) return new CompleteUploadResponse(target.Frames[index].Id, target.Id, index);
|
|
if (Sequences.Values.Where(s => !s.Unhashed && s != target).SelectMany(s => s.Frames).Any(f => f.Sha256 == sha256)) CopiedInto++;
|
|
var frame = target.AddFrame(bytes, Path.GetFileName(path), capturedAt);
|
|
return new CompleteUploadResponse(frame.Id, target.Id, target.Frames.IndexOf(frame));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Like the server's <c>frames/delete</c>: 404 for an unknown sequence, 403 with <see cref="ForbidFrameDeletes"/>, 409
|
|
/// <c>frames_conflict</c> when a frame is not there or the frames version moved, 409 <c>would_empty</c>; a dry run answers
|
|
/// the plan; else the frames go to the trash, each leaving a tombstone, and the frames version moves.
|
|
/// </summary>
|
|
public Task<FrameDeleteResultDto> DeleteFramesAsync(Guid sequenceId, FrameDeleteRequest request, CancellationToken cancellationToken)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
var sequence = Find(sequenceId);
|
|
if (ForbidFrameDeletes) throw new ChronosApiException(HttpStatusCode.Forbidden, new ApiError("forbidden", "delete"));
|
|
var wanted = request.FrameIds.ToHashSet();
|
|
var frames = sequence.Frames.Where(f => wanted.Contains(f.Id)).ToList();
|
|
if (frames.Count != wanted.Count || (request.ExpectedFramesVersion is { } expected && expected != sequence.FramesVersion))
|
|
throw new ChronosApiException(HttpStatusCode.Conflict, new ApiError("frames_conflict", "changed"));
|
|
if (frames.Count == sequence.Frames.Count) throw new ChronosApiException(HttpStatusCode.Conflict, new ApiError("would_empty", "empty"));
|
|
var bytes = frames.Sum(f => (long)f.Bytes.Length);
|
|
if (request.DryRun)
|
|
return Task.FromResult(new FrameDeleteResultDto(sequenceId, frames.Count, bytes, sequence.FramesVersion, sequence.Frames.Count, null, true));
|
|
var at = DateTimeOffset.UtcNow;
|
|
foreach (var frame in frames)
|
|
{
|
|
sequence.Frames.Remove(frame);
|
|
Trashed.Add((sequenceId, frame));
|
|
if (!sequence.Removed.Any(r => r.Sha256 == frame.Sha256)) sequence.Removed.Add(new RemovedPhotoDto(frame.Sha256, null, "deleted", at));
|
|
}
|
|
sequence.FramesVersion++;
|
|
sequence.UpdatedAt = at;
|
|
return Task.FromResult(new FrameDeleteResultDto(sequenceId, frames.Count, bytes, sequence.FramesVersion, sequence.Frames.Count,
|
|
$"trash/photos-{Guid.NewGuid():N}", false));
|
|
}
|
|
}
|
|
|
|
public FakeSequence Add(string? title, IEnumerable<byte[]> originals, string? settingsJson = null,
|
|
SequenceStatus status = SequenceStatus.ProxiesBuilt | SequenceStatus.ThumbsBuilt)
|
|
{
|
|
var sequence = new FakeSequence { Id = Guid.CreateVersion7(), Title = title, SettingsJson = settingsJson, Status = status };
|
|
foreach (var bytes in originals) sequence.AddFrame(bytes);
|
|
lock (_gate) Sequences[sequence.Id] = sequence;
|
|
return sequence;
|
|
}
|
|
|
|
/// <summary>Someone deletes the sequence on the server: every later call for it answers 404.</summary>
|
|
public void Drop(Guid id)
|
|
{
|
|
lock (_gate) Sequences.Remove(id);
|
|
}
|
|
|
|
/// <summary>Someone else edits the settings on the server.</summary>
|
|
public void EditSettings(Guid id, string settingsJson)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
var s = Sequences[id];
|
|
s.SettingsJson = settingsJson;
|
|
s.SettingsVersion++;
|
|
s.UpdatedAt = DateTimeOffset.UtcNow;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends an event to the stream open now. With <see cref="DropWhileClosed"/>, one sent while no stream is open is lost,
|
|
/// as a real server's is.
|
|
/// </summary>
|
|
public void Publish(ServerEvent e)
|
|
{
|
|
if (DropWhileClosed && !Subscribed) return;
|
|
_events.Writer.TryWrite(e);
|
|
}
|
|
|
|
/// <summary>Events sent while no stream is open are lost (<see cref="Publish"/>).</summary>
|
|
public bool DropWhileClosed { get; set; }
|
|
|
|
/// <summary>How long a stream takes to open after a lost one (a reconnection).</summary>
|
|
public TimeSpan ReconnectDelay { get; set; }
|
|
|
|
/// <summary>Whether an event stream is open now.</summary>
|
|
public bool Subscribed => Volatile.Read(ref _subscribed) > 0;
|
|
|
|
private int _subscribed;
|
|
private int _opened;
|
|
|
|
public Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken cancellationToken)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (FailingListings > 0)
|
|
{
|
|
FailingListings--;
|
|
throw new HttpRequestException("connection refused");
|
|
}
|
|
return Task.FromResult<IReadOnlyList<SequenceDto>>([.. Sequences.Values.Where(s => !Unlisted.Contains(s.Id)).Select(s => s.Dto())]);
|
|
}
|
|
}
|
|
|
|
/// <summary>The next request for this sequence times out (HttpClient reports a timeout as a cancellation).</summary>
|
|
public Guid? TimeoutOnce { get; set; }
|
|
|
|
public Task<SequenceDto> GetSequenceAsync(Guid id, CancellationToken cancellationToken)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (TimeoutOnce == id)
|
|
{
|
|
TimeoutOnce = null;
|
|
throw new TaskCanceledException("The request timed out.");
|
|
}
|
|
return Task.FromResult(Find(id).Dto());
|
|
}
|
|
}
|
|
|
|
/// <summary>Runs once, before the next manifest is answered: the archive on this PC changing while the sync compares.</summary>
|
|
public Func<Task>? OnceBeforeManifest { get; set; }
|
|
|
|
public async Task<SequenceManifest> GetManifestAsync(Guid id, CancellationToken cancellationToken)
|
|
{
|
|
if (OnceBeforeManifest is { } before)
|
|
{
|
|
OnceBeforeManifest = null;
|
|
await before();
|
|
}
|
|
lock (_gate)
|
|
{
|
|
ManifestCalls++;
|
|
if (Refused.Contains(id)) throw new ChronosApiException(HttpStatusCode.Forbidden, new ApiError("forbidden", "refused"));
|
|
return Find(id).Manifest(SentProxies.ContainsKey);
|
|
}
|
|
}
|
|
|
|
/// <summary>Runs once, before the next frame listing is answered (frame positions translated against the server's frames).</summary>
|
|
public Func<Task>? OnceBeforeFrames { get; set; }
|
|
|
|
public async Task<IReadOnlyList<FrameDto>> ListFramesAsync(Guid sequenceId, CancellationToken cancellationToken)
|
|
{
|
|
if (OnceBeforeFrames is { } before)
|
|
{
|
|
OnceBeforeFrames = null;
|
|
await before();
|
|
}
|
|
lock (_gate)
|
|
{
|
|
var sequence = Find(sequenceId);
|
|
return [.. sequence.Frames.Select(sequence.FrameDto)];
|
|
}
|
|
}
|
|
|
|
public Task<SequenceDto> UpdateSequenceAsync(Guid id, UpdateSequenceRequest request, CancellationToken cancellationToken)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
var s = Find(id);
|
|
if (request.ExpectedSettingsVersion is { } expected && expected != s.SettingsVersion)
|
|
throw new ChronosApiException(HttpStatusCode.Conflict, new ApiError("settings_conflict", "changed"));
|
|
if (request.ExpectedFramesVersion is { } frames && frames != s.FramesVersion)
|
|
throw new ChronosApiException(HttpStatusCode.Conflict, new ApiError("frames_conflict", "changed"));
|
|
Updates.Add(request);
|
|
if (request.Title is not null) s.Title = request.Title.Length == 0 ? null : request.Title;
|
|
if (request.Tags is not null) s.Tags = [.. request.Tags];
|
|
if (request.Rating is { } rating) s.Rating = rating;
|
|
if (request.Notes is not null) s.Notes = request.Notes.Length == 0 ? null : request.Notes;
|
|
if (request.SettingsJson is not null) s.SettingsJson = request.SettingsJson;
|
|
s.SettingsVersion++;
|
|
s.UpdatedAt = DateTimeOffset.UtcNow;
|
|
return Task.FromResult(s.Dto());
|
|
}
|
|
}
|
|
|
|
/// <summary>Like the server: content it already holds anywhere is not stored again; a session key files the first original into a new sequence.</summary>
|
|
public async Task<CompleteUploadResponse?> UploadFileAsync(string path, Guid? sequenceId, string? sessionKey, string sha256, DateTime? capturedAt,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var bytes = await File.ReadAllBytesAsync(path, cancellationToken);
|
|
if (Convert.ToHexStringLower(SHA256.HashData(bytes)) != sha256)
|
|
throw new ChronosApiException(HttpStatusCode.BadRequest, new ApiError("hash_mismatch", "hash"));
|
|
lock (_gate)
|
|
{
|
|
// Originals it never hashed are not recognised by content.
|
|
if (Sequences.Values.Where(s => !s.Unhashed).SelectMany(s => s.Frames).FirstOrDefault(f => f.Sha256 == sha256) is { } existing)
|
|
return new CompleteUploadResponse(existing.Id, sequenceId ?? Guid.Empty, -1);
|
|
FakeSequence target;
|
|
if (sequenceId is { } id) target = Find(id);
|
|
else if (!_sessions.TryGetValue(sessionKey!, out target!))
|
|
{
|
|
target = new FakeSequence { Id = Guid.CreateVersion7() };
|
|
Sequences[target.Id] = target;
|
|
_sessions[sessionKey!] = target;
|
|
}
|
|
var frame = target.AddFrame(bytes, Path.GetFileName(path), capturedAt);
|
|
return new CompleteUploadResponse(frame.Id, target.Id, target.Frames.Count - 1);
|
|
}
|
|
}
|
|
|
|
public async Task DownloadFrameAsync(Guid frameId, string kind, Stream destination, CancellationToken cancellationToken)
|
|
{
|
|
byte[] bytes;
|
|
lock (_gate)
|
|
{
|
|
var (sequence, frame) = Sequences.Values.SelectMany(s => s.Frames.Select(f => (s, f))).FirstOrDefault(p => p.f.Id == frameId);
|
|
if (frame is null) throw NotFound();
|
|
bytes = kind switch
|
|
{
|
|
"original" when CorruptOnce == frameId => [.. frame.Bytes.Select(b => (byte)~b)],
|
|
"original" => frame.Bytes,
|
|
"proxy" or "thumb" when FailAssets => throw new ChronosApiException(HttpStatusCode.InternalServerError, new ApiError("internal", "failed")),
|
|
"proxy" or "thumb" when Undrawn.Contains((frameId, kind)) => throw NotFound(),
|
|
// A proxy a client or render node sent is served as soon as it is filed, like the manifest says.
|
|
"proxy" when SentProxies.TryGetValue(frameId, out var sent) => sent,
|
|
"proxy" when (sequence.Status & SequenceStatus.ProxiesBuilt) != 0 => frame.Proxy,
|
|
"thumb" when (sequence.Status & SequenceStatus.ThumbsBuilt) != 0 => frame.Proxy[..Math.Min(frame.Proxy.Length, 64)],
|
|
_ => throw NotFound(),
|
|
};
|
|
if (kind == "original" && CorruptOnce == frameId) CorruptOnce = null;
|
|
}
|
|
// Range: continue after what the destination already holds, like the real endpoint.
|
|
var offset = destination.CanSeek ? (int)Math.Min(destination.Length, bytes.Length) : 0;
|
|
if (destination.CanSeek) destination.Seek(0, SeekOrigin.End);
|
|
await destination.WriteAsync(bytes.AsMemory(offset), cancellationToken);
|
|
}
|
|
|
|
/// <summary>Like the server: only a frame whose proxy it asks for takes one, and only a JPEG.</summary>
|
|
public Task UploadProxyAsync(Guid frameId, byte[] jpeg, CancellationToken cancellationToken)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (!Sequences.Values.Any(s => s.Undecodable && s.Frames.Any(f => f.Id == frameId))) throw NotFound();
|
|
if (jpeg is not [0xFF, 0xD8, ..]) throw new ChronosApiException(HttpStatusCode.UnprocessableEntity, new ApiError("invalid_proxy", "not a JPEG"));
|
|
SentProxies[frameId] = jpeg;
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public async Task<string?> DownloadRenderAsync(Guid renderId, Stream destination, CancellationToken cancellationToken)
|
|
{
|
|
FakeRender render;
|
|
lock (_gate) render = Sequences.Values.SelectMany(s => s.Renders).FirstOrDefault(r => r.Id == renderId) ?? throw NotFound();
|
|
var offset = destination.CanSeek ? (int)Math.Min(destination.Length, render.Bytes.Length) : 0;
|
|
if (destination.CanSeek) destination.Seek(0, SeekOrigin.End);
|
|
await destination.WriteAsync(render.Bytes.AsMemory(offset), cancellationToken);
|
|
return render.FileName;
|
|
}
|
|
|
|
/// <summary>Like the server: the SHA-256 is checked and a render keeps its id; one it already has is not sent again.</summary>
|
|
public async Task<RenderDto?> UploadRenderAsync(Guid sequenceId, string path, RenderUploadRequest request, CancellationToken cancellationToken)
|
|
{
|
|
var bytes = await File.ReadAllBytesAsync(path, cancellationToken);
|
|
if (Convert.ToHexStringLower(SHA256.HashData(bytes)) != request.Sha256 || bytes.Length != request.Size)
|
|
throw new ChronosApiException(HttpStatusCode.UnprocessableEntity, new ApiError("hash_mismatch", "hash"));
|
|
lock (_gate)
|
|
{
|
|
var sequence = Find(sequenceId);
|
|
if (sequence.Renders.Any(r => r.Id == request.RenderId)) return null;
|
|
var render = new FakeRender(request.RenderId, request.FileName, request.PresetName, bytes, request.Kind);
|
|
sequence.Renders.Add(render);
|
|
return render.Dto();
|
|
}
|
|
}
|
|
|
|
public IAsyncEnumerable<ServerEvent> EventsAsync(CancellationToken cancellationToken) => EventsAsync(() => { }, cancellationToken);
|
|
|
|
public async IAsyncEnumerable<ServerEvent> EventsAsync(Action connected, [EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
if (Interlocked.Increment(ref _opened) > 1 && ReconnectDelay > TimeSpan.Zero) await Task.Delay(ReconnectDelay, cancellationToken);
|
|
lock (_gate)
|
|
{
|
|
if (FailingEvents > 0)
|
|
{
|
|
FailingEvents--;
|
|
throw new HttpRequestException("socket closed");
|
|
}
|
|
}
|
|
Interlocked.Increment(ref _subscribed);
|
|
try
|
|
{
|
|
connected();
|
|
while (await _events.Reader.WaitToReadAsync(cancellationToken))
|
|
{
|
|
while (_events.Reader.TryRead(out var e)) yield return e;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Interlocked.Decrement(ref _subscribed);
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
private FakeSequence Find(Guid id) => Sequences.TryGetValue(id, out var s) ? s : throw NotFound();
|
|
|
|
private static ChronosApiException NotFound() => new(HttpStatusCode.NotFound, new ApiError("not_found", "sequence"));
|
|
}
|
|
|
|
internal sealed class FakeSequence
|
|
{
|
|
public required Guid Id { get; init; }
|
|
public string? Title { get; set; }
|
|
public List<string> Tags { get; set; } = [];
|
|
public int Rating { get; set; }
|
|
public string? Notes { get; set; }
|
|
public string? SettingsJson { get; set; }
|
|
public int SettingsVersion { get; set; } = 1;
|
|
public int FramesVersion { get; set; }
|
|
public SequenceStatus Status { get; set; }
|
|
|
|
/// <summary>The server cannot decode these originals (HEIF): its manifest asks for proxies of them.</summary>
|
|
public bool Undecodable { get; set; }
|
|
|
|
/// <summary>The server adopted these originals and never verified them: it lists no SHA-256 for them.</summary>
|
|
public bool Unhashed { get; set; }
|
|
|
|
public DateTimeOffset UpdatedAt { get; set; } = DateTimeOffset.UtcNow;
|
|
public DateTime? FirstCapture { get; set; }
|
|
public string? CameraModel { get; set; } = "Canon EOS R5";
|
|
public List<FakeFrame> Frames { get; } = [];
|
|
public List<FakeRender> Renders { get; } = [];
|
|
|
|
/// <summary>Tombstones of photos removed on the server (owner review 2, R6), as its manifest lists them.</summary>
|
|
public List<RemovedPhotoDto> Removed { get; } = [];
|
|
|
|
/// <summary>Like the server, the capture time comes from the photo's Exif data when none is given.</summary>
|
|
public FakeFrame AddFrame(byte[] bytes, string? name = null, DateTime? capturedAt = null) => InsertFrame(Frames.Count, bytes, name, capturedAt);
|
|
|
|
/// <summary>A photo filed at <paramref name="index"/> (captured before the frames after it): those move up by one.</summary>
|
|
public FakeFrame InsertFrame(int index, byte[] bytes, string? name = null, DateTime? capturedAt = null)
|
|
{
|
|
name ??= $"IMG_{Frames.Count + 1:0000}.JPG";
|
|
using var stream = new MemoryStream(bytes);
|
|
var frame = new FakeFrame(Guid.CreateVersion7(), name, bytes, capturedAt ?? MetadataReader.Read(stream, name).CapturedAt);
|
|
Frames.Insert(index, frame);
|
|
FramesVersion++;
|
|
UpdatedAt = DateTimeOffset.UtcNow;
|
|
return frame;
|
|
}
|
|
|
|
public SequenceDto Dto() => new(Id, Title, Title ?? "Untitled", "2026/" + Id.ToString("N"), "Canon", CameraModel, null, FirstCapture, null, Frames.Count, 10,
|
|
Frames.Sum(f => (long)f.Bytes.Length), (long)Status, Renders.Count, null, Tags, Rating, Notes, SettingsVersion, FramesVersion, 0, null, UpdatedAt);
|
|
|
|
public SequenceManifest Manifest(Func<Guid, bool> proxySent) => new(Id, FramesVersion, SettingsVersion, SettingsJson, Tags,
|
|
[.. Frames.Select((f, i) => new ManifestFrame(f.Id, i, f.FileName, f.Bytes.Length, Unhashed ? string.Empty : f.Sha256,
|
|
(Status & SequenceStatus.ProxiesBuilt) != 0 || proxySent(f.Id), (Status & SequenceStatus.ThumbsBuilt) != 0, WantsProxy: Undecodable && !proxySent(f.Id)))],
|
|
[.. Renders.Select(r => r.Dto())], Undecodable ? new ProxySpec(1280, 90) : null, Removed.Count == 0 ? null : [.. Removed]);
|
|
|
|
public FrameDto FrameDto(FakeFrame frame) => frame.Dto(Id, Frames.IndexOf(frame), Unhashed);
|
|
}
|
|
|
|
/// <param name="Recorded">The SHA-256 the server records (its file's when null; empty: none, as before migration 0010).</param>
|
|
internal sealed record FakeRender(Guid Id, string FileName, string PresetName, byte[] Bytes, string? Kind = null, string? Recorded = null)
|
|
{
|
|
public string Sha256 => Recorded ?? Convert.ToHexStringLower(SHA256.HashData(Bytes));
|
|
|
|
public RenderDto Dto() => new(Id, PresetName, "hevc", 3840, 2160, 30, 12, Bytes.Length, new DateTimeOffset(2026, 9, 20, 21, 0, 0, TimeSpan.Zero), "Studio NAS",
|
|
Sha256: Sha256.Length == 0 ? null : Sha256, Kind: Kind);
|
|
}
|
|
|
|
internal sealed record FakeFrame(Guid Id, string FileName, byte[] Bytes, DateTime? CapturedAt)
|
|
{
|
|
public string Sha256 { get; } = Convert.ToHexStringLower(SHA256.HashData(Bytes));
|
|
|
|
/// <summary>The original stands in for its proxy: a real JPEG the decoders read.</summary>
|
|
public byte[] Proxy => Bytes;
|
|
|
|
public FrameDto Dto(Guid sequenceId, int index, bool unhashed = false) =>
|
|
new(Id, sequenceId, index, FileName, Bytes.Length, unhashed ? null : Sha256, CapturedAt, null, 1.0 / 250, 8, 100, 24, 1, 48, 32, "jpeg", 0);
|
|
}
|