A push now moves the base before its local file reads as sent; a replay journals itself in sync.json, writes the replayed versions, then the base (the commit point), and only then sets the old ones aside and adopts the local commits the home already held; a conflict met past such commits moves the base onto them first. A save-both journals its copy and the ids it sends under, so a retry completes the same copy instead of making another. The next push, pull or resolve finishes or undoes whatever a cut left, so no version is orphaned and no false conflict appears. The editor reads the working state and the media index under the project lease; workspace.json is written whole and moved into place (an empty one is made again); project files may hold 64 MiB and one that would be larger is refused before it is written, so large projects check out. The workspace copy checks the drive's free space before and during the copy, keeps the folder in its checkpoint and stores a reset when a pass starts again, and runs at High level in the priority queue. Renders record a version only when the index holds it with the settings rendered; an unsent version renders as the project. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
176 lines
9.0 KiB
C#
176 lines
9.0 KiB
C#
using Chronos.Core.Model;
|
|
using Chronos.Data.Archiving;
|
|
using Chronos.Data.Jobs;
|
|
using Chronos.Data.Projects;
|
|
using Chronos.Data.Tests.Archiving;
|
|
using Chronos.Data.Tests.Projects;
|
|
using Chronos.Data.Workspaces;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Data.Tests.Workspaces;
|
|
|
|
/// <summary>An archive with an uploaded sequence as the projects' home, and workspaces that edit it (owner review 2, R8).</summary>
|
|
internal sealed class WorkspaceFixture : IAsyncDisposable
|
|
{
|
|
private readonly TestContext _context;
|
|
private JobEngine? _engine;
|
|
|
|
private WorkspaceFixture(TestContext context, ArchiveFixture archive, Sequence sequence, List<Frame> frames)
|
|
{
|
|
_context = context;
|
|
Archive = archive;
|
|
Sequence = sequence;
|
|
Frames = frames;
|
|
Home = new ArchiveProjectHome(archive.Db, archive.Service.Projects, sequence.Id);
|
|
}
|
|
|
|
public ArchiveFixture Archive { get; }
|
|
public Sequence Sequence { get; set; }
|
|
public List<Frame> Frames { get; }
|
|
public ArchiveProjectHome Home { get; }
|
|
public ChronosDatabase Db => Archive.Db;
|
|
public CancellationToken Ct => Archive.Ct;
|
|
|
|
public static async Task<WorkspaceFixture> CreateAsync(TestContext context, ArchiveFixture archive, int frames = 5)
|
|
{
|
|
var (sequence, list) = await ProjectServiceTests.UploadedAsync(archive, frames);
|
|
return new WorkspaceFixture(context, archive, sequence, list);
|
|
}
|
|
|
|
/// <summary>A workspace of its own (another PC, or another folder of this one) and its sync.</summary>
|
|
public (WorkspaceStore Store, WorkspaceSync Sync) Workspace(string name = "workspace")
|
|
{
|
|
var store = new WorkspaceStore(Path.Combine(_context.CreateTempDirectory(name), "workspace"));
|
|
return (store, new WorkspaceSync(store, "Chronos on " + name) { LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)) });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Another sync of <paramref name="store"/> that stops, as a crash would, at the <paramref name="occurrence"/>-th time it
|
|
/// reaches step <paramref name="step"/> (<see cref="WorkspaceSync.Cut"/>), throwing <see cref="CutException"/>.
|
|
/// </summary>
|
|
public static WorkspaceSync Cutting(WorkspaceStore store, string step, int occurrence = 1)
|
|
{
|
|
var seen = 0;
|
|
return new WorkspaceSync(store, "Chronos cut")
|
|
{
|
|
LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)),
|
|
Cut = name =>
|
|
{
|
|
if (name == step && ++seen == occurrence) throw new CutException(step);
|
|
},
|
|
};
|
|
}
|
|
|
|
/// <summary>Main of the sequence checked out into <paramref name="sync"/>'s workspace, its media copied.</summary>
|
|
public async Task<WorkspaceProject> CheckoutAsync(WorkspaceSync sync, Guid? projectId = null)
|
|
{
|
|
var id = projectId ?? (await Archive.Service.Projects.MainAsync(Sequence.Id, Ct)).Id;
|
|
var project = await sync.CheckoutAsync(Home, id, cancellationToken: Ct);
|
|
await CopyAsync(sync.Store, id);
|
|
return project;
|
|
}
|
|
|
|
/// <summary>Runs a workspace copy job to its end.</summary>
|
|
public Task<Job> CopyAsync(WorkspaceStore store, Guid projectId, JobState expected = JobState.Done, string? checkpoint = null, string media = "proxies") =>
|
|
CopyAsync(store.Root, projectId, expected, checkpoint, media);
|
|
|
|
/// <summary>Runs a workspace copy job into the workspace at <paramref name="root"/> to its end.</summary>
|
|
public async Task<Job> CopyAsync(string root, Guid projectId, JobState expected = JobState.Done, string? checkpoint = null, string media = "proxies")
|
|
{
|
|
var engine = await EngineAsync();
|
|
var request = WorkspaceJobs.Copy(Sequence, root, projectId, media);
|
|
var job = checkpoint is null ? await engine.EnqueueAsync(request, cancellationToken: Ct) : await Archive.EnqueueWithCheckpointAsync(engine, request, checkpoint);
|
|
return await Archive.WaitForAsync(job.Id, expected, (int)TestTiming.Budget(60));
|
|
}
|
|
|
|
private async Task<JobEngine> EngineAsync()
|
|
{
|
|
if (_engine is not null) return _engine;
|
|
_engine = new JobEngine(Db, [.. Archive.Service.CreateJobHandlers(), .. WorkspaceJobs.CreateHandlers(Db, Archive.Service)],
|
|
new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
|
|
await _engine.StartAsync(Ct);
|
|
return _engine;
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
if (_engine is not null) await _engine.DisposeAsync();
|
|
}
|
|
}
|
|
|
|
/// <summary>A crash between two writes of a sync (<see cref="WorkspaceFixture.Cutting"/>).</summary>
|
|
internal sealed class CutException(string step) : Exception($"Cut at {step}.");
|
|
|
|
/// <summary>
|
|
/// A home whose pushes can be cut: one refused as out of reach before the home sees it, or one stored whose answer is lost
|
|
/// on the way back (the program killed, the network dropped).
|
|
/// </summary>
|
|
internal sealed class CuttingHome(IProjectHome home) : IProjectHome
|
|
{
|
|
public int Pushes { get; private set; }
|
|
|
|
/// <summary>The push (counted from 1) refused as out of reach.</summary>
|
|
public int? Refuse { get; set; }
|
|
|
|
/// <summary>The push (counted from 1) the home stores and whose answer is lost.</summary>
|
|
public int? LoseAnswer { get; set; }
|
|
|
|
public async Task<PushResult> PushAsync(Guid projectId, ProjectVersion version, CancellationToken cancellationToken)
|
|
{
|
|
var push = ++Pushes;
|
|
if (push == Refuse) throw new HomeUnavailableException("The home cannot be reached.");
|
|
var result = await home.PushAsync(projectId, version, cancellationToken);
|
|
if (push == LoseAnswer) throw new HomeUnavailableException("The answer was lost.");
|
|
return result;
|
|
}
|
|
|
|
public Task<HomeSequence> SequenceAsync(CancellationToken cancellationToken) => home.SequenceAsync(cancellationToken);
|
|
public Task<IReadOnlyList<SequenceProject>> ListAsync(CancellationToken cancellationToken) => home.ListAsync(cancellationToken);
|
|
|
|
public Task<SequenceProject> CreateAsync(string name, Guid? fromVersionId, string? author, CancellationToken cancellationToken) =>
|
|
home.CreateAsync(name, fromVersionId, author, cancellationToken);
|
|
|
|
public Task<ProjectVersion> HeadAsync(Guid projectId, CancellationToken cancellationToken) => home.HeadAsync(projectId, cancellationToken);
|
|
|
|
public Task<ProjectVersion?> GetVersionAsync(Guid projectId, Guid versionId, CancellationToken cancellationToken) =>
|
|
home.GetVersionAsync(projectId, versionId, cancellationToken);
|
|
|
|
public Task<IReadOnlyList<ProjectVersion>> VersionsAfterAsync(Guid projectId, int afterNumber, int limit, CancellationToken cancellationToken) =>
|
|
home.VersionsAfterAsync(projectId, afterNumber, limit, cancellationToken);
|
|
|
|
public Task<IReadOnlyList<ProjectVersion>> HistoryAsync(Guid projectId, int? beforeNumber, int limit, CancellationToken cancellationToken) =>
|
|
home.HistoryAsync(projectId, beforeNumber, limit, cancellationToken);
|
|
|
|
public Task<HomeFrames> FramesAsync(CancellationToken cancellationToken) => home.FramesAsync(cancellationToken);
|
|
}
|
|
|
|
/// <summary>A home that cannot be reached, standing for a server out of reach or an archive offline.</summary>
|
|
internal sealed class UnreachableHome(IProjectHome home) : IProjectHome
|
|
{
|
|
public bool Reachable { get; set; }
|
|
|
|
private T Reach<T>(Func<T> call) => Reachable ? call() : throw new HomeUnavailableException("The home cannot be reached.");
|
|
|
|
public Task<HomeSequence> SequenceAsync(CancellationToken cancellationToken) => Reach(() => home.SequenceAsync(cancellationToken));
|
|
public Task<IReadOnlyList<SequenceProject>> ListAsync(CancellationToken cancellationToken) => Reach(() => home.ListAsync(cancellationToken));
|
|
|
|
public Task<SequenceProject> CreateAsync(string name, Guid? fromVersionId, string? author, CancellationToken cancellationToken) =>
|
|
Reach(() => home.CreateAsync(name, fromVersionId, author, cancellationToken));
|
|
|
|
public Task<ProjectVersion> HeadAsync(Guid projectId, CancellationToken cancellationToken) => Reach(() => home.HeadAsync(projectId, cancellationToken));
|
|
|
|
public Task<ProjectVersion?> GetVersionAsync(Guid projectId, Guid versionId, CancellationToken cancellationToken) =>
|
|
Reach(() => home.GetVersionAsync(projectId, versionId, cancellationToken));
|
|
|
|
public Task<IReadOnlyList<ProjectVersion>> VersionsAfterAsync(Guid projectId, int afterNumber, int limit, CancellationToken cancellationToken) =>
|
|
Reach(() => home.VersionsAfterAsync(projectId, afterNumber, limit, cancellationToken));
|
|
|
|
public Task<IReadOnlyList<ProjectVersion>> HistoryAsync(Guid projectId, int? beforeNumber, int limit, CancellationToken cancellationToken) =>
|
|
Reach(() => home.HistoryAsync(projectId, beforeNumber, limit, cancellationToken));
|
|
|
|
public Task<PushResult> PushAsync(Guid projectId, ProjectVersion version, CancellationToken cancellationToken) =>
|
|
Reach(() => home.PushAsync(projectId, version, cancellationToken));
|
|
|
|
public Task<HomeFrames> FramesAsync(CancellationToken cancellationToken) => Reach(() => home.FramesAsync(cancellationToken));
|
|
}
|