Owner review 2, R10: every timer that queues work becomes a visible schedule, so the server and the desktop need one shared engine to run them. - Migration 0007: schedules table (system rows keyed by system_key) and jobs.schedule_id; Job.ScheduleId, JobDto.ScheduleId, JobRepository HasPendingAsync / ListPendingTargetsAsync / ListByScheduleAsync. - ScheduleRepository: seeding that keeps user edits, reset, compare-and-set claim of a run (one winner across processes), outcomes. - Scheduling: in-house recurrence (every/daily/weekly/monthly, DST gap moves forward, ambiguous time runs once), ScheduleActions resolving scan, verify, thumbnails, proxies, analysis, maintenance, backup, cleanup, duplicates and orphans into archive jobs, IScheduleHost, and the Scheduler loop (catch-up, clock going back, run now, CRUD as API v1 DTOs). - New job kinds Backup (16) and Cleanup (17) with handlers, shared clean-up steps (job history, audit log, trash report that never deletes) and host steps through ArchiveServiceOptions; read-only Duplicates and Orphans report handlers, so the server can run those kinds too. - JobEngine no longer purges history at start: the housekeeping schedule's job-history step does; JobEngine.CanRun and an EnqueueAsync with scheduleId. - Protocol DTOs for schedules; job kind names in en and it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit eb0edd2483a493db7c6945d5b494461cabb2a4ad)
193 lines
11 KiB
C#
193 lines
11 KiB
C#
using Chronos.Core.Model;
|
|
using Chronos.Data.Repositories;
|
|
using Chronos.Data.Scheduling;
|
|
using Chronos.Data.Tests.Infrastructure;
|
|
using Chronos.Protocol;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Data.Tests.Repositories;
|
|
|
|
/// <summary>Schedules on both dialects (owner review 2, R10): round trip, system rows, the compare-and-set claim, due rows.</summary>
|
|
public abstract class ScheduleRepositoryTests(TestContext context) : RepositoryTest(context)
|
|
{
|
|
private static Schedule NewSchedule(string name = "Nightly scan", string? systemKey = null) => new()
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
SystemKey = systemKey,
|
|
Name = name,
|
|
Action = ScheduleActions.Scan,
|
|
Recurrence = "daily:03:00",
|
|
Created = TestData.Now,
|
|
Updated = TestData.Now,
|
|
};
|
|
|
|
private static SystemSchedule System(string key, string recurrence = "every:10m", bool enabled = true) =>
|
|
new(key, "System " + key, ScheduleActions.Verify, ScheduleRecurrence.Parse(recurrence), new ScheduleParametersDto(Percent: 25), enabled, CatchUp: false);
|
|
|
|
[Test]
|
|
public async Task SchedulesRoundTripEveryField()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
var schedule = NewSchedule() with
|
|
{
|
|
SystemKey = "archive-scan",
|
|
Target = "current",
|
|
ParametersJson = """{"force": true}""",
|
|
CatchUp = false,
|
|
Priority = JobPriority.User,
|
|
Enabled = false,
|
|
NextRun = TestData.Now.AddHours(1),
|
|
LastRun = TestData.Now.AddHours(-1),
|
|
LastJobId = Guid.CreateVersion7(),
|
|
LastOutcome = ScheduleOutcome.SkippedPending,
|
|
CreatedBy = Guid.CreateVersion7(),
|
|
Updated = TestData.Now.AddMinutes(5),
|
|
};
|
|
await db.Schedules.InsertAsync(schedule, Ct);
|
|
Assert.Equal(schedule, await db.Schedules.GetAsync(schedule.Id, Ct));
|
|
Assert.Equal(schedule, await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct));
|
|
Assert.Null(await db.Schedules.GetAsync(Guid.CreateVersion7(), Ct));
|
|
|
|
var plain = NewSchedule("Weekly verify");
|
|
await db.Schedules.InsertAsync(plain, Ct);
|
|
Assert.Equal(plain, await db.Schedules.GetAsync(plain.Id, Ct));
|
|
Assert.SequenceEqual([schedule.Id, plain.Id], (await db.Schedules.ListAsync(Ct)).Select(s => s.Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdatesKeepTheRunHistoryAndSystemRowsAreNeverDeleted()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
var user = NewSchedule();
|
|
var system = NewSchedule("Backup", "index-backup");
|
|
await db.Schedules.InsertAsync(user, Ct);
|
|
await db.Schedules.InsertAsync(system, Ct);
|
|
await db.Schedules.RecordOutcomeAsync(user.Id, Guid.CreateVersion7(), ScheduleOutcome.Queued, TestData.Now, Ct);
|
|
var recorded = (await db.Schedules.GetAsync(user.Id, Ct))!;
|
|
|
|
var edited = recorded with { Name = "Renamed", Recurrence = "every:6h", Enabled = false, NextRun = null, Updated = TestData.Now.AddDays(1), LastOutcome = "ignored" };
|
|
Assert.True(await db.Schedules.UpdateAsync(edited, cancellationToken: Ct));
|
|
Assert.Equal(edited with { LastOutcome = recorded.LastOutcome }, await db.Schedules.GetAsync(user.Id, Ct));
|
|
// Without the next run: a run claimed meanwhile stays claimed.
|
|
Assert.True(await db.Schedules.TryAdvanceAsync(system.Id, null, TestData.Now.AddHours(2), Ct));
|
|
Assert.True(await db.Schedules.UpdateAsync(system with { Name = "Backup 2", NextRun = null }, setNextRun: false, Ct));
|
|
Assert.Equal(TestData.Now.AddHours(2), (await db.Schedules.GetAsync(system.Id, Ct))!.NextRun);
|
|
Assert.False(await db.Schedules.UpdateAsync(NewSchedule(), cancellationToken: Ct));
|
|
|
|
Assert.False(await db.Schedules.DeleteAsync(system.Id, Ct));
|
|
Assert.NotNull(await db.Schedules.GetAsync(system.Id, Ct));
|
|
Assert.True(await db.Schedules.DeleteAsync(user.Id, Ct));
|
|
Assert.False(await db.Schedules.DeleteAsync(user.Id, Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SeedingSystemSchedulesKeepsTheUsersEdits()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
Assert.Equal(2, await db.Schedules.EnsureSystemAsync([System("archive-scan"), System("index-backup", enabled: false)], TestData.Now, Ct));
|
|
var seeded = (await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct))!;
|
|
Assert.Equal(("System archive-scan", "verify", "every:10m", false, true, JobPriority.Background), (seeded.Name, seeded.Action, seeded.Recurrence, seeded.CatchUp, seeded.Enabled, seeded.Priority));
|
|
// Stored normalised: the verify defaults fill what the host left out.
|
|
Assert.Equal(new ScheduleParametersDto(OlderThanDays: 30, Percent: 25), ScheduleMapping.Parameters(seeded));
|
|
Assert.Null(seeded.NextRun);
|
|
Assert.False((await db.Schedules.GetBySystemKeyAsync("index-backup", Ct))!.Enabled);
|
|
|
|
await db.Schedules.UpdateAsync(seeded with { Recurrence = "every:30m", Enabled = false }, cancellationToken: Ct);
|
|
// A later start brings other defaults and a new system schedule: the edited row stays as the user left it.
|
|
Assert.Equal(1, await db.Schedules.EnsureSystemAsync([System("archive-scan", "every:5m"), System("index-backup"), System("housekeeping")], TestData.Now, Ct));
|
|
var kept = (await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct))!;
|
|
Assert.Equal((seeded.Id, "every:30m", false), (kept.Id, kept.Recurrence, kept.Enabled));
|
|
Assert.Count(3, await db.Schedules.ListAsync(Ct));
|
|
Assert.Equal(0, await db.Schedules.EnsureSystemAsync([], TestData.Now, Ct));
|
|
|
|
await db.Schedules.TryAdvanceAsync(kept.Id, null, TestData.Now.AddHours(1), Ct);
|
|
Assert.True(await db.Schedules.ResetSystemAsync("archive-scan", System("archive-scan", "every:15m"), TestData.Now.AddDays(1), Ct));
|
|
var reset = (await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct))!;
|
|
Assert.Equal((seeded.Id, "every:15m", true, (DateTimeOffset?)null, TestData.Now.AddDays(1)), (reset.Id, reset.Recurrence, reset.Enabled, reset.NextRun, reset.Updated));
|
|
Assert.False(await db.Schedules.ResetSystemAsync("unknown", System("unknown"), TestData.Now, Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task OnlyOneClaimOfARunWins()
|
|
{
|
|
var db = await OpenChronosAsync(multiConnection: true);
|
|
var schedule = NewSchedule() with { NextRun = TestData.Now };
|
|
await db.Schedules.InsertAsync(schedule, Ct);
|
|
for (var round = 0; round < 5; round++)
|
|
{
|
|
var due = (await db.Schedules.GetAsync(schedule.Id, Ct))!.NextRun;
|
|
var next = due!.Value.AddDays(1);
|
|
var claims = await Task.WhenAll(Enumerable.Range(0, 8).Select(_ => Task.Run(() => db.Schedules.TryAdvanceAsync(schedule.Id, due, next, Ct))));
|
|
Assert.Equal(1, claims.Count(c => c));
|
|
Assert.Equal(next, (await db.Schedules.GetAsync(schedule.Id, Ct))!.NextRun);
|
|
}
|
|
Assert.False(await db.Schedules.TryAdvanceAsync(schedule.Id, TestData.Now, TestData.Now.AddDays(2), Ct), "a stale expectation loses");
|
|
|
|
var unset = NewSchedule("Unset");
|
|
await db.Schedules.InsertAsync(unset, Ct);
|
|
Assert.True(await db.Schedules.TryAdvanceAsync(unset.Id, null, TestData.Now, Ct));
|
|
Assert.False(await db.Schedules.TryAdvanceAsync(unset.Id, null, TestData.Now.AddHours(1), Ct));
|
|
var disabled = NewSchedule("Disabled") with { Enabled = false, NextRun = TestData.Now };
|
|
await db.Schedules.InsertAsync(disabled, Ct);
|
|
Assert.False(await db.Schedules.TryAdvanceAsync(disabled.Id, TestData.Now, TestData.Now.AddHours(1), Ct), "a disabled schedule is never claimed");
|
|
}
|
|
|
|
[Test]
|
|
public async Task DueSchedulesAreEnabledOnesAtOrBeforeNow()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
var late = NewSchedule("Late") with { NextRun = TestData.Now.AddHours(-2) };
|
|
var onTime = NewSchedule("On time") with { NextRun = TestData.Now };
|
|
var future = NewSchedule("Future") with { NextRun = TestData.Now.AddSeconds(1) };
|
|
var disabled = NewSchedule("Disabled") with { NextRun = TestData.Now.AddHours(-3), Enabled = false };
|
|
var unset = NewSchedule("Unset");
|
|
foreach (var s in new[] { onTime, future, disabled, unset, late }) await db.Schedules.InsertAsync(s, Ct);
|
|
Assert.SequenceEqual([late.Id, onTime.Id], (await db.Schedules.ListDueAsync(TestData.Now, Ct)).Select(s => s.Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ARunWithoutAJobKeepsThePreviousJob()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
var schedule = NewSchedule();
|
|
await db.Schedules.InsertAsync(schedule, Ct);
|
|
var job = Guid.CreateVersion7();
|
|
Assert.True(await db.Schedules.RecordOutcomeAsync(schedule.Id, job, ScheduleOutcome.Queued, TestData.Now, Ct));
|
|
Assert.True(await db.Schedules.RecordOutcomeAsync(schedule.Id, null, ScheduleOutcome.SkippedPending, TestData.Now.AddMinutes(10), Ct));
|
|
var read = (await db.Schedules.GetAsync(schedule.Id, Ct))!;
|
|
Assert.Equal((job, ScheduleOutcome.SkippedPending, TestData.Now.AddMinutes(10)), (read.LastJobId!.Value, read.LastOutcome!, read.LastRun!.Value));
|
|
Assert.False(await db.Schedules.RecordOutcomeAsync(Guid.CreateVersion7(), null, ScheduleOutcome.Queued, TestData.Now, Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task VerifyCandidatesAreTheLeastRecentlyVerifiedFirst()
|
|
{
|
|
var db = await OpenChronosAsync();
|
|
var archive = TestData.Archive();
|
|
await db.Archives.UpsertAsync(archive, Ct);
|
|
var never = TestData.Sequence(archive.Id) with { FrameCount = 3 };
|
|
var old = TestData.Sequence(archive.Id) with { FrameCount = 3, VerifiedAt = TestData.Now.AddDays(-60) };
|
|
var recent = TestData.Sequence(archive.Id) with { FrameCount = 3, VerifiedAt = TestData.Now.AddDays(-2) };
|
|
var empty = TestData.Sequence(archive.Id);
|
|
foreach (var s in new[] { recent, empty, old, never }) await db.Sequences.UpsertAsync(s, Ct);
|
|
var other = TestData.Archive("Other");
|
|
await db.Archives.UpsertAsync(other, Ct);
|
|
await db.Sequences.UpsertAsync(TestData.Sequence(other.Id) with { FrameCount = 1 }, Ct);
|
|
|
|
Assert.SequenceEqual([never.Id, old.Id, recent.Id], await db.Sequences.ListVerifyCandidatesAsync(archive.Id, null, 10, Ct));
|
|
Assert.SequenceEqual([never.Id, old.Id], await db.Sequences.ListVerifyCandidatesAsync(archive.Id, TestData.Now.AddDays(-30), 10, Ct));
|
|
Assert.SequenceEqual([never.Id], await db.Sequences.ListVerifyCandidatesAsync(archive.Id, null, 1, Ct));
|
|
}
|
|
}
|
|
|
|
public sealed class SqliteScheduleRepositoryTests(TestContext context) : ScheduleRepositoryTests(context)
|
|
{
|
|
protected override Backend Backend => Backend.SqliteMemory;
|
|
}
|
|
|
|
[RequiresEnvironment(PgTestServer.Variable)]
|
|
public sealed class PostgresScheduleRepositoryTests(TestContext context) : ScheduleRepositoryTests(context)
|
|
{
|
|
protected override Backend Backend => Backend.Postgres;
|
|
}
|