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>
112 lines
5.4 KiB
C#
112 lines
5.4 KiB
C#
using Chronos.Core.Model;
|
|
using Chronos.Data.Jobs;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Data.Tests.Jobs;
|
|
|
|
/// <summary>The priority queue of the settings (owner review 1, R2): levels per kind of job, the claim order and what interrupts.</summary>
|
|
[Category("jobs")]
|
|
public sealed class JobPriorityQueueTests
|
|
{
|
|
private static readonly DateTimeOffset T0 = new(2026, 10, 16, 9, 0, 0, TimeSpan.Zero);
|
|
|
|
[Test]
|
|
public void RendersImportsAndDownloadsComeFirstAndTheLongResumablePassesLast()
|
|
{
|
|
var queue = new JobPriorityQueue();
|
|
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.Render));
|
|
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.Import));
|
|
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.Download));
|
|
// Edit waits for the copy of a project's media into the workspace: it goes before scans and analyses.
|
|
Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.WorkspaceCopy));
|
|
var on = queue with { Enabled = true };
|
|
Assert.True(on.Interrupts(JobKind.WorkspaceCopy, JobKind.Scan));
|
|
Assert.False(on.Interrupts(JobKind.WorkspaceCopy, JobKind.Render));
|
|
Assert.Equal(JobKindPriority.Low, queue.LevelOf(JobKind.Verify));
|
|
Assert.Equal(JobKindPriority.Low, queue.LevelOf(JobKind.Proxies));
|
|
foreach (var kind in new[] { JobKind.Scan, JobKind.Thumbs, JobKind.LightAnalyse, JobKind.DeepAnalyse, JobKind.Maintenance })
|
|
Assert.Equal(JobKindPriority.Normal, queue.LevelOf(kind));
|
|
// A level the user set wins over the default.
|
|
Assert.Equal(JobKindPriority.Low, (queue with { Levels = new Dictionary<JobKind, JobKindPriority> { [JobKind.Render] = JobKindPriority.Low } }).LevelOf(JobKind.Render));
|
|
}
|
|
|
|
[Test]
|
|
public void OnlyAHigherLevelInterruptsAndOnlyWhileTheQueueIsOn()
|
|
{
|
|
var on = new JobPriorityQueue { Enabled = true };
|
|
Assert.True(on.Interrupts(JobKind.Render, JobKind.Scan));
|
|
Assert.True(on.Interrupts(JobKind.Scan, JobKind.Verify));
|
|
Assert.False(on.Interrupts(JobKind.Scan, JobKind.Render));
|
|
Assert.False(on.Interrupts(JobKind.Thumbs, JobKind.Scan));
|
|
Assert.False(on.Interrupts(JobKind.Import, JobKind.Render));
|
|
Assert.False(JobPriorityQueue.Off.Interrupts(JobKind.Render, JobKind.Verify));
|
|
}
|
|
|
|
[Test]
|
|
public void TheQueueOrdersByLevelThenPriorityThenAge()
|
|
{
|
|
var on = new JobPriorityQueue { Enabled = true };
|
|
var oldVerify = Job(JobKind.Verify, JobPriority.User, -30);
|
|
var backgroundScan = Job(JobKind.Scan, JobPriority.Background, -20);
|
|
var userThumbs = Job(JobKind.Thumbs, JobPriority.User, -10);
|
|
var render = Job(JobKind.Render, JobPriority.Normal, 0);
|
|
Job[] jobs = [oldVerify, backgroundScan, userThumbs, render];
|
|
|
|
Assert.SequenceEqual([render, userThumbs, backgroundScan, oldVerify], Sorted(jobs, on));
|
|
// Off, the strict queue of before: priority, then age.
|
|
Assert.SequenceEqual([oldVerify, userThumbs, render, backgroundScan], Sorted(jobs, JobPriorityQueue.Off));
|
|
// Two jobs alike fall back to the id.
|
|
var twin = render with { Id = Guid.CreateVersion7() };
|
|
Assert.True(on.ClaimsBefore(render, twin) != on.ClaimsBefore(twin, render));
|
|
}
|
|
|
|
[Test]
|
|
public void SettingsKeepOnlyTheLevelsThatDifferAndSkipWhatTheyCannotRead()
|
|
{
|
|
var queue = JobPriorityQueue.From(true, new Dictionary<string, string>
|
|
{
|
|
["deep-analyse"] = "high",
|
|
["Scan"] = "LOW",
|
|
["render"] = "high",
|
|
["teleport"] = "high",
|
|
["verify"] = "urgent",
|
|
["99"] = "low",
|
|
});
|
|
Assert.True(queue.Enabled);
|
|
Assert.Equal((JobKindPriority.High, JobKindPriority.Low, JobKindPriority.Low), (queue.LevelOf(JobKind.DeepAnalyse), queue.LevelOf(JobKind.Scan), queue.LevelOf(JobKind.Verify)));
|
|
|
|
var stored = JobPriorityQueue.Changed(Enum.GetValues<JobKind>().ToDictionary(k => k, queue.LevelOf));
|
|
Assert.SequenceEqual(["deep-analyse", "scan"], stored.Keys.Order(StringComparer.Ordinal));
|
|
Assert.Equal(("high", "low"), (stored["deep-analyse"], stored["scan"]));
|
|
var reread = JobPriorityQueue.From(true, stored);
|
|
foreach (var kind in Enum.GetValues<JobKind>()) Assert.Equal(queue.LevelOf(kind), reread.LevelOf(kind));
|
|
Assert.Equal(JobKindPriority.High, JobPriorityQueue.From(false, stored).LevelOf(JobKind.DeepAnalyse));
|
|
Assert.False(JobPriorityQueue.From(false, null).Enabled);
|
|
}
|
|
|
|
[Test]
|
|
public void TheClaimOrderOfTheDatabaseListsOnlyTheLevelsOtherThanNormal()
|
|
{
|
|
var on = new JobPriorityQueue { Enabled = true };
|
|
Assert.Equal(string.Empty, JobPriorityQueue.Off.OrderSql([JobKind.Render, JobKind.Verify]));
|
|
Assert.Equal(string.Empty, on.OrderSql([JobKind.Scan, JobKind.Thumbs]));
|
|
Assert.Equal("CASE WHEN kind IN (7) THEN 2 WHEN kind IN (2) THEN 0 ELSE 1 END DESC, ", on.OrderSql([JobKind.Render, JobKind.Verify, JobKind.Scan, JobKind.Render]));
|
|
}
|
|
|
|
private static Job[] Sorted(Job[] jobs, JobPriorityQueue queue)
|
|
{
|
|
var list = jobs.ToList();
|
|
list.Sort((a, b) => a.Id == b.Id ? 0 : queue.ClaimsBefore(a, b) ? -1 : 1);
|
|
return [.. list];
|
|
}
|
|
|
|
private static Job Job(JobKind kind, JobPriority priority, int minutes) => new()
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
Kind = kind,
|
|
Priority = priority,
|
|
State = JobState.Queued,
|
|
Created = T0.AddMinutes(minutes),
|
|
};
|
|
}
|