Files
Alby96andClaude Opus 5.5 f33bcac32e
CI / Build and test (push) Successful in 13m44s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 16s
Release / Build, test and publish (push) Successful in 26m34s
CI / PostgreSQL 16 integration (push) Failing after 17m36s
CI / PostgreSQL 17 integration (push) Failing after 15m36s
CI / Docker image (push) Successful in 1m12s
Release / Server image (push) Failing after 15s
feat(copies): matches between this PC and the server, Integrate and merge (owner review 6, v1.2.0) (#74)
The same time-lapse on a server and on this PC under different ids, or twice on this PC, is recognised,
compared and settled as the owner asked in owner review 6.

Matches are found after each sync refresh, through the server's new photo lookup, and after the jobs that
change photos. The default is to ask every time. Server › Matches offers:
- Keep apart, which is remembered;
- Link only and Unlink;
- the Compare dialog: photos, details line by line, projects and the plan.

Integrate completes both sides. Photos default to Union, projects are copied across, and a losing version
goes to the trash only after a hash check. Afterwards new photos move by themselves, and deletions wait for
the user.

A merge of two local sequences verifies every photo before the other sequence goes to its archive's trash.
Upload all local skips suspected matches and flags them.

Migration 0012 adds the found_copies and copy_probes tables. Jobs 25 (Integrate) and 26 (MergeSequences) are
new, and so are the server capabilities photo-lookup and upload-into.

Refs #73

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-11-18 15:20:29 +01:00

394 lines
24 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.Security.Cryptography;
using Chronos.Core.Codecs.Jpeg;
using Chronos.Core.Imaging;
using Chronos.Core.Metadata;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data;
using Chronos.Data.Archiving;
using Chronos.Data.Copies;
using Chronos.Data.Jobs;
using Chronos.Data.Projects;
using Chronos.Data.Repositories;
using Chronos.Data.Sync;
using Chronos.Protocol.Client;
using Chronos.Server.Storage;
using Chronos.Testing;
namespace Chronos.Server.Tests.Sync;
/// <summary>
/// The owner's scenario of review 6 (#73) end to end, against a real in-process server: a time-lapse uploaded from this PC,
/// an old copy of it found again on a disk adopted as an archive, compared, kept apart, integrated (Union) both ways with
/// the details settled line by line and the projects copied across, its new photos moving by themselves unless the
/// connection is metered, Upload all local leaving a suspected copy out, and two copies on this PC merged into one.
/// </summary>
[Category("server")]
[Timeout(300_000)]
public sealed class CopyScenarioTests(TestContext context)
{
private const string PcName = "STUDIO";
private const string ServerName = "Test server";
private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0);
private static readonly TimeSpan Deadline = TimeSpan.FromSeconds(60);
private CancellationToken Ct => context.Cancellation;
[Test]
public async Task AnOldCopyFoundOnAnAdoptedDiskIsIntegratedWithTheServerAndMergedOnThisPc()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = 64 * 1024, ArchiveModule.Register);
var (_, _, token) = await server.UserAsync("alberto", "editor");
await using var pc = await Pc.StartAsync(context, server, token);
// 1. A time-lapse of eight photos, rated 4, uploaded from this PC.
// Photo 3 carries the camera's sub-second time: two versions of it at that instant under one name are one photo that differs.
static DateTime Captured(int i) => Start.AddSeconds(10 * i).AddMilliseconds(i == 3 ? 250 : 0);
var photos = Enumerable.Range(1, 8).Select(i => Jpeg(Captured(i), i)).ToList();
var original = await pc.LocalAsync(pc.Main, "Comet over the ridge", photos.Select((p, i) => (p, Captured(i + 1))).ToList());
original = (await pc.Db.Sequences.EditAsync(original.Id, new SequenceEdit { Rating = 4 }, null, Ct)).Sequence!;
await pc.WaitAsync((await pc.Sync.EnqueueUploadAsync(pc.Jobs, pc.Server, original, Ct)).Id);
var remoteId = (await pc.Sync.LinkOfAsync(pc.Server, original.Id, Ct))!.RemoteId;
var onServer = Assert.NotNull(await server.Database.Sequences.GetAsync(remoteId));
Assert.True((await server.Database.Frames.ListBySequenceAsync(remoteId)).Select(f => f.Sha256).ToHashSet().SetEquals(photos.Select(Sha)));
await ServerIdleAsync(server);
// Freed on this PC since: the server holds it.
await pc.Archives.DeleteAsync(await pc.Archives.PlanDeleteAsync([original.Id], cancellationToken: Ct), "alberto", cancellationToken: Ct);
await pc.Sync.RefreshAsync(pc.Remote, Policy, Ct);
Assert.Null(await pc.Sync.LinkOfAsync(pc.Server, original.Id, Ct));
// 2. An old disk adopted as an archive: photos 1-6 (photo 3 in another version), two more of its own, another title and rating.
var manifest = await pc.Remote.GetManifestAsync(remoteId, Ct);
var names = manifest.Frames.OrderBy(f => f.Index).Select(f => f.FileName).ToList();
var diskRoot = context.CreateTempDirectory("old-disk");
var folder = Path.Combine(diskRoot, "2026-09-28 comet");
Directory.CreateDirectory(folder);
var differing = Jpeg(Captured(3), 103);
var extras = new[] { Jpeg(Start.AddSeconds(5), 201), Jpeg(Start.AddSeconds(75), 202) };
for (var i = 0; i < 6; i++) await File.WriteAllBytesAsync(Path.Combine(folder, names[i]), i == 2 ? differing : photos[i], Ct);
await File.WriteAllBytesAsync(Path.Combine(folder, "IMG_9001.JPG"), extras[0], Ct);
await File.WriteAllBytesAsync(Path.Combine(folder, "IMG_9002.JPG"), extras[1], Ct);
var disk = await pc.Archives.AdoptAsync(diskRoot, "Old disk", Ct);
await pc.Archives.Indexer.ScanAsync(disk, ScanMode.Full, null, _ => ValueTask.CompletedTask, Ct);
var old = Assert.NotNull((await pc.Db.Sequences.ListAsync(new SequenceQuery { ArchiveId = disk.Id }, Ct)).Items.SingleOrDefault());
old = (await pc.Db.Sequences.EditAsync(old.Id, new SequenceEdit { Title = "Old disk comet", Rating = 2 }, null, Ct)).Sequence!;
Assert.Equal(8, old.FrameCount);
// 3. Detection with Ask always (a refresh in the background): the match is listed, told, and not linked.
var told = new List<CopyFindResult>();
pc.Copies.Found += told.Add;
await pc.Sync.RefreshAsync(pc.Remote, Policy, Ct);
var pair = Assert.Contains(await pc.Copies.ListAsync(Ct), v => v.Copy.LocalId == old.Id).Copy;
Assert.Equal((CopyKind.LocalServer, CopyState.Candidate, (Guid?)remoteId), (pair.Kind, pair.State, pair.RemoteId));
Assert.Contains(told.SelectMany(r => r.New), c => c.Id == pair.Id);
Assert.Empty(told.SelectMany(r => r.AutoLinked));
Assert.Null(await pc.Sync.LinkOfAsync(pc.Server, old.Id, Ct));
// 4. Verified (an adopted folder holds no hashes until then), the comparison shows each class of photo.
await pc.Archives.Verifier.VerifyAsync(disk, [old.Id], default, (_, _, _) => ValueTask.CompletedTask, cancellationToken: Ct);
var review = await pc.Copies.CompareAsync(pair.Id, pc.Remote, Ct);
int Count(PhotoClass c) => review.Photos.Photos.Count(p => p.Class == c);
Assert.Equal((5, 2, 2, 1), (Count(PhotoClass.Same), Count(PhotoClass.OnlyHere), Count(PhotoClass.OnlyThere), Count(PhotoClass.Differs)));
Assert.True(review.Photos.Photos.Where(p => p.Class == PhotoClass.OnlyThere).Select(p => p.There!.Sha256).ToHashSet().SetEquals([Sha(photos[6]), Sha(photos[7])]));
Assert.True(review.Photos.Photos.Where(p => p.Class == PhotoClass.OnlyHere).Select(p => p.Here!.Sha256).ToHashSet().SetEquals(extras.Select(Sha)));
var differs = review.Photos.Photos.Single(p => p.Class == PhotoClass.Differs);
Assert.Equal((Sha(differing), Sha(photos[2])), (differs.Here!.Sha256, differs.There!.Sha256));
Assert.Contains(review.Details, d => d.Path == "sequence.title" && d.Here == "Old disk comet" && d.There == onServer.Title);
Assert.Contains(review.Details, d => d.Path == "sequence.rating" && d.Here == "2" && d.There == onServer.Rating.ToString(System.Globalization.CultureInfo.InvariantCulture));
// 5. Keep apart is remembered across refreshes; Ask again brings it back.
await pc.Copies.KeepApartAsync(pair.Id, Ct);
for (var i = 0; i < 2; i++)
{
await pc.Sync.Finder.ResetProbesAsync(pc.Server, Ct);
await pc.Sync.RefreshAsync(pc.Remote, Policy, Ct);
}
Assert.Equal(CopyState.KeptApart, (await pc.Sync.Copies.GetAsync(pair.Id, Ct))!.State);
Assert.Null(await pc.Sync.LinkOfAsync(pc.Server, old.Id, Ct));
await pc.Copies.AskAgainAsync(pair.Id, Ct);
// 6. A project other than Main on each side, under one name, each edited its own way.
await ProjectAsync(new ArchiveProjectHome(pc.Db, pc.Archives.Projects, old.Id), "Vertical", 41);
await ProjectAsync(pc.ServerHome(remoteId), "Vertical", 33);
// 7. Integrate with Union: the server's title, this PC's rating, the rest the server's; the projects copied across.
review = await pc.Copies.CompareAsync(pair.Id, pc.Remote, Ct);
var details = review.Details.Select(d => d.Path).Distinct()
.ToDictionary(p => p, p => p == "sequence.rating" ? CopySide.ThisPc : CopySide.Other);
var plan = await pc.Copies.PlanIntegrateAsync(pair.Id, pc.Remote,
new IntegrateChoices(CopyPhotoPolicy.Union, new Dictionary<string, PhotoChoice>(), details, CopyProjects.CopyAcross), Ct);
Assert.True(plan.CanApply, string.Join(", ", plan.Blocks));
Assert.Equal((0, true, false), (plan.LeftOut, plan.AutoPhotos, plan.Destructive));
Assert.SequenceEqual(["Other:Vertical (Test server)", "ThisPc:Vertical (STUDIO)"],
plan.Projects.Select(p => $"{p.From}:{p.TargetName}").Order(StringComparer.Ordinal));
await pc.WaitAsync((await pc.Copies.EnqueueIntegrateAsync(pc.Jobs, plan, Ct)).Id);
var union = photos.Select(Sha).Concat(extras.Select(Sha)).Append(Sha(differing)).ToHashSet(StringComparer.Ordinal);
Assert.True((await LocalHashesAsync(pc, old.Id)).SetEquals(union), "this PC holds every photo of both, both versions of photo 3");
Assert.True((await server.Database.Frames.ListBySequenceAsync(remoteId)).Select(f => f.Sha256!).ToHashSet().SetEquals(union), "and so does the server");
var here = (await pc.Db.Sequences.GetAsync(old.Id, Ct))!;
var there = (await server.Database.Sequences.GetAsync(remoteId))!;
Assert.Equal((onServer.Title, 2), (here.Title, here.Rating));
Assert.Equal((onServer.Title, 2), (there.Title, there.Rating));
static List<string> Names(IEnumerable<SequenceProject> list) => [.. list.Where(p => !p.IsMain).Select(p => p.Name).Order(StringComparer.Ordinal)];
Assert.SequenceEqual(["Vertical", "Vertical (Test server)"], Names(await pc.Archives.Projects.ListAsync(old.Id, Ct)));
Assert.SequenceEqual(["Vertical", "Vertical (STUDIO)"], Names(await pc.ServerHome(remoteId).ListAsync(Ct)));
var integrated = (await pc.Sync.Copies.GetAsync(pair.Id, Ct))!;
Assert.Equal((CopyState.Integrated, true), (integrated.State, integrated.AutoPhotos));
Assert.Equal(remoteId, (await pc.Sync.LinkOfAsync(pc.Server, old.Id, Ct))?.RemoteId);
await ServerIdleAsync(server);
// 8. A new photo on this PC moves to the server by itself, but not while the connection is metered.
var later = Jpeg(Start.AddSeconds(200), 301);
await pc.AddPhotoAsync(disk, old.Id, later, Start.AddSeconds(200));
var held = await pc.StopJobsAsync();
await using (var agent = new SyncAgent(pc.Sync, pc.Remote, () => Policy, held, new SyncAgentOptions
{
RefreshInterval = TimeSpan.FromHours(1),
EventDelay = TimeSpan.FromMilliseconds(20),
MinBackoff = TimeSpan.FromMilliseconds(20),
MaxBackoff = TimeSpan.FromMilliseconds(200),
}))
{
await agent.RefreshAsync(Ct);
var automatic = (await pc.Db.Jobs.ListAsync(JobState.Queued, JobKind.UploadCommit, 10, cancellationToken: Ct)).Items.Single();
Assert.Equal((old.Id, JobPriority.Background), (automatic.TargetIds.Single(), automatic.Priority));
// Metered: the hold pauses the transfers with the server (UploadHold, the desktop's, does this on Windows).
await held.PauseAsync(automatic.Id, Ct);
await held.StartAsync(Ct);
await Task.Delay(TimeSpan.FromSeconds(1), Ct);
Assert.Equal(JobState.Paused, (await pc.Db.Jobs.GetAsync(automatic.Id, Ct))!.State);
Assert.DoesNotContain(Sha(later), (await server.Database.Frames.ListBySequenceAsync(remoteId)).Select(f => f.Sha256));
// No longer metered: it goes on.
await held.ResumeAsync(automatic.Id, Ct);
await pc.WaitAsync(automatic.Id);
Assert.Contains(Sha(later), (await server.Database.Frames.ListBySequenceAsync(remoteId)).Select(f => f.Sha256));
}
// 9. Upload all local: a copy filed again from the card is a suspected duplicate, skipped and flagged; the rest goes.
var card = await pc.LocalAsync(pc.Main, "Comet from the card", [(photos[0], Start.AddSeconds(10)), (photos[1], Start.AddSeconds(20)),
(Jpeg(Start.AddSeconds(210), 401), Start.AddSeconds(210))]);
var other = await pc.LocalAsync(pc.Main, "Harbour", [(Jpeg(Start.AddDays(1), 501), Start.AddDays(1)), (Jpeg(Start.AddDays(1).AddSeconds(10), 502), Start.AddDays(1).AddSeconds(10))]);
await pc.Copies.FindAsync(pc.Remote, Ct);
var local = Assert.Contains(await pc.Copies.ListAsync(Ct), v => v.Copy.Kind == CopyKind.LocalLocal).Copy;
Assert.True(new[] { local.LocalId, local.OtherId!.Value }.ToHashSet().SetEquals([old.Id, card.Id]));
Assert.Equal(CopyState.Candidate, local.State);
var entries = (await pc.Sync.ListAsync(pc.Server, Ct)).Where(e => e.Status == SyncStatus.LocalOnly);
var (upload, skipped) = UploadAllRule.Select(entries, await pc.Copies.ListAllPairsAsync(Ct), new HashSet<Guid>(), new HashSet<Guid>());
Assert.Equal((card.Id, UploadSkip.SuspectedCopy), (skipped.Single().Entry.Local!.Id, skipped.Single().Why));
Assert.Equal(other.Id, upload.Single().Local!.Id);
await pc.WaitAsync((await pc.Sync.EnqueueUploadAsync(held, pc.Server, upload.Single().Local!, Ct)).Id);
Assert.NotNull(await pc.Sync.LinkOfAsync(pc.Server, other.Id, Ct));
Assert.Null(await pc.Sync.LinkOfAsync(pc.Server, card.Id, Ct));
// 10. The two copies on this PC merge into the linked one; the other goes to the archive trash once every photo is verified there.
review = await pc.Copies.CompareAsync(local.Id, null, Ct);
var merge = await pc.Copies.PlanMergeAsync(local.Id, old.Id,
new MergeChoices(CopyPhotoPolicy.Union, new Dictionary<string, PhotoChoice>(), review.Details.Select(d => d.Path).Distinct().ToDictionary(p => p, _ => CopySide.ThisPc)), Ct);
Assert.True(merge.CanApply, string.Join(", ", merge.Blocks));
Assert.Equal((old.Id, card.Id), (merge.KeepId, merge.DropId));
await pc.WaitAsync((await pc.Copies.EnqueueMergeAsync(held, merge, Ct)).Id);
Assert.Null(await pc.Db.Sequences.GetAsync(card.Id, Ct));
var kept = await pc.Db.Frames.ListBySequenceAsync(old.Id, cancellationToken: Ct);
Assert.Contains(Sha(Jpeg(Start.AddSeconds(210), 401)), kept.Select(f => f.Sha256));
foreach (var frame in kept) Assert.Equal(frame.Sha256, Sha(await File.ReadAllBytesAsync(Path.Combine(disk.RootPath, frame.RelativePath), Ct)));
Assert.Contains(await pc.Archives.ListTrashAsync(pc.Main.Id, Ct), t => t.SequenceId == card.Id);
Assert.Equal(remoteId, (await pc.Sync.LinkOfAsync(pc.Server, old.Id, Ct))?.RemoteId);
}
private static readonly SyncPolicy Policy = new(Linking: CopyLinking.AskAlways);
private static string Sha(byte[] bytes) => Convert.ToHexStringLower(SHA256.HashData(bytes));
/// <summary>A project named <paramref name="name"/> at <paramref name="home"/> with one version of its own (a deflicker window).</summary>
private async Task ProjectAsync(IProjectHome home, string name, int window)
{
var project = await home.CreateAsync(name, null, "alberto", Ct);
var head = await home.HeadAsync(project.Id, Ct);
var portable = ProjectContent.ToPortable(ProjectSettings.FromJson("""{"exposure":{"deflickerWindow":{"isAuto":false,"manual":""" + window + "}}}"), new FramePhotos([]));
var pushed = await home.PushAsync(project.Id, new ProjectVersion
{
Id = Guid.CreateVersion7(),
ProjectId = project.Id,
ParentId = head.Id,
Number = head.Number + 1,
Kind = ProjectVersionKind.Commit,
Author = "alberto",
ClientName = PcName,
SettingsJson = portable,
ContentHash = ProjectContent.Hash(portable),
FramesVersion = head.FramesVersion,
CreatedAt = DateTimeOffset.UtcNow,
}, Ct);
Assert.NotNull(pushed.Version);
}
/// <summary>A small real JPEG with Exif (camera and capture time); each seed gives distinct bytes.</summary>
private static byte[] Jpeg(DateTime captured, int seed)
{
using var image = new ImageBuffer(48, 32);
var random = new Random(seed);
for (var c = 0; c < 3; c++)
{
var plane = image.Plane(c);
var level = (float)random.NextDouble();
for (var i = 0; i < plane.Length; i++) plane[i] = level * (0.5f + 0.5f * (i % 48) / 48f);
}
var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { Make = "Canon", Model = "Canon EOS R5", BodySerial = "0431", CapturedAt = captured, Iso = 100 });
return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] });
}
private static async Task<HashSet<string>> LocalHashesAsync(Pc pc, Guid id) =>
(await pc.Db.Frames.ListBySequenceAsync(id, cancellationToken: pc.Ct)).Select(f => f.Sha256!).ToHashSet(StringComparer.Ordinal);
private Task ServerIdleAsync(TestServer server) =>
UntilAsync(async () => await server.Database.Jobs.CountAsync(DateTimeOffset.UtcNow) is { Queued: 0, Running: 0 }, "the server's jobs");
private async Task UntilAsync(Func<Task<bool>> condition, string what)
{
var until = DateTime.UtcNow + Deadline;
while (!await condition())
{
if (DateTime.UtcNow > until) Assert.Fail("Timed out waiting for " + what);
await Task.Delay(50, Ct);
}
}
/// <summary>
/// This PC as the desktop composes it (AppServices): its index and archive, the sync engine, the matches engine with its
/// planners and the server's project homes, and a job engine with the archive, sync, Integrate and Merge handlers.
/// </summary>
private sealed class Pc : IAsyncDisposable
{
private readonly TestContext _context;
private readonly ChronosClient _client;
private readonly Connector _connector;
private Pc(TestContext context, ChronosDatabase db, ArchiveService archives, Archive main, SyncService sync, ChronosClient client)
{
_context = context;
Db = db;
Archives = archives;
Main = main;
Sync = sync;
_client = client;
Remote = new ChronosSyncRemote(client, ownsClient: false);
_connector = new Connector(client);
var sides = new CopySides(db);
var homes = CopyJobs.ServerHomes(_connector);
Copies = new CopyEngine(sync, archives, new IntegratePlanner(sync, sides, archives.Projects, homes), new SequenceMerger(db, archives, sides),
new CopyReviewBuilder(db, archives.Projects, sides, homes), remote => new CopyPlanContext(PcName, remote is null ? null : ServerName,
true, true, true, false, false, remote is not null, null, new HashSet<Guid>(), new HashSet<Guid>()),
serverNames: _ => ServerName);
Jobs = NewJobs();
}
public ChronosDatabase Db { get; }
public ArchiveService Archives { get; }
public Archive Main { get; }
public SyncService Sync { get; }
public ChronosSyncRemote Remote { get; }
public CopyEngine Copies { get; }
public JobEngine Jobs { get; private set; }
public string Server => Remote.Server;
public CancellationToken Ct => _context.Cancellation;
public static async Task<Pc> StartAsync(TestContext context, TestServer server, string token)
{
var ct = context.Cancellation;
var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory("studio-db"), "chronos.db")), ct);
var options = new ArchiveServiceOptions { Owner = PcName, LeaseWait = TimeSpan.FromSeconds(20) };
var archives = new ArchiveService(db, options);
var main = await archives.CreateAsync(context.CreateTempDirectory("studio-archive"), "Main", cancellationToken: ct);
var sync = new SyncService(db, archives, new SyncOptions { Archive = options, ProxyCacheDirectory = context.CreateTempDirectory("studio-proxies") });
var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), PcName) { Token = token };
var pc = new Pc(context, db, archives, main, sync, client);
await pc.Jobs.StartAsync(ct);
return pc;
}
/// <summary>A job engine over this index with every handler the desktop registers for these jobs (not started).</summary>
public JobEngine NewJobs() => new(Db,
[
.. Archives.CreateJobHandlers(), .. Sync.CreateJobHandlers(_connector),
CopyJobs.CreateIntegrateHandler(Sync, Archives, _connector, Sync.Copies),
SequenceMerger.CreateHandler(Db, new SequenceMerger(Db, Archives, new CopySides(Db)), Archives, new ProjectTransplant(), new NoWorkspace()),
],
new JobEngineOptions { Workers = 2, WorkerId = PcName, PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
/// <summary>Stops the engine that runs jobs as they come and puts one not started in its place: the next jobs wait for it.</summary>
public async Task<JobEngine> StopJobsAsync()
{
await Jobs.DisposeAsync();
return Jobs = NewJobs();
}
public IProjectHome ServerHome(Guid remoteId) => new ServerProjectHome(_client, remoteId, ServerName, null, Server);
/// <summary>A local sequence filed photo by photo through the archive ingest.</summary>
public async Task<Sequence> LocalAsync(Archive archive, string title, IReadOnlyList<(byte[] Bytes, DateTime Captured)> photos)
{
Guid? id = null;
for (var i = 0; i < photos.Count; i++)
{
var result = await IngestAsync(archive, id, id is null ? title : null, photos[i].Bytes, $"IMG_{photos[i].Captured:HHmmss}.JPG", photos[i].Captured);
id = result.SequenceId;
}
return (await Db.Sequences.GetAsync(id!.Value, Ct))!;
}
public Task<IngestResult> AddPhotoAsync(Archive archive, Guid sequenceId, byte[] photo, DateTime captured) =>
IngestAsync(archive, sequenceId, null, photo, $"IMG_{captured:HHmmss}.JPG", captured);
private async Task<IngestResult> IngestAsync(Archive archive, Guid? sequenceId, string? title, byte[] photo, string name, DateTime captured)
{
var staging = Path.Combine(archive.RootPath, ".chronos", "staging", "test");
Directory.CreateDirectory(staging);
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.part");
await File.WriteAllBytesAsync(path, photo, Ct);
return await Archives.Ingest.CommitAsync(new IngestRequest(archive.Id, sequenceId, title, null, path, name, photo.Length, Sha(photo), captured, null), Ct);
}
public async Task<Job> WaitAsync(Guid jobId)
{
var until = DateTime.UtcNow.AddSeconds(TestTiming.Budget(60));
while (true)
{
var job = await Db.Jobs.GetAsync(jobId, Ct);
if (job?.State == JobState.Done) return job;
if (job?.State is JobState.Failed or JobState.Cancelled) Assert.Fail($"Job {job.Kind} {job.State}: {job.Error}\n{job.LogTail}");
if (DateTime.UtcNow > until) Assert.Fail($"Job {jobId} did not finish (now {job?.State})");
await Task.Delay(25, Ct);
}
}
public async ValueTask DisposeAsync()
{
await Jobs.DisposeAsync();
Copies.Dispose();
Remote.Dispose();
_client.Dispose();
await Db.DisposeAsync();
}
/// <summary>No workspace here: no sequence has workspace work not sent home.</summary>
private sealed class NoWorkspace : IWorkspaceGuard
{
public Task<bool> HasUnsentAsync(Guid sequenceId, CancellationToken ct) => Task.FromResult(false);
}
/// <summary>The signed-in session: a remote per job and the server's project homes (Settings › Server's server keeps projects).</summary>
private sealed class Connector(ChronosClient client) : ISyncConnector
{
public ValueTask<ISyncRemote?> ConnectAsync(string server, CancellationToken cancellationToken)
{
ISyncRemote remote = new ChronosSyncRemote(client, ownsClient: false);
return ValueTask.FromResult<ISyncRemote?>(remote.Server == server ? remote : null);
}
public IProjectHome? ProjectHome(BundleHome home) =>
home.IsArchive ? null : new ServerProjectHome(client, home.SequenceId, ServerName, null, home.Server);
}
}
}