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 <noreply@anthropic.com>
222 lines
12 KiB
C#
222 lines
12 KiB
C#
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;
|
|
|
|
/// <summary>
|
|
/// A workspace's local renders sent home (phase 5c, <see cref="JobKind.WorkspaceSend"/>) 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.
|
|
/// </summary>
|
|
[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<WorkspaceFixture> FixtureAsync()
|
|
{
|
|
var archive = Own(await ArchiveFixture.CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
|
|
return Own(await WorkspaceFixture.CreateAsync(Context, archive, 3));
|
|
}
|
|
|
|
/// <summary>An engine with the workspace's handlers; <paramref name="hold"/> stands for a metered connection.</summary>
|
|
private async Task<JobEngine> EngineAsync(WorkspaceFixture fx, Func<bool>? 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;
|
|
}
|
|
|
|
/// <summary>Main checked out into a workspace of its own (its media are not needed to send).</summary>
|
|
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));
|
|
}
|
|
|
|
/// <summary>An output in the project's exports with its ledger entry, as a local render leaves them.</summary>
|
|
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<Job> 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;
|
|
}
|