From 00b8dcd24966cf811f1e12e69aa57c0eba9b7e9e Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Wed, 4 Nov 2026 15:32:49 +0100 Subject: [PATCH] feat(workspace): send local renders home with their project and version Phase 5c P3. A render made in a workspace must reach its home with the project and version it was rendered from, and transfers with a server must respect a metered connection, downloads into the workspace included. - WorkspaceSendJobHandler: per unsent ledger entry, hash the file again (missing or changed: marked failed, file left in place), push the named version first when the home lacks it (failure fails the job, entry pending), then file it in this PC's archive (staged copy read back against its SHA-256, project and version checked against the sequence) or upload it to the server with ProjectId/ProjectVersionId; mark it sent. Idempotent by render id. A send to a server waits while HoldTransfers says so. - SyncTransfers: extract FileRenderAsync, the lease-held filing of a staged render into a sequence's exports, shared by GetExportsAsync and the send. - ISyncConnector.ProjectHome (default null; SyncHost already implements it) so the send can push a version to a server home. - Server: RenderUploads checks the project fields at start and completion (422 project_mismatch) and records them; RenderDto carries them. - UploadHold also pauses WorkspaceCopy and WorkspaceSend jobs naming a server; Server screen checkbox reads "Pause metered transfers". Co-Authored-By: Claude Opus 5.5 --- src/Chronos.App/Infrastructure/AppSettings.cs | 2 +- src/Chronos.App/Sections/ServerView.xaml | 2 +- src/Chronos.App/Server/UploadHold.cs | 43 ++- src/Chronos.Data/Sync/SyncRemote.cs | 7 + src/Chronos.Data/Sync/SyncTransfers.cs | 76 +++-- .../Workspaces/WorkspaceSendJobHandler.cs | 292 +++++++++++++++++- src/Chronos.Protocol/Sequences.cs | 11 +- src/Chronos.Server/Api/Dto.cs | 3 +- src/Chronos.Server/Storage/RenderUploads.cs | 42 ++- .../Server/UploadHoldTests.cs | 62 ++++ .../Workspaces/WorkspaceSendTests.cs | 221 +++++++++++++ .../Workspaces/WorkspaceSendServerTests.cs | 186 +++++++++++ 12 files changed, 894 insertions(+), 53 deletions(-) create mode 100644 tests/Chronos.App.Tests/Server/UploadHoldTests.cs create mode 100644 tests/Chronos.Data.Tests/Workspaces/WorkspaceSendTests.cs create mode 100644 tests/Chronos.Server.Tests/Workspaces/WorkspaceSendServerTests.cs diff --git a/src/Chronos.App/Infrastructure/AppSettings.cs b/src/Chronos.App/Infrastructure/AppSettings.cs index a2e2e6ac..3780f173 100644 --- a/src/Chronos.App/Infrastructure/AppSettings.cs +++ b/src/Chronos.App/Infrastructure/AppSettings.cs @@ -236,7 +236,7 @@ public sealed class AppSettings /// Send and take project settings changed on one side without asking (Server.html). public bool SyncSettingsAutomatically { get; set; } = true; - /// Pause upload jobs while Windows reports the connection as metered (Server.html). + /// Pause transfers with a server (uploads, workspace copies and renders sent) while Windows reports the connection as metered (Server.html). public bool PauseUploadsOnMetered { get; set; } // ---- Jobs ---- diff --git a/src/Chronos.App/Sections/ServerView.xaml b/src/Chronos.App/Sections/ServerView.xaml index 8fc9283e..3e039e1c 100644 --- a/src/Chronos.App/Sections/ServerView.xaml +++ b/src/Chronos.App/Sections/ServerView.xaml @@ -160,7 +160,7 @@ - + diff --git a/src/Chronos.App/Server/UploadHold.cs b/src/Chronos.App/Server/UploadHold.cs index 5cee850c..8bfd77ed 100644 --- a/src/Chronos.App/Server/UploadHold.cs +++ b/src/Chronos.App/Server/UploadHold.cs @@ -4,14 +4,17 @@ using Chronos.App.Infrastructure; using Chronos.Core.Diagnostics; using Chronos.Core.Model; using Chronos.Data.Jobs; +using Chronos.Data.Workspaces; namespace Chronos.App.Server; /// -/// "Pause uploads on metered networks" (Server.html): while is on and -/// Windows reports the connection as metered, upload jobs are paused (a running one stops after its current chunk and -/// keeps its checkpoint); they are resumed when the connection is no longer metered or the option goes off. Only the -/// uploads it paused are resumed. Checked when the network or an upload job changes, and every minute. +/// "Pause metered transfers" (Server.html): while is on and Windows reports +/// the connection as metered, the transfers with a server are paused (a running one stops after its current chunk or file +/// and keeps its checkpoint): upload jobs, and since phase 5c the workspace's copies from a server and its renders sent to +/// one (); a copy from or a send to this PC's archive is never held. They are resumed when the connection +/// is no longer metered or the option goes off. Only the jobs it paused are resumed. Checked when the network or one of +/// those jobs changes, and every minute. /// public sealed class UploadHold : IDisposable { @@ -58,7 +61,26 @@ public sealed class UploadHold : IDisposable private void OnJobChanged(Job job) { - if (job is { Kind: JobKind.UploadCommit, State: JobState.Queued or JobState.Running }) Request(); + if (job is { State: JobState.Queued or JobState.Running } && Holds(job)) Request(); + } + + /// The kinds of job a metered connection may hold ( says which of them). + internal static IReadOnlyList Kinds { get; } = [JobKind.UploadCommit, JobKind.WorkspaceCopy, JobKind.WorkspaceSend]; + + /// + /// Whether a metered connection holds : an upload, or a workspace copy or send whose home is a server + /// (its parameters name one). One whose parameters cannot be read is not held: it fails with its reason. + /// + internal static bool Holds(Job job) + { + ArgumentNullException.ThrowIfNull(job); + return job.Kind switch + { + JobKind.UploadCommit => true, + JobKind.WorkspaceCopy => WorkspaceJobs.CopyParameters(job)?.Server is { Length: > 0 }, + JobKind.WorkspaceSend => WorkspaceJobs.SendParameters(job)?.Server is { Length: > 0 }, + _ => false, + }; } private async Task ApplyAsync() @@ -71,10 +93,13 @@ public sealed class UploadHold : IDisposable { foreach (var state in new[] { JobState.Queued, JobState.Running }) { - foreach (var job in (await db.Jobs.ListAsync(state, JobKind.UploadCommit, 500)).Items) + foreach (var kind in Kinds) { - await engine.PauseAsync(job.Id); - _held.Add(job.Id); + foreach (var job in (await db.Jobs.ListAsync(state, kind, 500)).Items.Where(Holds)) + { + await engine.PauseAsync(job.Id); + _held.Add(job.Id); + } } } return; @@ -87,7 +112,7 @@ public sealed class UploadHold : IDisposable } catch (Data.DatabaseException ex) { - Log.Warning("sync", "Uploads could not be paused or resumed for the metered connection", ex); + Log.Warning("sync", "Transfers could not be paused or resumed for the metered connection", ex); } finally { diff --git a/src/Chronos.Data/Sync/SyncRemote.cs b/src/Chronos.Data/Sync/SyncRemote.cs index ef1c01a2..3ef8b7cb 100644 --- a/src/Chronos.Data/Sync/SyncRemote.cs +++ b/src/Chronos.Data/Sync/SyncRemote.cs @@ -92,6 +92,13 @@ public interface ISyncConnector { /// A signed-in remote of owned by the caller; null when this PC is not connected to that server. ValueTask ConnectAsync(string server, CancellationToken cancellationToken); + + /// + /// The project home of a workspace project whose home is (a server's sequence) over the same + /// signed-in session: where a send of its renders pushes the version they name first (phase 5c). Null when this PC is not + /// connected to that server, or the connection keeps no projects. + /// + Projects.IProjectHome? ProjectHome(Core.Project.BundleHome home) => null; } /// over a signed-in , which it disposes when it owns it. diff --git a/src/Chronos.Data/Sync/SyncTransfers.cs b/src/Chronos.Data/Sync/SyncTransfers.cs index a8a816f6..117ad8ce 100644 --- a/src/Chronos.Data/Sync/SyncTransfers.cs +++ b/src/Chronos.Data/Sync/SyncTransfers.cs @@ -500,44 +500,58 @@ internal sealed class SyncTransfers(SyncService sync) foreach (var render in wanted) { var (part, name) = await FetchRenderAsync(remote, render, staging, ct).ConfigureAwait(false); - // Filed under the sequence's lease into its folder as the index has it then, as a server files a render: a - // Reorganize may have moved it since the sequence was read, and moves the row's path along when it moves it later. - // One another index moved is found by this index's next scan; until then nothing is filed (the download stays - // staged for the next attempt), so the folder it left is not created again, nor filed into when it holds another - // sequence now. - var filed = await sync.Archives.UnderLeaseAsync(local, async row => + var filed = await FileRenderAsync(sync.Archives, db, local, paths, part, name, new Render { - if (row is null) throw new InvalidOperationException(Loc.L("Errors.Sync.LocalMissing")); - var folder = paths.Sequence(row.Folder); - if (!SequenceFolders.Holds(folder, row.Id)) return false; - Directory.CreateDirectory(folder.Exports); - var target = Unique(folder.Exports, name); - File.Move(part, target); - // Recorded even if the job is being cancelled: a filed export is never left without its row. - await db.Renders.InsertAsync(new Render - { - Id = render.Id, - SequenceId = row.Id, - PresetName = render.PresetName, - OutputPath = paths.ToRelative(target), - Codec = render.Codec, - Width = render.Width, - Height = render.Height, - Fps = render.Fps, - DurationSeconds = render.DurationSeconds, - Bytes = new FileInfo(target).Length, - Created = render.Created, - ProducedBy = render.ProducedBy, - }, CancellationToken.None).ConfigureAwait(false); - return true; + Id = render.Id, + SequenceId = local.Id, + PresetName = render.PresetName, + OutputPath = string.Empty, + Codec = render.Codec, + Width = render.Width, + Height = render.Height, + Fps = render.Fps, + DurationSeconds = render.DurationSeconds, + Created = render.Created, + ProducedBy = render.ProducedBy, }, ct).ConfigureAwait(false); - if (!filed) throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved")); + if (filed is null) throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved")); await progress.StepAsync().ConfigureAwait(false); } TryDeleteDirectory(staging); await sync.RecompareAsync(remote, remoteId, ct).ConfigureAwait(false); } + /// + /// Files the render staged at (on the archive's volume) into the exports of + /// under its lease, into its folder as the index has it then, as a server files a render: a + /// Reorganize may have moved it since the sequence was read, and moves the row's path along when it moves it later. The + /// file takes , or "name (2)" and so on (an export is never replaced), and the index records + /// for it, with the sequence, the path and the size it has there (recorded even if the job is + /// being cancelled: a filed export is never left without its row). Used by the sync's downloads of a server's exports and + /// by a workspace's renders sent home (). Returns the archive-relative path + /// it was filed at; null when the folder does not hold the sequence now (another index moved it; this index's next scan + /// finds it): nothing is filed then, the staged file stays for the next attempt, and the folder it left is not created + /// again, nor filed into when it holds another sequence now. + /// + /// The sequence left the index. + /// The archive is offline or read-only. + /// Another writer held the sequence for longer than the lease wait. + internal static Task FileRenderAsync(ArchiveService archives, ChronosDatabase db, Sequence local, ArchivePaths paths, string part, string name, + Render render, CancellationToken cancellationToken) => + archives.UnderLeaseAsync(local, async row => + { + if (row is null) throw new InvalidOperationException(Loc.L("Errors.Sync.LocalMissing")); + var folder = paths.Sequence(row.Folder); + if (!SequenceFolders.Holds(folder, row.Id)) return null; + Directory.CreateDirectory(folder.Exports); + var target = Unique(folder.Exports, name); + File.Move(part, target); + var relative = paths.ToRelative(target); + await db.Renders.InsertAsync(render with { SequenceId = row.Id, OutputPath = relative, Bytes = new FileInfo(target).Length }, CancellationToken.None) + .ConfigureAwait(false); + return (string?)relative; + }, cancellationToken); + /// A render's file in staging (resumed with Range; started over once if the partial copy no longer fits) and the name the server gives it. private static async Task<(string Part, string Name)> FetchRenderAsync(ISyncRemote remote, RenderDto render, string staging, CancellationToken cancellationToken) { @@ -833,7 +847,7 @@ internal sealed class SyncTransfers(SyncService sync) private static Task EnqueueFollowUpAsync(JobContext context, ArchiveJobRequest request, CancellationToken cancellationToken) => context.EnqueueFollowUpAsync(request.Kind, request.Targets, request.Label, request.ParametersJson, request.Priority, cancellationToken); - private static void EnsureSpace(string root, long bytes) + internal static void EnsureSpace(string root, long bytes) { long? free; try diff --git a/src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs index 2434dca6..9b99f99a 100644 --- a/src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs +++ b/src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs @@ -1,25 +1,303 @@ +using System.Net; +using Chronos.Core.Archiving; +using Chronos.Core.Diagnostics; +using Chronos.Core.Localization; using Chronos.Core.Model; +using Chronos.Core.Project; using Chronos.Data.Archiving; using Chronos.Data.Jobs; +using Chronos.Data.Projects; using Chronos.Data.Sync; +using Chronos.Protocol; +using Chronos.Protocol.Client; namespace Chronos.Data.Workspaces; /// /// (phase 5c, ): the local renders of a workspace project -/// sent home with their project and version, per unsent ledger entry: the file hashed again (another is refused and stays), -/// the version it names pushed first when the home lacks it, then filed in this PC's archive (as the sync files a server's -/// exports) or uploaded to its server (RenderUploadRequest with ProjectId and ProjectVersionId), and the -/// entry marked sent. Idempotent by render id: a send repeated after a cut finds the home holding it already. +/// sent home with their project and version, per unsent ledger entry (; the ids the job names, +/// or every unsent one): the file hashed again (one missing or changed since it was rendered is refused, marked failed in the +/// ledger and left where it is), the version it names pushed first when the home lacks it (a push that fails fails the job, +/// the entry left as it was), then filed in this PC's archive (copied into the archive's staging folder, read back against +/// its SHA-256, and filed under the sequence's lease as the sync files a server's exports, +/// , after checking the project and version are the sequence's) or uploaded to its +/// server ( with ProjectId and ProjectVersionId, which the server checks the +/// same way), and the entry marked sent. The file stays in exports/ until a clean-up removes it. +/// Idempotent by render id: a send repeated after a cut finds the home holding the render already and only marks it sent; a +/// render id the home files under another sequence is refused. The ledger is read and written under the project's lease, +/// each entry read again before it is written, so a render finished meanwhile is kept. +/// A send to a server is held while says so (a metered connection): it waits +/// before each upload, and the desktop pauses it meanwhile. A send to this PC's archive is never held. /// internal sealed class WorkspaceSendJobHandler(ChronosDatabase db, ArchiveService archives, ISyncConnector? servers, WorkspaceJobOptions options) : IJobHandler { + private static readonly TimeSpan LockWait = TimeSpan.FromMinutes(2); + + /// How often a send held on a metered connection looks again. + internal static TimeSpan HoldPoll { get; set; } = TimeSpan.FromSeconds(2); + public JobKind Kind => JobKind.WorkspaceSend; - public Task RunAsync(JobContext context) + public async Task RunAsync(JobContext context) { ArgumentNullException.ThrowIfNull(context); - _ = (db, archives, servers, options); - throw new NotImplementedException("Sending a workspace project's renders home comes with phase 5c (P3)."); + var ct = context.Cancellation; + var parameters = WorkspaceJobs.SendParameters(context.Job) ?? throw new InvalidDataException(Loc.L("Errors.Workspace.JobParameters")); + if (context.Job.TargetIds is not [var sequenceId] || string.IsNullOrWhiteSpace(parameters.WorkspaceRoot)) + throw new InvalidDataException(Loc.L("Errors.Workspace.JobParameters")); + var server = parameters.Server is { Length: > 0 } named ? named : null; + var project = new WorkspaceStore(parameters.WorkspaceRoot).Find(parameters.ProjectId) + ?? throw new InvalidOperationException(Loc.L("Errors.Workspace.NotCheckedOut")); + var workspace = project.ReadBundle().Workspace ?? throw new InvalidOperationException(Loc.L("Errors.Workspace.NotCheckedOut")); + var home = workspace.Home; + if (home.SequenceId != sequenceId || (server is null + ? !home.IsArchive + : home.Kind != BundleHome.ServerKind || !string.Equals(home.Server, server, StringComparison.OrdinalIgnoreCase))) + throw new InvalidOperationException(Loc.L("Errors.Workspace.OtherHome")); + + var entries = await ToSendAsync(project, parameters.RenderIds, ct).ConfigureAwait(false); + await context.ReportAsync(0, entries.Count).ConfigureAwait(false); + if (entries.Count == 0) + { + context.Log(Loc.L("Archive.Log.WorkspaceSent", workspace.Name, 0, 0)); + return; + } + if (server is null) + { + var sequence = await db.Sequences.GetAsync(sequenceId, ct).ConfigureAwait(false) + ?? throw new InvalidOperationException(Loc.L("Archive.Log.SequenceMissing", sequenceId)); + var archive = await db.Archives.GetAsync(sequence.ArchiveId, ct).ConfigureAwait(false) + ?? throw new InvalidOperationException(Loc.L("Errors.Sync.NoArchive")); + var projectHome = new ArchiveProjectHome(db, archives.Projects, sequenceId); + await SendAsync(context, project, workspace, entries, () => projectHome, held: false, + (entry, file, token) => FileAsync(sequence, archive, entry, file, token)).ConfigureAwait(false); + return; + } + using var remote = (servers is null ? null : await servers.ConnectAsync(server, ct).ConfigureAwait(false)) + ?? throw new InvalidOperationException(Loc.L("Errors.Sync.NotConnected")); + await SendAsync(context, project, workspace, entries, + () => servers!.ProjectHome(home) ?? throw new InvalidOperationException(Loc.L("Errors.Sync.NotConnected")), held: true, + (entry, file, token) => UploadAsync(remote, sequenceId, entry, file, token)).ConfigureAwait(false); } + + /// + /// The entries to send, oldest first: those of the ledger holds unsent (an id it no longer + /// holds was discarded meanwhile, one sent already is left), every unsent one when none is named. + /// + private static async Task> ToSendAsync(WorkspaceProject project, IReadOnlyList? renderIds, CancellationToken ct) + { + WorkspaceRenders ledger; + using (await project.LockAsync(LockWait, ct).ConfigureAwait(false)) ledger = project.ReadRenders(); + if (renderIds is not { Count: > 0 }) return ledger.Unsent; + var named = renderIds.ToHashSet(); + return [.. ledger.Entries.Where(e => named.Contains(e.RenderId) && e.IsUnsent)]; + } + + /// Delivers one checked render home: true when the home took it now, false when it held it already. + private delegate Task Deliver(WorkspaceRenderEntry entry, string file, CancellationToken cancellationToken); + + private async Task SendAsync(JobContext context, WorkspaceProject project, BundleWorkspace workspace, IReadOnlyList entries, + Func home, bool held, Deliver deliver) + { + var ct = context.Cancellation; + var (sent, there, refused) = (0, 0, 0); + // The versions this run found at the home, or sent there first. + var versions = new HashSet(); + for (var i = 0; i < entries.Count; i++) + { + ct.ThrowIfCancellationRequested(); + if (held) await WhileHeldAsync(context).ConfigureAwait(false); + var entry = entries[i]; + var file = project.ExportFile(entry.File); + var refusal = await CheckAsync(project, entry, file, ct).ConfigureAwait(false); + if (refusal is null) + { + if (entry.ProjectVersionId is { } versionId && !versions.Contains(versionId)) + { + await EnsureVersionAsync(context, project, workspace, home(), entry.ProjectId, versionId, ct).ConfigureAwait(false); + versions.Add(versionId); + } + try + { + if (await deliver(entry, file, ct).ConfigureAwait(false)) sent++; + else there++; + // The home holds it: recorded whatever stops the job now. + await UpdateAsync(project, entry.RenderId, e => e.AsSent(DateTimeOffset.UtcNow)).ConfigureAwait(false); + } + catch (SendRefusedException ex) + { + refusal = ex.Message; + } + } + if (refusal is not null) + { + refused++; + context.Log(refusal); + await UpdateAsync(project, entry.RenderId, e => e.AsFailed(refusal)).ConfigureAwait(false); + } + await context.ReportAsync(i + 1, entries.Count).ConfigureAwait(false); + } + context.Log(Loc.L("Archive.Log.WorkspaceSent", workspace.Name, sent, there)); + if (refused > 0) throw new InvalidOperationException(Loc.L("Errors.Workspace.SendFailed", refused, entries.Count)); + } + + /// Why the render cannot be sent as it is (gone from the exports, or another file than the one rendered); null when it can. + private static async Task CheckAsync(WorkspaceProject project, WorkspaceRenderEntry entry, string file, CancellationToken ct) + { + var name = Path.GetFileName(entry.File); + var exports = Path.TrimEndingDirectorySeparator(Path.GetFullPath(project.ExportsDirectory)) + Path.DirectorySeparatorChar; + // A ledger names files inside the exports only; one pointing elsewhere is never read. + if (!Path.GetFullPath(file).StartsWith(exports, StringComparison.OrdinalIgnoreCase) || !File.Exists(file)) return Loc.L("Errors.Workspace.SendMissing", name); + if (new FileInfo(file).Length != entry.Size + || !string.Equals(await ChronosClient.HashFileAsync(file, ct).ConfigureAwait(false), entry.Sha256, StringComparison.OrdinalIgnoreCase)) + return Loc.L("Errors.Workspace.SendHashMismatch", name); + return null; + } + + /// + /// Version of the project at the home: pushed there first (every local version, in order, as a + /// sync pushes them) when the home lacks it. A push that does not bring it there fails the job. + /// + private static async Task EnsureVersionAsync(JobContext context, WorkspaceProject project, BundleWorkspace workspace, IProjectHome home, Guid projectId, + Guid versionId, CancellationToken ct) + { + if (await home.GetVersionAsync(projectId, versionId, ct).ConfigureAwait(false) is not null) return; + try + { + await new WorkspaceSync(project.Store, Environment.MachineName) { LockWait = LockWait }.PushAsync(projectId, home, ct).ConfigureAwait(false); + } + catch (Exception ex) when (ex is HomeUnavailableException or WorkspaceSyncException or ProjectException or LeaseUnavailableException + or InvalidOperationException) + { + context.Log(ex.Message); + throw new InvalidOperationException(Loc.L("Errors.Workspace.SendVersion"), ex); + } + var pushed = await home.GetVersionAsync(projectId, versionId, ct).ConfigureAwait(false) + ?? throw new InvalidOperationException(Loc.L("Errors.Workspace.SendVersion")); + context.Log(Loc.L("Archive.Log.WorkspaceVersionPushed", workspace.Name, pushed.Number)); + } + + /// + /// The render filed in this PC's archive, the home's sequence: copied into the archive's staging folder, read back against + /// the ledger's SHA-256, then filed under the sequence's lease with the project and version (once both are checked to be + /// the sequence's). A render id the index holds already for this sequence is the same render, sent before. + /// + private async Task FileAsync(Sequence sequence, Archive archive, WorkspaceRenderEntry entry, string file, CancellationToken ct) + { + if (await db.Renders.GetAsync(entry.RenderId, ct).ConfigureAwait(false) is { } known) + return known.SequenceId == sequence.Id ? false : throw new SendRefusedException(Loc.L("Server.Error.RenderExists")); + if (!await ProjectOfAsync(sequence.Id, entry, ct).ConfigureAwait(false)) throw new SendRefusedException(Loc.L("Server.Error.ProjectMismatch")); + var paths = new ArchivePaths(archive.RootPath); + ArchiveVolume.EnsureWritable(paths); + SyncTransfers.EnsureSpace(paths.Root, entry.Size); + Directory.CreateDirectory(paths.StagingDirectory); + var staged = Path.Combine(paths.StagingDirectory, "workspace-render-" + entry.RenderId.ToString("N") + ".part"); + try + { + await using (var source = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read, 1 << 20, FileOptions.Asynchronous | FileOptions.SequentialScan)) + await using (var target = new FileStream(staged, FileMode.Create, FileAccess.Write, FileShare.None, 1 << 20, FileOptions.Asynchronous)) + { + await source.CopyToAsync(target, ct).ConfigureAwait(false); + target.Flush(flushToDisk: true); + } + // Read back from the archive's volume: what is filed is the render as it was written. + if (!string.Equals(await ChronosClient.HashFileAsync(staged, ct).ConfigureAwait(false), entry.Sha256, StringComparison.OrdinalIgnoreCase)) + throw new IOException(Loc.L("Errors.Workspace.CopyMismatch", staged)); + var name = SyncTransfers.SafeFileName(Path.GetFileName(entry.File)) ?? entry.RenderId.ToString("N"); + var filed = await SyncTransfers.FileRenderAsync(archives, db, sequence, paths, staged, name, new Render + { + Id = entry.RenderId, + SequenceId = sequence.Id, + PresetName = entry.PresetName, + OutputPath = string.Empty, + Codec = entry.Codec, + Width = entry.Width, + Height = entry.Height, + Fps = entry.Fps, + DurationSeconds = entry.DurationSeconds, + Created = entry.Rendered, + ProducedBy = options.Processing.ProducedBy, + ProjectId = entry.ProjectId, + ProjectVersionId = entry.ProjectVersionId, + }, ct).ConfigureAwait(false); + return filed is not null ? true : throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved")); + } + finally + { + TryDelete(staged); + } + } + + /// The project the entry names is one of the sequence's, and its version (when it names one) one of that project's. + private async Task ProjectOfAsync(Guid sequenceId, WorkspaceRenderEntry entry, CancellationToken ct) + { + var project = await db.Projects.GetAsync(entry.ProjectId, ct).ConfigureAwait(false); + var version = entry.ProjectVersionId is { } versionId ? await db.Projects.GetVersionAsync(versionId, ct).ConfigureAwait(false) : null; + if (project is null || (entry.ProjectVersionId is not null && version is null)) + { + // One the index does not know yet may be in the sequence's sidecars: listing reads them first. + await archives.Projects.ListAsync(sequenceId, ct).ConfigureAwait(false); + project = await db.Projects.GetAsync(entry.ProjectId, ct).ConfigureAwait(false); + if (entry.ProjectVersionId is { } id) version = await db.Projects.GetVersionAsync(id, ct).ConfigureAwait(false); + } + return project is not null && project.SequenceId == sequenceId && (entry.ProjectVersionId is null || version?.ProjectId == project.Id); + } + + /// + /// The render uploaded to its server's sequence, with its project and version, resumable and checked against its SHA-256 + /// there; the server answers that it holds the render already when it does. Refused for good (the server takes the + /// project for another sequence's, the id for another sequence's render, the file for too large or not the one hashed): + /// marked failed; anything else (the server out of reach, busy, the sign-in expired) fails the job, the entry left as it was. + /// + private async Task UploadAsync(ISyncRemote remote, Guid sequenceId, WorkspaceRenderEntry entry, string file, CancellationToken ct) + { + var name = SyncTransfers.SafeFileName(Path.GetFileName(entry.File)) ?? entry.RenderId.ToString("N"); + var request = new RenderUploadRequest(entry.RenderId, name, entry.Size, entry.Sha256.ToLowerInvariant(), entry.PresetName, entry.Codec, entry.Width, entry.Height, + entry.Fps, entry.DurationSeconds, options.Processing.ProducedBy, entry.ProjectId, entry.ProjectVersionId); + try + { + return await remote.UploadRenderAsync(sequenceId, file, request, ct).ConfigureAwait(false) is not null; + } + catch (ChronosApiException ex) when (ex.Status is HttpStatusCode.BadRequest or HttpStatusCode.Conflict or HttpStatusCode.RequestEntityTooLarge + or HttpStatusCode.UnprocessableEntity) + { + throw new SendRefusedException(string.IsNullOrWhiteSpace(ex.Error.Message) ? ex.Message : ex.Error.Message); + } + } + + /// Waits while transfers with a server are held (a metered connection), saying so once. + private async Task WhileHeldAsync(JobContext context) + { + if (!options.HoldTransfers()) return; + context.Log(Loc.L("Archive.Log.WorkspaceSendHeld")); + while (options.HoldTransfers()) await Task.Delay(HoldPoll, context.Cancellation).ConfigureAwait(false); + } + + /// + /// The ledger entry of changed by , under the project's lease, read again + /// first (a render finished meanwhile stays); an entry discarded meanwhile stays discarded. Written whatever stops the job. + /// + private static async Task UpdateAsync(WorkspaceProject project, Guid renderId, Func change) + { + using (await project.LockAsync(LockWait, CancellationToken.None).ConfigureAwait(false)) + { + var ledger = project.ReadRenders(); + if (ledger.Find(renderId) is { } entry) project.WriteRenders(ledger.With(change(entry))); + } + } + + private static void TryDelete(string path) + { + try + { + if (File.Exists(path)) File.Delete(path); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + Log.Debug("workspace", $"{path} could not be removed: {ex.Message}"); + } + } + + /// The home will not take this render as it is: it is marked failed with this message, and the others go on. + private sealed class SendRefusedException(string message) : Exception(message); } diff --git a/src/Chronos.Protocol/Sequences.cs b/src/Chronos.Protocol/Sequences.cs index 1dcfe9be..617c9169 100644 --- a/src/Chronos.Protocol/Sequences.cs +++ b/src/Chronos.Protocol/Sequences.cs @@ -109,6 +109,13 @@ public sealed record ManifestFrame(Guid Id, int Index, string FileName, long Siz /// How the server's proxies are made (BRIEF §8.5): long edge in pixels (0 = full size) and JPEG quality. public sealed record ProxySpec(int LongEdge, int Quality); +/// A render of a sequence, filed under its exports. +/// +/// The project whose version was rendered (owner review 2, R8): a render node's output of a job that names one, or a render a +/// workspace made on a client and sent home (phase 5c); null for a render of the sequence's own settings, and from servers +/// before phase 5c. +/// +/// The project version rendered; null when none is named (see ). public sealed record RenderDto( Guid Id, string PresetName, @@ -119,7 +126,9 @@ public sealed record RenderDto( double DurationSeconds, long Bytes, DateTimeOffset Created, - string? ProducedBy); + string? ProducedBy, + Guid? ProjectId = null, + Guid? ProjectVersionId = null); /// Aggregates for the archive dashboard and the admin panel. /// Free bytes of the space volume: the server's space path when one is set, else the archive's volume. diff --git a/src/Chronos.Server/Api/Dto.cs b/src/Chronos.Server/Api/Dto.cs index 0a5b6720..32a2a16c 100644 --- a/src/Chronos.Server/Api/Dto.cs +++ b/src/Chronos.Server/Api/Dto.cs @@ -23,7 +23,8 @@ public static class Dto f.Id, f.SequenceId, f.Index, f.FileName, f.Size, f.Sha256, f.CapturedAt, f.UtcOffsetMinutes, f.ExposureTime, f.FNumber, f.Iso, f.FocalLength, f.Orientation, f.Width, f.Height, f.Format.ToString().ToLowerInvariant(), (long)f.Flags, f.PreviewWidth, f.PreviewHeight); - public static RenderDto Render(Render r) => new(r.Id, r.PresetName, r.Codec, r.Width, r.Height, r.Fps, r.DurationSeconds, r.Bytes, r.Created, r.ProducedBy); + public static RenderDto Render(Render r) => new(r.Id, r.PresetName, r.Codec, r.Width, r.Height, r.Fps, r.DurationSeconds, r.Bytes, r.Created, r.ProducedBy, + r.ProjectId, r.ProjectVersionId); public static JobDto Job(Job j) => new( j.Id, JobWire.Kind(j.Kind), j.TargetIds, j.TargetLabel, JobWire.State(j.State), JobWire.Priority(j.Priority), j.ProgressDone, diff --git a/src/Chronos.Server/Storage/RenderUploads.cs b/src/Chronos.Server/Storage/RenderUploads.cs index 80e55955..08747830 100644 --- a/src/Chronos.Server/Storage/RenderUploads.cs +++ b/src/Chronos.Server/Storage/RenderUploads.cs @@ -3,6 +3,7 @@ using System.Text.Json; using Chronos.Core.Archiving; using Chronos.Core.Model; using Chronos.Data; +using Chronos.Data.Archiving; using Chronos.Data.Repositories; using Chronos.Protocol; using Chronos.Server.Api; @@ -17,7 +18,12 @@ namespace Chronos.Server.Storage; /// Renders a client sends on request (BRIEF §14.5): chunked like frame uploads (same store, chunk endpoint and /// retention), verified against their SHA-256 at completion and filed by under the /// sequence's exports with the client's render id, so both sides recognise the same render. +/// A render a workspace made (phase 5c) names its project and version: both are checked against the sequence when the upload +/// starts and again when it completes (422 project_mismatch: the project is not one of the sequence's, or the version +/// not one of the project's) and recorded with the render; a version alone names its project. Without them a render is filed +/// as before, recording neither. /// +/// The archive engine whose projects are read when the index does not know one yet; one of its own when none is registered. public sealed class RenderUploads( ChronosDatabase db, ServerOptions options, @@ -26,7 +32,8 @@ public sealed class RenderUploads( RenderStore renders, EventHub events, VolumeSpace volumes, - TimeProvider time) + TimeProvider time, + ArchiveService? archives = null) { public async Task> StartAsync(Caller caller, Guid sequenceId, RenderUploadRequest request, CancellationToken cancellationToken) { @@ -45,6 +52,8 @@ public sealed class RenderUploads( ? new StartUploadResponse(null, options.ChunkSizeBytes, [], AlreadyExists: true, null) : Outcome.Fail(409, "render_exists"); } + // Checked before a byte is sent, and again at completion. + if (await ProjectOfAsync(sequenceId, request, cancellationToken) is null) return Outcome.Fail(422, "project_mismatch"); var sha = request.Sha256.ToLowerInvariant(); if (await db.Uploads.FindReceivingAsync(caller.Id, sha, cancellationToken) is { } open && open.SequenceId == sequenceId && open.Size == request.Size && Read(open)?.RenderId == request.RenderId && store.Exists(open.Id)) @@ -81,6 +90,8 @@ public sealed class RenderUploads( if (upload.State != UploadState.Receiving) return Outcome.Fail(409, "upload_state"); if (!upload.IsComplete) return Outcome.Fail(409, "incomplete", (upload.ChunkCount - upload.ReceivedCount).ToString(CultureInfo.InvariantCulture)); + // Asked again: the upload may have been started before the project was deleted from the index, or by an earlier server. + if (await ProjectOfAsync(sequenceId, output, cancellationToken) is not { } provenance) return Outcome.Fail(422, "project_mismatch"); if (!uploads.ArchiveHasRoom(upload)) return Outcome.Fail(507, "insufficient_storage"); if (!await db.Uploads.TryTransitionAsync(upload.Id, UploadState.Receiving, UploadState.Committing, cancellationToken: cancellationToken)) return Outcome.Fail(409, "upload_state"); @@ -93,7 +104,7 @@ public sealed class RenderUploads( try { render = sequence is null ? null : await renders.CommitAsync(sequence, staged, result, output.ProducedBy ?? caller.ClientName ?? caller.User.Username, - output.RenderId, cancellationToken); + output.RenderId, provenance.ProjectId, provenance.ProjectVersionId, cancellationToken); } catch (Exception ex) when (ex is LeaseUnavailableException or ArchiveOfflineException or FolderMovedException) { @@ -113,6 +124,33 @@ public sealed class RenderUploads( return Dto.Render(render); } + /// + /// The project and version names, checked against sequence : the + /// project one of its own (deleted ones included: their versions are kept), the version one of that project's (a version + /// alone names its project). One the index does not know yet may be in the sequence's sidecars: listing reads them first. + /// Both null when the request names neither; null when they do not hold. + /// + private async Task<(Guid? ProjectId, Guid? ProjectVersionId)?> ProjectOfAsync(Guid sequenceId, RenderUploadRequest request, CancellationToken cancellationToken) + { + if (request.ProjectId is null && request.ProjectVersionId is null) return (null, null); + var (project, version) = await FindAsync(); + if (project is null || (request.ProjectVersionId is not null && version is null)) + { + await LibraryEndpoints.Engine(archives, db).Projects.ListAsync(sequenceId, cancellationToken); + (project, version) = await FindAsync(); + } + if (project is null || project.SequenceId != sequenceId || (version is not null && version.ProjectId != project.Id)) return null; + return (project.Id, version?.Id); + + async Task<(SequenceProject? Project, ProjectVersion? Version)> FindAsync() + { + var known = request.ProjectVersionId is { } versionId ? await db.Projects.GetVersionAsync(versionId, cancellationToken) : null; + if (request.ProjectVersionId is not null && known is null) return (null, null); + var projectId = request.ProjectId ?? known!.ProjectId; + return (await db.Projects.GetAsync(projectId, cancellationToken), known); + } + } + private static RenderUploadRequest? Read(Upload upload) { if (upload.RenderJson is not { } json) return null; diff --git a/tests/Chronos.App.Tests/Server/UploadHoldTests.cs b/tests/Chronos.App.Tests/Server/UploadHoldTests.cs new file mode 100644 index 00000000..e2d9844e --- /dev/null +++ b/tests/Chronos.App.Tests/Server/UploadHoldTests.cs @@ -0,0 +1,62 @@ +using Chronos.App.Server; +using Chronos.Core.Model; +using Chronos.Data.Archiving.Jobs; +using Chronos.Data.Workspaces; +using Chronos.Testing; + +namespace Chronos.App.Tests.Server; + +/// +/// Which jobs "Pause metered transfers" holds (Server.html, phase 5c): uploads, and the workspace's copies from and renders +/// sent to a server; never a copy from or a send to this PC's archive. +/// +public sealed class UploadHoldTests +{ + private const string Server = "https://nas.local:8443"; + private static readonly Guid SequenceId = Guid.CreateVersion7(); + private static readonly Guid ProjectId = Guid.CreateVersion7(); + private const string Root = @"C:\Users\me\Chronos\workspace"; + + private static Job Of(ArchiveJobRequest request) => new() + { + Id = Guid.CreateVersion7(), + Kind = request.Kind, + TargetIds = request.Targets, + TargetLabel = request.Label, + ParametersJson = request.ParametersJson, + State = JobState.Queued, + Created = DateTimeOffset.UtcNow, + }; + + private static Job Of(JobKind kind, string? parameters = null) => new() + { + Id = Guid.CreateVersion7(), + Kind = kind, + TargetIds = [SequenceId], + ParametersJson = parameters, + State = JobState.Queued, + Created = DateTimeOffset.UtcNow, + }; + + [Test] + public void TransfersWithAServerAreHeld() + { + Assert.True(UploadHold.Holds(Of(JobKind.UploadCommit))); + Assert.True(UploadHold.Holds(Of(WorkspaceJobs.CopyFromServer(SequenceId, "Harbour", Server, Root, ProjectId)))); + Assert.True(UploadHold.Holds(Of(WorkspaceJobs.Send(SequenceId, "Harbour", Root, ProjectId, [], Server)))); + Assert.SequenceEqual([JobKind.UploadCommit, JobKind.WorkspaceCopy, JobKind.WorkspaceSend], UploadHold.Kinds); + } + + [Test] + public void TransfersWithThisPcsLibraryAndOtherJobsAreNot() + { + var sequence = new Sequence { Id = SequenceId, ArchiveId = Guid.CreateVersion7(), Title = "Harbour", Folder = "2026/harbour" }; + Assert.False(UploadHold.Holds(Of(WorkspaceJobs.Copy(sequence, Root, ProjectId)))); + Assert.False(UploadHold.Holds(Of(WorkspaceJobs.Send(SequenceId, "Harbour", Root, ProjectId, [])))); + Assert.False(UploadHold.Holds(Of(JobKind.Download))); + Assert.False(UploadHold.Holds(Of(JobKind.Render))); + // Parameters that cannot be read are not held: the job fails with its reason. + Assert.False(UploadHold.Holds(Of(JobKind.WorkspaceSend, "{not json"))); + Assert.False(UploadHold.Holds(Of(JobKind.WorkspaceCopy))); + } +} diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceSendTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceSendTests.cs new file mode 100644 index 00000000..6559dcc2 --- /dev/null +++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceSendTests.cs @@ -0,0 +1,221 @@ +using System.Security.Cryptography; +using Chronos.Core.Localization; +using Chronos.Core.Model; +using Chronos.Core.Project; +using Chronos.Data.Archiving; +using Chronos.Data.Jobs; +using Chronos.Data.Tests.Archiving; +using Chronos.Data.Tests.Infrastructure; +using Chronos.Data.Workspaces; +using Chronos.Testing; + +namespace Chronos.Data.Tests.Workspaces; + +/// +/// A workspace's local renders sent home (phase 5c, ) to this PC's archive: filed with +/// their project and version, the version pushed first when the home lacks it, a changed or missing file refused and left in +/// the workspace, a send repeated after a cut harmless, and never held on a metered connection. +/// +[Category("workspace")] +public abstract class WorkspaceSendTests(TestContext context) : DatabaseTest(context) +{ + private static readonly DateTimeOffset Rendered = new(2026, 11, 4, 9, 0, 0, TimeSpan.Zero); + + private async Task FixtureAsync() + { + var archive = Own(await ArchiveFixture.CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true))); + return Own(await WorkspaceFixture.CreateAsync(Context, archive, 3)); + } + + /// An engine with the workspace's handlers; stands for a metered connection. + private async Task EngineAsync(WorkspaceFixture fx, Func? hold = null) + { + var options = WorkspaceJobOptions.For(fx.Archive.Service) with { HoldTransfers = hold ?? (() => false) }; + var engine = new JobEngine(fx.Db, WorkspaceJobs.CreateHandlers(fx.Db, fx.Archive.Service, null, options), + new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }); + await engine.StartAsync(Ct); + Own(engine); + return engine; + } + + /// Main checked out into a workspace of its own (its media are not needed to send). + private static async Task<(WorkspaceStore Store, WorkspaceSync Sync, WorkspaceProject Project)> CheckoutAsync(WorkspaceFixture fx) + { + var (store, sync) = fx.Workspace(); + var main = await fx.Archive.Service.Projects.MainAsync(fx.Sequence.Id, fx.Ct); + return (store, sync, await sync.CheckoutAsync(fx.Home, main.Id, cancellationToken: fx.Ct)); + } + + /// An output in the project's exports with its ledger entry, as a local render leaves them. + private static WorkspaceRenderEntry Render(WorkspaceProject project, Guid? versionId, string name, int seed) + { + Directory.CreateDirectory(project.ExportsDirectory); + var bytes = new byte[150_000 + seed]; + new Random(seed).NextBytes(bytes); + File.WriteAllBytes(Path.Combine(project.ExportsDirectory, name), bytes); + var entry = new WorkspaceRenderEntry(Guid.CreateVersion7(), Guid.CreateVersion7(), name, Convert.ToHexStringLower(SHA256.HashData(bytes)), bytes.Length, + "1080p H.264", "h264", 1920, 1080, 24, 2.5, project.ProjectId, versionId, null, Rendered); + project.WriteRenders(project.ReadRenders().With(entry)); + return entry; + } + + private static string Sha(string path) => Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(path))); + + private static async Task SendAsync(WorkspaceFixture fx, JobEngine engine, WorkspaceStore store, Guid projectId, JobState expected, + params Guid[] renderIds) + { + var job = await engine.EnqueueAsync(WorkspaceJobs.Send(fx.Sequence.Id, fx.Sequence.DisplayTitle, store.Root, projectId, renderIds), cancellationToken: fx.Ct); + return await fx.Archive.WaitForAsync(job.Id, expected, (int)TestTiming.Budget(60)); + } + + [Test] + public async Task TheSendFilesTheRenderInTheLibraryWithItsProjectAndVersion() + { + var fx = await FixtureAsync(); + var engine = await EngineAsync(fx); + var (store, _, project) = await CheckoutAsync(fx); + var head = project.ReadBundle().Workspace!.Base!.VersionId; + var entry = Render(project, head, "Main 1080p.mp4", 1); + + await SendAsync(fx, engine, store, project.ProjectId, JobState.Done); + + var row = Assert.NotNull(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct)); + Assert.Equal((fx.Sequence.Id, (Guid?)project.ProjectId, (Guid?)head, "1080p H.264", entry.Size, 1920), + (row.SequenceId, row.ProjectId, row.ProjectVersionId, row.PresetName, row.Bytes, row.Width)); + var filed = Path.Combine(fx.Archive.Archive.RootPath, row.OutputPath); + Assert.Equal(entry.Sha256, Sha(filed)); + Assert.Equal("Main 1080p.mp4", Path.GetFileName(filed)); + // The workspace keeps its file until a clean-up; the ledger says it went home. + Assert.Equal(entry.Sha256, Sha(project.ExportFile(entry.File))); + var sent = Assert.NotNull(project.ReadRenders().Find(entry.RenderId)); + Assert.True(sent.IsSent); + Assert.NotNull(sent.Sent); + Assert.Empty(Directory.GetFiles(fx.Archive.Paths.StagingDirectory, "workspace-render-*")); + } + + [Test] + public async Task ASendRepeatedAfterACutFilesNothingTwice() + { + var fx = await FixtureAsync(); + var engine = await EngineAsync(fx); + var (store, _, project) = await CheckoutAsync(fx); + var entry = Render(project, project.ReadBundle().Workspace!.Base!.VersionId, "Main.mp4", 2); + await SendAsync(fx, engine, store, project.ProjectId, JobState.Done, entry.RenderId); + + // Cut after the home filed it, before the ledger said so: the next send finds it there and only marks it sent. + project.WriteRenders(project.ReadRenders().With(entry)); + Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsUnsent); + var again = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done); + Assert.Contains(Loc.L("Archive.Log.WorkspaceSent", project.ReadBundle().Workspace!.Name, 0, 1), again.LogTail); + Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsSent); + Assert.Equal(1, (await fx.Db.Renders.ListBySequenceAsync(fx.Sequence.Id, fx.Ct)).Count); + var exports = Path.GetDirectoryName(Path.Combine(fx.Archive.Archive.RootPath, (await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct))!.OutputPath))!; + Assert.Equal(1, Directory.GetFiles(exports).Length); + + // A send with nothing unsent is done at once. + var nothing = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done); + Assert.Contains(Loc.L("Archive.Log.WorkspaceSent", project.ReadBundle().Workspace!.Name, 0, 0), nothing.LogTail); + } + + [Test] + public async Task AVersionTheHomeLacksIsSentFirst() + { + var fx = await FixtureAsync(); + var engine = await EngineAsync(fx); + // With its media: a version is saved only of frames the workspace holds. + var (store, sync) = fx.Workspace(); + var project = await fx.CheckoutAsync(sync); + var session = await sync.OpenAsync(project.ProjectId, fx.Ct); + await sync.SaveAsync(project.ProjectId, session.Working with { HeroFrame = 2 }, fx.Ct); + var local = Assert.NotNull(await sync.CommitAsync(project.ProjectId, "Render", cancellationToken: fx.Ct)); + Assert.Null(await fx.Home.GetVersionAsync(project.ProjectId, local.Id, fx.Ct)); + var entry = Render(project, local.Id, "Hero.mp4", 3); + + var job = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done); + + var pushed = Assert.NotNull(await fx.Home.GetVersionAsync(project.ProjectId, local.Id, fx.Ct)); + Assert.Contains(Loc.L("Archive.Log.WorkspaceVersionPushed", project.ReadBundle().Workspace!.Name, pushed.Number), job.LogTail); + Assert.Equal((Guid?)local.Id, (await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct))!.ProjectVersionId); + Assert.Equal(WorkspaceState.InSync, (await sync.StatusAsync(project.ProjectId, fx.Home, fx.Ct)).State); + } + + [Test] + public async Task AChangedOrMissingRenderIsRefusedAndTheOthersGoOn() + { + var fx = await FixtureAsync(); + var engine = await EngineAsync(fx); + var (store, _, project) = await CheckoutAsync(fx); + var head = project.ReadBundle().Workspace!.Base!.VersionId; + var changed = Render(project, head, "Changed.mp4", 4); + var gone = Render(project, head, "Gone.mp4", 5); + var good = Render(project, head, "Good.mp4", 6); + var original = File.ReadAllBytes(project.ExportFile(changed.File)); + File.AppendAllText(project.ExportFile(changed.File), "edited"); + File.Delete(project.ExportFile(gone.File)); + + var failed = await SendAsync(fx, engine, store, project.ProjectId, JobState.Failed); + + Assert.Equal(Loc.L("Errors.Workspace.SendFailed", 2, 3), failed.Error); + var ledger = project.ReadRenders(); + Assert.True(ledger.Find(good.RenderId)!.IsSent); + Assert.Equal((WorkspaceRenderEntry.Failed, Loc.L("Errors.Workspace.SendHashMismatch", "Changed.mp4")), + (ledger.Find(changed.RenderId)!.State, ledger.Find(changed.RenderId)!.Error)); + Assert.Equal((WorkspaceRenderEntry.Failed, Loc.L("Errors.Workspace.SendMissing", "Gone.mp4")), + (ledger.Find(gone.RenderId)!.State, ledger.Find(gone.RenderId)!.Error)); + Assert.Null(await fx.Db.Renders.GetAsync(changed.RenderId, fx.Ct)); + Assert.Null(await fx.Db.Renders.GetAsync(gone.RenderId, fx.Ct)); + // The changed file stays in the workspace as it is. + Assert.FileExists(project.ExportFile(changed.File)); + + // Put back as rendered (and the missing one discarded), the next send takes it. + File.WriteAllBytes(project.ExportFile(changed.File), original); + project.WriteRenders(project.ReadRenders().Without(gone.RenderId)); + await SendAsync(fx, engine, store, project.ProjectId, JobState.Done); + Assert.True(project.ReadRenders().Find(changed.RenderId)!.IsSent); + Assert.Equal(2, (await fx.Db.Renders.ListBySequenceAsync(fx.Sequence.Id, fx.Ct)).Count); + } + + [Test] + public async Task AVersionOfAnotherProjectIsNeverFiledWithTheRender() + { + var fx = await FixtureAsync(); + var engine = await EngineAsync(fx); + var (store, _, project) = await CheckoutAsync(fx); + var other = await fx.Home.CreateAsync("Vertical", null, null, fx.Ct); + var foreign = (await fx.Home.HeadAsync(other.Id, fx.Ct)).Id; + var entry = Render(project, foreign, "Foreign.mp4", 7); + + var failed = await SendAsync(fx, engine, store, project.ProjectId, JobState.Failed); + + Assert.Equal(Loc.L("Errors.Workspace.SendVersion"), failed.Error); + Assert.Null(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct)); + // Not the render's fault: it waits, unsent, for the next send. + Assert.Equal(WorkspaceRenderEntry.Pending, project.ReadRenders().Find(entry.RenderId)!.State); + } + + [Test] + public async Task ASendToThisPcsLibraryIsNeverHeldOnAMeteredConnection() + { + var fx = await FixtureAsync(); + var engine = await EngineAsync(fx, hold: () => true); + var (store, _, project) = await CheckoutAsync(fx); + var entry = Render(project, null, "Working.mp4", 8); + + var job = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done); + + Assert.False(job.LogTail?.Contains(Loc.L("Archive.Log.WorkspaceSendHeld"), StringComparison.Ordinal) ?? false); + var row = Assert.NotNull(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct)); + Assert.Equal(((Guid?)project.ProjectId, (Guid?)null), (row.ProjectId, row.ProjectVersionId)); + } +} + +public sealed class SqliteWorkspaceSendTests(TestContext context) : WorkspaceSendTests(context) +{ + protected override Backend Backend => Backend.SqliteFile; +} + +[RequiresEnvironment(PgTestServer.Variable)] +public sealed class PostgresWorkspaceSendTests(TestContext context) : WorkspaceSendTests(context) +{ + protected override Backend Backend => Backend.Postgres; +} diff --git a/tests/Chronos.Server.Tests/Workspaces/WorkspaceSendServerTests.cs b/tests/Chronos.Server.Tests/Workspaces/WorkspaceSendServerTests.cs new file mode 100644 index 00000000..adaa1692 --- /dev/null +++ b/tests/Chronos.Server.Tests/Workspaces/WorkspaceSendServerTests.cs @@ -0,0 +1,186 @@ +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"); + } +}