Owner review 1, phase 1 (docs/requests/2026-10-15-owner-review-1.md). Thumbnail and proxy jobs over several sequences counted sequences while they checkpointed inside one: the rate decayed until the time left overflowed TimeSpan, the job failed while publishing progress and again while saving it, and stayed Running. The throughput is now seeded by the first window with progress, the time left is bounded (JobEta), saving progress never throws, image passes count frames, and job speeds use the right unit (bytes for verify and import). The debugger stops in WicDecoderProvider.cs when presets changed were cancelled preview decodes leaving synchronous thread-pool delegates; the editor's sources, LatestRunner and the render node's proxy task now keep them in their own tasks, and a cancellation is never an unreadable frame. GoPro DNGs converted by Adobe software were classified GPR and read only through their 8-bit preview, and Windows' preview-only DNG decoder was reported as a native decode. A DNG is GPR only when its raw image is VC-5, WIC decodes RAW only through the Raw Image Extension and never DNG, analyses and previews take an adequate embedded preview by choice while renders develop natively, and frames already indexed as GPR are reclassified by the next light analysis. Also records the owner's request (docs/requests), the BRIEF amendments (§8.1, §8.2, new §24), DECISIONS, CHANGELOG, STATUS and ARCHITECTURE. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
148 lines
5.5 KiB
C#
148 lines
5.5 KiB
C#
using Titano.Core.Model;
|
|
using Titano.Data.Jobs;
|
|
using Titano.Protocol;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.Data.Tests.Jobs;
|
|
|
|
/// <summary>A clock the test moves by hand (BCL <see cref="TimeProvider"/>, no package).</summary>
|
|
internal sealed class ManualTime : TimeProvider
|
|
{
|
|
private long _ticks;
|
|
|
|
public override long TimestampFrequency => TimeSpan.TicksPerSecond;
|
|
|
|
public override long GetTimestamp() => Interlocked.Read(ref _ticks);
|
|
|
|
public void Advance(TimeSpan by) => Interlocked.Add(ref _ticks, by.Ticks);
|
|
}
|
|
|
|
[Category("jobs")]
|
|
public sealed class JobThroughputTests(TestContext context)
|
|
{
|
|
[Test]
|
|
public void TheFirstWindowWithProgressSeedsTheRate()
|
|
{
|
|
var throughput = new JobThroughput(0);
|
|
Assert.Null(throughput.Sample(2, 0, 100).Rate);
|
|
var (rate, eta) = throughput.Sample(4, 10, 100);
|
|
Assert.Equal(5.0, rate);
|
|
Assert.Equal(TimeSpan.FromSeconds(18), eta);
|
|
}
|
|
|
|
[Test]
|
|
public void AStalledJobLosesItsRateAndTimeLeftWithoutOverflowing()
|
|
{
|
|
// The owner's log: one sequence of 17 done, then a long one checkpointed every 10 s without moving the count.
|
|
var throughput = new JobThroughput(0);
|
|
throughput.Sample(600, 1, 17);
|
|
(double? Rate, TimeSpan? Eta) last = default;
|
|
for (var i = 1; i <= 2000; i++) last = throughput.Sample(600 + i * 10, 1, 17);
|
|
Assert.Null(last.Rate);
|
|
Assert.Null(last.Eta);
|
|
}
|
|
|
|
[Test]
|
|
public void ProgressThatGoesBackStartsANewWindow()
|
|
{
|
|
var throughput = new JobThroughput(0);
|
|
throughput.Sample(2, 20, 100);
|
|
throughput.Sample(3, 5, 100);
|
|
var (rate, _) = throughput.Sample(5, 15, 100);
|
|
Assert.Approximately(0.7 * 10 + 0.3 * 5, rate!.Value, 1e-9);
|
|
}
|
|
|
|
[Theory]
|
|
[Case(double.NaN)]
|
|
[Case(double.PositiveInfinity)]
|
|
[Case(-1.0)]
|
|
[Case(1e300)]
|
|
[Case(4e7)]
|
|
public void UnusableSecondsGiveNoTimeLeft(double seconds) => Assert.Null(JobEta.FromSeconds(seconds));
|
|
|
|
[Test]
|
|
public void UsableSecondsAndRatesGiveTheTimeLeft()
|
|
{
|
|
Assert.Equal(TimeSpan.FromSeconds(90), JobEta.FromSeconds(90));
|
|
Assert.Equal(TimeSpan.FromSeconds(4), JobEta.Of(8, 2));
|
|
Assert.Null(JobEta.Of(0, 2));
|
|
Assert.Null(JobEta.Of(8, null));
|
|
Assert.Null(JobEta.Of(8, 1e-300));
|
|
}
|
|
|
|
[Test]
|
|
public void ServerTimeLeftBeyondTheMaximumReadsUnknown()
|
|
{
|
|
var dto = new JobDto(Guid.NewGuid(), "render", [], null, "running", "normal", 1, 17, 1e-11, 1e300, null, null, 0, null,
|
|
DateTimeOffset.UtcNow, null, null);
|
|
Assert.Null(JobWire.FromDto(dto)!.Eta);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AJobWhoseCountStallsForHoursStillEndsDone()
|
|
{
|
|
var time = new ManualTime();
|
|
var reported = new List<JobProgressInfo>();
|
|
await using var db = await TitanoDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory(), "jobs.db")), context.Cancellation);
|
|
var handler = new CallbackHandler(JobKind.Proxies, async c =>
|
|
{
|
|
time.Advance(TimeSpan.FromSeconds(600));
|
|
await c.CheckpointAsync("1:0", 1, 17);
|
|
for (var frame = 1; frame <= 400; frame++)
|
|
{
|
|
time.Advance(TimeSpan.FromSeconds(11));
|
|
await c.CheckpointAsync($"1:{frame}", 1, 17);
|
|
}
|
|
});
|
|
await using var engine = new JobEngine(db, [handler], new JobEngineOptions { Workers = 1, WorkerId = "t", Time = time });
|
|
engine.Progress += p =>
|
|
{
|
|
lock (reported) reported.Add(p);
|
|
};
|
|
await engine.StartAsync();
|
|
var job = await engine.EnqueueAsync(JobKind.Proxies, [Guid.NewGuid()]);
|
|
var done = await WaitForAsync(db, job.Id, JobState.Done);
|
|
Assert.Null(done.Eta);
|
|
Assert.Null(done.ItemsPerSecond);
|
|
lock (reported) Assert.Null(reported[^1].Eta);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AProgressSubscriberThatThrowsNeverFailsTheJob()
|
|
{
|
|
await using var db = await TitanoDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory(), "jobs.db")), context.Cancellation);
|
|
var handler = new CallbackHandler(JobKind.Verify, async c =>
|
|
{
|
|
for (var i = 1; i <= 5; i++) await c.CheckpointAsync(i.ToString(System.Globalization.CultureInfo.InvariantCulture), i, 5);
|
|
});
|
|
await using var engine = new JobEngine(db, [handler], new JobEngineOptions { Workers = 1, WorkerId = "t" });
|
|
engine.Progress += _ => throw new InvalidOperationException("broken subscriber");
|
|
await engine.StartAsync();
|
|
var first = await engine.EnqueueAsync(JobKind.Verify, [Guid.NewGuid()]);
|
|
var second = await engine.EnqueueAsync(JobKind.Verify, [Guid.NewGuid()]);
|
|
Assert.Equal(5L, (await WaitForAsync(db, first.Id, JobState.Done)).ProgressDone);
|
|
await WaitForAsync(db, second.Id, JobState.Done);
|
|
}
|
|
|
|
private sealed class CallbackHandler(JobKind kind, Func<JobContext, Task> run) : IJobHandler
|
|
{
|
|
public JobKind Kind => kind;
|
|
|
|
public Task RunAsync(JobContext context) => run(context);
|
|
}
|
|
|
|
private static async Task<Job> WaitForAsync(TitanoDatabase db, Guid id, JobState state)
|
|
{
|
|
var until = DateTime.UtcNow.AddSeconds(15);
|
|
Job? job = null;
|
|
while (DateTime.UtcNow < until)
|
|
{
|
|
job = await db.Jobs.GetAsync(id);
|
|
if (job?.State == state) return job;
|
|
await Task.Delay(20);
|
|
}
|
|
Assert.Fail($"Job {id} is {job?.State}, not {state}");
|
|
return null!;
|
|
}
|
|
}
|