using System.Net; using System.Security.Cryptography; using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data; using Chronos.Data.Archiving; using Chronos.Data.Jobs; using Chronos.Data.Projects; using Chronos.Data.Sync; using Chronos.Data.Workspaces; using Chronos.Protocol; using Chronos.Protocol.Client; using Chronos.Server.Storage; using Chronos.Testing; namespace Chronos.Server.Tests.Workspaces; /// /// A render made in a workspace and sent to its server (phase 5c): the server checks the project and version it names /// against the sequence (422 project_mismatch) and records them with the render; one naming neither is filed as /// before. The desktop's uploads it with them, and waits while a metered connection holds /// transfers with the server. /// [Category("server")] [Category("workspace")] public sealed class WorkspaceSendServerTests(TestContext context) { private const string Title = "Rooftop"; private static readonly TimeSpan Wait = TimeSpan.FromSeconds(TestTiming.Budget(60)); [Test] public async Task TheServerFilesAWorkspaceRenderWithItsProjectAndVersion() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (http, _, token) = await server.UserAsync("alberto", "editor"); var sid = (await Uploads.UploadAsync(http, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId; using var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), "PC-A") { Token = token }; var home = new ServerProjectHome(client, sid, "Test server"); var main = (await home.ListAsync(context.Cancellation)).Single(); var head = await home.HeadAsync(main.Id, context.Cancellation); var (path, request) = Output(1); var dto = Assert.NotNull(await client.UploadRenderAsync(sid, path, request with { ProjectId = main.Id, ProjectVersionId = head.Id }, ct: context.Cancellation)); Assert.Equal(((Guid?)main.Id, (Guid?)head.Id), (dto.ProjectId, dto.ProjectVersionId)); var row = Assert.NotNull(await server.Database.Renders.GetAsync(request.RenderId)); Assert.Equal((sid, (Guid?)main.Id, (Guid?)head.Id), (row.SequenceId, row.ProjectId, row.ProjectVersionId)); Assert.Contains((await client.GetManifestAsync(sid, context.Cancellation)).Renders, r => r.Id == request.RenderId && r.ProjectVersionId == head.Id); // A version alone names its project. var (alone, versionOnly) = Output(2); var named = Assert.NotNull(await client.UploadRenderAsync(sid, alone, versionOnly with { ProjectVersionId = head.Id }, ct: context.Cancellation)); Assert.Equal(((Guid?)main.Id, (Guid?)head.Id), (named.ProjectId, named.ProjectVersionId)); // Sent again: the server holds it already, and nothing is filed twice. Assert.Null(await client.UploadRenderAsync(sid, path, request with { ProjectId = main.Id, ProjectVersionId = head.Id }, ct: context.Cancellation)); Assert.Equal(2, (await server.Database.Renders.ListBySequenceAsync(sid)).Count); // Without them, as from an earlier client: filed naming neither. var (plain, earlier) = Output(3); var before = Assert.NotNull(await client.UploadRenderAsync(sid, plain, earlier, ct: context.Cancellation)); Assert.Equal(((Guid?)null, (Guid?)null), (before.ProjectId, before.ProjectVersionId)); Assert.Null((await server.Database.Renders.GetAsync(earlier.RenderId))!.ProjectVersionId); } [Test] public async Task AProjectOrVersionOfAnotherSequenceIsRefused() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (http, _, token) = await server.UserAsync("alberto", "editor"); var sid = (await Uploads.UploadAsync(http, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId; var other = (await Uploads.UploadAsync(http, Photo(2), "IMG_0002.JPG", sessionKey: "lake", capturedAt: new DateTime(2026, 10, 3, 9, 0, 0))).SequenceId; Assert.NotEqual(sid, other); using var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), "PC-A") { Token = token }; var main = (await new ServerProjectHome(client, sid).ListAsync(context.Cancellation)).Single(); var foreignHome = new ServerProjectHome(client, other); var foreign = (await foreignHome.ListAsync(context.Cancellation)).Single(); var foreignHead = await foreignHome.HeadAsync(foreign.Id, context.Cancellation); var (path, request) = Output(4); foreach (var named in new[] { request with { ProjectId = main.Id, ProjectVersionId = foreignHead.Id }, request with { ProjectId = foreign.Id }, request with { ProjectVersionId = foreignHead.Id }, request with { ProjectId = Guid.CreateVersion7() }, }) { var refused = await Assert.ThrowsAsync(() => client.UploadRenderAsync(sid, path, named, ct: context.Cancellation)); Assert.Equal((HttpStatusCode.UnprocessableEntity, "project_mismatch"), (refused.Status, refused.Error.Code)); } Assert.Null(await server.Database.Renders.GetAsync(request.RenderId)); } [Test] public async Task TheSendUploadsTheRenderWithItsVersionOnceTheConnectionIsNoLongerMetered() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (http, _, token) = await server.UserAsync("alberto", "editor"); var sid = (await Uploads.UploadAsync(http, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId; using var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), "PC-A") { Token = token }; var serverKey = SyncService.ServerKey(client.BaseAddress); await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory("pc-db"), "chronos.db")), context.Cancellation); var archives = new ArchiveService(db, new ArchiveServiceOptions { Owner = "PC-A" }); var metered = true; var options = WorkspaceJobOptions.For(archives) with { HoldTransfers = () => Volatile.Read(ref metered) }; await using var engine = new JobEngine(db, WorkspaceJobs.CreateHandlers(db, archives, new Connector(client), options), new JobEngineOptions { Workers = 1, WorkerId = "PC-A", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }); await engine.StartAsync(context.Cancellation); var store = new WorkspaceStore(Path.Combine(context.CreateTempDirectory("pc-ws"), "workspace")); var sync = new WorkspaceSync(store, "Chronos on PC-A") { LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)) }; var home = new ServerProjectHome(client, sid, "Test server"); var main = (await home.ListAsync(context.Cancellation)).Single(); var project = await sync.CheckoutAsync(home, main.Id, cancellationToken: context.Cancellation); var head = project.ReadBundle().Workspace!.Base!.VersionId; Directory.CreateDirectory(project.ExportsDirectory); var bytes = RandomNumberGenerator.GetBytes(120_000); File.WriteAllBytes(Path.Combine(project.ExportsDirectory, "Roof 1080p.mp4"), bytes); var entry = new WorkspaceRenderEntry(Guid.CreateVersion7(), Guid.CreateVersion7(), "Roof 1080p.mp4", Convert.ToHexStringLower(SHA256.HashData(bytes)), bytes.Length, "1080p H.264", "h264", 1920, 1080, 24, 2.5, main.Id, head, null, DateTimeOffset.UtcNow); project.WriteRenders(WorkspaceRenders.Empty.With(entry)); // Held while the connection is metered: nothing goes out. var job = await engine.EnqueueAsync(WorkspaceJobs.Send(sid, Title, store.Root, main.Id, [entry.RenderId], serverKey), cancellationToken: context.Cancellation); await Task.Delay(TimeSpan.FromSeconds(1), context.Cancellation); Assert.Equal(JobState.Running, (await db.Jobs.GetAsync(job.Id, context.Cancellation))!.State); Assert.Null(await server.Database.Renders.GetAsync(entry.RenderId)); Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsUnsent); Volatile.Write(ref metered, false); var done = await WaitAsync(db, job.Id, JobState.Done); Assert.Contains(Loc.L("Archive.Log.WorkspaceSendHeld"), done.LogTail!); Assert.Contains(Loc.L("Archive.Log.WorkspaceSent", main.Name, 1, 0), done.LogTail!); var row = Assert.NotNull(await server.Database.Renders.GetAsync(entry.RenderId)); Assert.Equal((sid, (Guid?)main.Id, (Guid?)head, entry.Size), (row.SequenceId, row.ProjectId, row.ProjectVersionId, row.Bytes)); Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsSent); Assert.FileExists(project.ExportFile(entry.File)); // This PC's library is never written: the server is the home. Assert.Empty(await db.Renders.ListBySequenceAsync(sid, context.Cancellation)); } /// A render's file on this PC and the offer of it, naming no project. private (string Path, RenderUploadRequest Request) Output(int seed) { var data = Uploads.Photo(4000 + seed, seed); var path = System.IO.Path.Combine(context.CreateTempDirectory("render"), $"Roof {seed}.mp4"); File.WriteAllBytes(path, data); return (path, new RenderUploadRequest(Guid.CreateVersion7(), System.IO.Path.GetFileName(path), data.Length, Uploads.Sha(data), "1080p H.264", "h264", 1920, 1080, 24, 2.5, "PC-A")); } private static async Task WaitAsync(ChronosDatabase db, Guid jobId, JobState state) { var until = DateTime.UtcNow + Wait; while (true) { var job = await db.Jobs.GetAsync(jobId); if (job?.State == state) return job; if (job?.State is JobState.Failed or JobState.Done or JobState.Cancelled) Assert.Fail($"Job ended {job.State}: {job.Error}\n{job.LogTail}"); if (DateTime.UtcNow > until) Assert.Fail($"Job {jobId} did not reach {state} (now {job?.State})"); await Task.Delay(25); } } private static byte[] Photo(int seed) { const int width = 96, height = 64; var pixels = new byte[width * height * 3]; for (var i = 0; i < pixels.Length; i++) pixels[i] = (byte)((i * 7 + seed * 31) % 251); return JpegEncoder.Encode(pixels, width, height, 3, new JpegEncodeOptions { Quality = 90 }); } /// The desktop's session with the test server: a remote and the project home over the signed-in client. private sealed class Connector(ChronosClient client) : ISyncConnector { public ValueTask ConnectAsync(string server, CancellationToken cancellationToken) { ISyncRemote remote = new ChronosSyncRemote(client, ownsClient: false); return ValueTask.FromResult(remote.Server == server ? remote : null); } public IProjectHome? ProjectHome(BundleHome home) => new ServerProjectHome(client, home.SequenceId, "Test server"); } }