Upload again now deletes the gone pair row once the new sequence is linked, so the pair stops reading "deleted on server" or "kept here". A linked upload the server refuses into its sequence (403 for an account without Edit that does not own it) falls back to ordinary uploads instead of failing; an Integrate that would add photos to such a sequence is blocked in its plan (NoAddRight). Automatic photo transfers pause on a metered connection whatever the option says. Integrate trashes server photos only against the manifest version that checked the winner, and a merge is blocked while the other sequence holds a damaged photo nothing else holds (DamagedPhotos), so nothing unverified reaches the trash. The plan and the confirmations now say what really happens: replaced versions are no longer counted as kept, a merge lists the kept sequence's replaced photos, plan lines use the text colour, an integrated pair that left photos out says new photos move by hand, and a merging pair reads "merging" with its progress. The Compare dialog gets per-side tooltips, class sizes for both sides, policy-aware class tooltips, column headings and readable file names; the sync table shows "deleted there" with Review and warns on skipped rows; the Edit picker names the server, the Library card shows the match status second, a deleted server sequence is named instead of "0 photos", and the match tooltips stop calling a sequence a copy. The capture scenes use the server name, the link names and consistent sample sizes. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
548 lines
27 KiB
C#
548 lines
27 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>
|
|
/// Uploads into a target refused with 403, as for an account with Read and Upload but not Edit that does not own the
|
|
/// target; <see cref="RefusedInto"/> counts them.
|
|
/// </summary>
|
|
public bool ForbidInto { get; set; }
|
|
|
|
public int RefusedInto { get; private set; }
|
|
|
|
/// <summary>Runs once, before the next frame deletion is answered (the server sequence changing meanwhile).</summary>
|
|
public Action? OnceBeforeDelete { get; 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);
|
|
if (ForbidInto)
|
|
{
|
|
lock (_gate) RefusedInto++;
|
|
throw new ChronosApiException(HttpStatusCode.Forbidden, new ApiError("forbidden", "into"));
|
|
}
|
|
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)
|
|
{
|
|
if (OnceBeforeDelete is { } before)
|
|
{
|
|
OnceBeforeDelete = null;
|
|
before();
|
|
}
|
|
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, OwnerUserId, UpdatedAt);
|
|
|
|
/// <summary>The server account that owns the sequence (none by default).</summary>
|
|
public Guid? OwnerUserId { get; set; }
|
|
|
|
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);
|
|
}
|