refactor!: rename Titano to Chronos and move CI and releases to Gitea (#6)
CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s
CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s
The owner renamed the product and moved the repository to the self-hosted Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control, and asked for Actions and a first automatic release with the server package and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md). - Chronos everywhere: a byte-exact rename of contents and paths, then a per-language review of the forms the old name's ending had dictated. - Gitea instead of GitHub: the update check, licence, issue and support links read ChronosReleasesUrl; the update check takes the highest stable version, offers a pre-release build its final release and reports a repository it cannot see as a failed check. EULA, security policy and Gitea issue forms live at the repository root. - Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release, nightly image and performance gates in the .NET SDK container with git checkout and the system SQLite. The release cross-compiles the Windows programs, checks their icon, version and DPI manifest, packs installers and zips, publishes the Gitea release and pushes the server image (REGISTRY_TOKEN). Windows-only tests run in an opt-in job on a Windows runner (WINDOWS_RUNNER). - New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the docker-exec script, which Gitea's service containers do not allow; the throw-away server runs without durability) and pe-check. - Timed tests take their budget from TestTiming (CHRONOS_TEST_TIME_FACTOR, 3 on the shared runner; the weekly performance gates keep theirs). BREAKING CHANGE: programs, settings, data folders, file types, environment variables and the Docker image use the new name; nothing is migrated from Titano, which never had a release. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
This commit was merged in pull request #6.
This commit is contained in:
1 parent
c99842cc86
commit
f2b58522b9
1801 files changed
+11804
-10676
No files matched your search
@@ -0,0 +1,318 @@
|
||||
using Chronos.Core.Model;
|
||||
using Chronos.Data.Sync;
|
||||
using Chronos.Protocol;
|
||||
using Chronos.Testing;
|
||||
|
||||
namespace Chronos.Data.Tests.Sync;
|
||||
|
||||
/// <summary>The background agent: event-driven comparisons, retries with backoff, proxies kept offline.</summary>
|
||||
[Category("sync")]
|
||||
public sealed class SyncAgentTests(TestContext context)
|
||||
{
|
||||
/// <summary>How long any wait may take on a loaded runner; every wait ends as soon as what it waits for happened.</summary>
|
||||
private static readonly TimeSpan Deadline = TimeSpan.FromSeconds(30);
|
||||
|
||||
/// <summary>Full comparisons only at start, so anything later comes from events or explicit requests.</summary>
|
||||
private static readonly SyncAgentOptions EventsOnly = new()
|
||||
{
|
||||
RefreshInterval = TimeSpan.FromHours(1),
|
||||
EventDelay = TimeSpan.FromMilliseconds(20),
|
||||
MinBackoff = TimeSpan.FromMilliseconds(20),
|
||||
MaxBackoff = TimeSpan.FromMilliseconds(200),
|
||||
};
|
||||
|
||||
[Test]
|
||||
public async Task ServerEventsBringChangesWithoutAFullComparison()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
var photos = f.NewPhotos(2);
|
||||
var local = await f.LocalAsync("Harbour", photos);
|
||||
var remote = f.Remote.Add("Harbour", photos);
|
||||
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(), null, EventsOnly);
|
||||
agent.Start();
|
||||
await WaitAsync(() => agent.Snapshot is not null, "first comparison");
|
||||
var first = agent.Snapshot!;
|
||||
|
||||
await ComparedAfterAsync(f, () =>
|
||||
{
|
||||
f.Remote.EditSettings(remote.Id, SyncFixture.Window33);
|
||||
f.Remote.Publish(new SequenceChangedEvent(remote.Id, "settings", remote.FramesVersion, remote.SettingsVersion));
|
||||
}, "the comparison of the server's edit");
|
||||
Assert.True(SyncRules.SameSettings(SyncFixture.Window33, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SettingsJson),
|
||||
"the server's edit reached this PC");
|
||||
|
||||
await ComparedAfterAsync(f, () =>
|
||||
{
|
||||
var created = f.Remote.Add("New on the server", f.NewPhotos(1));
|
||||
f.Remote.Publish(new SequenceChangedEvent(created.Id, "created", 1, 1));
|
||||
}, "the comparison of a sequence created on the server");
|
||||
Assert.Contains(await f.Sync.ListAsync(f.Server, f.Ct), e => e.Title == "New on the server");
|
||||
Assert.Same(first, agent.Snapshot);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task FailedComparisonsAreRetriedWithBackoff()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
f.Remote.Add("Harbour", f.NewPhotos(1));
|
||||
f.Remote.FailingListings = 3;
|
||||
var changes = 0;
|
||||
var compared = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(), null, EventsOnly);
|
||||
// The agent stores the snapshot, then clears the last error, then raises Changed: only Changed sees both.
|
||||
agent.Changed += () =>
|
||||
{
|
||||
Interlocked.Increment(ref changes);
|
||||
if (agent.Snapshot is not null) compared.TrySetResult();
|
||||
};
|
||||
agent.Start();
|
||||
|
||||
await SignalAsync(compared.Task, "a comparison after the failures");
|
||||
Assert.Null(agent.LastError);
|
||||
Assert.Equal(0, f.Remote.FailingListings);
|
||||
Assert.GreaterOrEqual(changes, 4);
|
||||
Assert.Equal(1, agent.Snapshot!.ServerSequences);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ATimedOutComparisonIsRecordedAndLiveUpdatesGoOn()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
var photos = f.NewPhotos(1);
|
||||
var local = await f.LocalAsync("Harbour", photos);
|
||||
var remote = f.Remote.Add("Harbour", photos);
|
||||
await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(), null, EventsOnly);
|
||||
agent.Start();
|
||||
await WaitAsync(() => agent.Snapshot is not null, "first comparison");
|
||||
|
||||
await ComparedAfterAsync(f, () =>
|
||||
{
|
||||
f.Remote.TimeoutOnce = remote.Id;
|
||||
f.Remote.Publish(new SequenceChangedEvent(remote.Id, "settings", remote.FramesVersion, remote.SettingsVersion));
|
||||
}, "the comparison that timed out");
|
||||
Assert.NotNull((await f.EntryAsync("Harbour")).Link!.Error);
|
||||
|
||||
await ComparedAfterAsync(f, () =>
|
||||
{
|
||||
f.Remote.EditSettings(remote.Id, SyncFixture.Window33);
|
||||
f.Remote.Publish(new SequenceChangedEvent(remote.Id, "settings", remote.FramesVersion, remote.SettingsVersion));
|
||||
}, "the comparison of a later event");
|
||||
Assert.True(SyncRules.SameSettings(SyncFixture.Window33, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SettingsJson),
|
||||
"a later event still reaches this PC");
|
||||
Assert.Null((await f.EntryAsync("Harbour")).Link!.Error);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task KeepingProxiesOfflineRefreshesTheCachesThisPcOpened()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
var photos = f.NewPhotos(2);
|
||||
var local = await f.LocalAsync("Harbour", photos);
|
||||
await f.Sync.LinkAsync(f.Server, f.Remote.Add("Harbour", photos).Id, local.Id, f.Ct);
|
||||
var opened = f.Remote.Add("Construction cam", f.NewPhotos(2));
|
||||
var never = f.Remote.Add("Never opened", f.NewPhotos(1));
|
||||
var engine = await f.StartEngineAsync();
|
||||
await f.RefreshAsync();
|
||||
var first = await f.Sync.EnqueueDownloadAsync(engine, f.Server, opened.Id, "Construction cam", SyncDownloadMode.Proxies, null);
|
||||
await f.Archive.WaitForAsync(first.Id, JobState.Done);
|
||||
opened.AddFrame(f.NewPhotos(1)[0]);
|
||||
var keep = false;
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(KeepProxiesOffline: keep), engine, EventsOnly);
|
||||
agent.Start();
|
||||
await WaitAsync(() => agent.Snapshot is not null, "first comparison");
|
||||
Assert.True((await f.EntryAsync("Construction cam")).Link!.ProxiesStale);
|
||||
|
||||
keep = true;
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
// The download writes the cache, then the link, and only then ends: until it ends its row shows a transfer.
|
||||
var refresh = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id);
|
||||
await f.Archive.WaitForAsync(refresh.Id, JobState.Done);
|
||||
Assert.Equal(3, Assert.NotNull(f.Sync.OpenRemote(f.Server, opened.Id)).CachedCount, "the stale cache brought up to date");
|
||||
Assert.Null(f.Sync.OpenRemote(f.Server, never.Id));
|
||||
var entries = await f.Sync.ListAsync(f.Server, f.Ct);
|
||||
Assert.Equal(SyncStatus.ProxiesOnly, entries.Single(e => e.Title == "Construction cam").Status);
|
||||
Assert.Equal(SyncStatus.RemoteOnly, entries.Single(e => e.Title == "Never opened").Status);
|
||||
Assert.Equal(SyncStatus.InSync, entries.Single(e => e.Title == "Harbour").Status);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AFailedProxyRefreshWaitsForItsBackoff()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
var opened = f.Remote.Add("Construction cam", f.NewPhotos(2));
|
||||
var engine = await f.StartEngineAsync();
|
||||
await f.RefreshAsync();
|
||||
await f.Archive.WaitForAsync((await f.Sync.EnqueueDownloadAsync(engine, f.Server, opened.Id, "Construction cam", SyncDownloadMode.Proxies, null)).Id,
|
||||
JobState.Done);
|
||||
opened.AddFrame(f.NewPhotos(1)[0]);
|
||||
f.Remote.FailAssets = true;
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(KeepProxiesOffline: true), engine,
|
||||
EventsOnly with { MinBackoff = TimeSpan.FromHours(1), MaxBackoff = TimeSpan.FromHours(2) });
|
||||
agent.Start();
|
||||
await WaitAsync(async () => (await DownloadsAsync(f)).Any(j => j.State == JobState.Failed), "the background refresh failing");
|
||||
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
|
||||
Assert.Equal(2, (await DownloadsAsync(f)).Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ThumbnailsStandingInAreReplacedOnceTheServerOffersTheirProxies()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
// The server cannot decode these originals and waits for their proxies; one frame (missing or damaged) never gets
|
||||
// one, so the sequence's proxy flag never comes.
|
||||
var remote = f.Remote.Add("Fog", f.NewPhotos(3), status: SequenceStatus.ThumbsBuilt);
|
||||
remote.Undecodable = true;
|
||||
var engine = await f.StartEngineAsync();
|
||||
await f.RefreshAsync();
|
||||
var first = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Fog", SyncDownloadMode.Proxies, null);
|
||||
await f.Archive.WaitForAsync(first.Id, JobState.Done);
|
||||
Assert.True(Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id)).Files.All(file => new FileInfo(file!).Length == 64), "thumbnails stand in");
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(KeepProxiesOffline: true), engine, EventsOnly);
|
||||
agent.Start();
|
||||
await WaitAsync(() => agent.Snapshot is not null, "first comparison");
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
Assert.Count(1, await DownloadsAsync(f));
|
||||
|
||||
// Another PC sends the proxies of two frames; the server's proxy pass then records the sequence's state.
|
||||
foreach (var frame in remote.Frames.Take(2)) f.Remote.SentProxies[frame.Id] = frame.Proxy;
|
||||
remote.UpdatedAt = DateTimeOffset.UtcNow.AddSeconds(1);
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
var refresh = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id);
|
||||
await f.Archive.WaitForAsync(refresh.Id, JobState.Done);
|
||||
|
||||
var opened = Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id));
|
||||
Assert.SequenceEqual([remote.Frames[0].Proxy.Length, remote.Frames[1].Proxy.Length, 64], opened.Files.Select(file => (int)new FileInfo(file!).Length));
|
||||
// The frame still waiting keeps its thumbnail; nothing is queued again until the server's sequence changes.
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
Assert.Count(2, await DownloadsAsync(f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task FramesTheServerHadNotDrawnAreFetchedAgainOnceItDid()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
var remote = f.Remote.Add("Construction cam", f.NewPhotos(2));
|
||||
var engine = await f.StartEngineAsync();
|
||||
await f.RefreshAsync();
|
||||
var first = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Construction cam", SyncDownloadMode.Proxies, null);
|
||||
await f.Archive.WaitForAsync(first.Id, JobState.Done);
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(KeepProxiesOffline: true), engine, EventsOnly);
|
||||
agent.Start();
|
||||
await WaitAsync(() => agent.Snapshot is not null, "first comparison");
|
||||
|
||||
// A photo reaches the server, whose proxy flag stays set until its next proxy pass draws the photo: the refresh
|
||||
// that follows the upload caches nothing for it.
|
||||
var added = remote.AddFrame(f.NewPhotos(1)[0]);
|
||||
f.Remote.Undrawn.UnionWith([(added.Id, "proxy"), (added.Id, "thumb")]);
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
var refresh = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id);
|
||||
await f.Archive.WaitForAsync(refresh.Id, JobState.Done);
|
||||
Assert.Null(Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id)).Files[2]);
|
||||
Assert.True((await f.EntryAsync("Construction cam")).Link!.ProxiesStale);
|
||||
// Nothing is fetched again while the server's sequence stands still.
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
Assert.Count(2, await DownloadsAsync(f));
|
||||
|
||||
// The pass draws the photo and records the sequence's state.
|
||||
f.Remote.Undrawn.Clear();
|
||||
remote.UpdatedAt = DateTimeOffset.UtcNow.AddSeconds(1);
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
var drawn = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id && j.Id != refresh.Id);
|
||||
await f.Archive.WaitForAsync(drawn.Id, JobState.Done);
|
||||
var opened = Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id));
|
||||
Assert.SequenceEqual(remote.Frames.Select(r => (long)r.Proxy.Length), opened.Files.Select(file => new FileInfo(file!).Length));
|
||||
Assert.False((await f.EntryAsync("Construction cam")).Link!.ProxiesStale);
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
Assert.Count(3, await DownloadsAsync(f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AStandInDownloadThatFailedIsQueuedAgainAfterItsBackoff()
|
||||
{
|
||||
await using var f = await SyncFixture.CreateAsync(context);
|
||||
var remote = f.Remote.Add("Fog", f.NewPhotos(3), status: SequenceStatus.ThumbsBuilt);
|
||||
remote.Undecodable = true;
|
||||
var engine = await f.StartEngineAsync();
|
||||
await f.RefreshAsync();
|
||||
var first = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Fog", SyncDownloadMode.Proxies, null);
|
||||
await f.Archive.WaitForAsync(first.Id, JobState.Done);
|
||||
await using var agent = new SyncAgent(f.Sync, f.Remote, () => new SyncPolicy(KeepProxiesOffline: true), engine, EventsOnly);
|
||||
agent.Start();
|
||||
await WaitAsync(() => agent.Snapshot is not null, "first comparison");
|
||||
|
||||
// Two frames' proxies reach the server, but their download fails (the server restarts meanwhile).
|
||||
foreach (var frame in remote.Frames.Take(2)) f.Remote.SentProxies[frame.Id] = frame.Proxy;
|
||||
remote.UpdatedAt = DateTimeOffset.UtcNow.AddSeconds(1);
|
||||
f.Remote.FailAssets = true;
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
var failed = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id);
|
||||
await f.Archive.WaitForAsync(failed.Id, JobState.Failed);
|
||||
|
||||
// The server's sequence does not change again: once the backoff has passed, the download is queued anyway.
|
||||
f.Remote.FailAssets = false;
|
||||
await WaitAsync(async () =>
|
||||
{
|
||||
await agent.RefreshAsync(f.Ct);
|
||||
return (await DownloadsAsync(f)).Count == 3;
|
||||
}, "the download queued again");
|
||||
var retry = Assert.Contains(await DownloadsAsync(f), j => j.Id != first.Id && j.Id != failed.Id);
|
||||
await f.Archive.WaitForAsync(retry.Id, JobState.Done);
|
||||
var opened = Assert.NotNull(f.Sync.OpenRemote(f.Server, remote.Id));
|
||||
Assert.SequenceEqual([remote.Frames[0].Proxy.Length, remote.Frames[1].Proxy.Length, 64], opened.Files.Select(file => (int)new FileInfo(file!).Length));
|
||||
}
|
||||
|
||||
private static async Task<IReadOnlyList<Job>> DownloadsAsync(SyncFixture f) =>
|
||||
(await f.Db.Jobs.ListAsync(null, JobKind.Download, 100, null, f.Ct)).Items;
|
||||
|
||||
/// <summary>
|
||||
/// Runs <paramref name="cause"/> and returns once the comparison it starts has finished. The engine raises
|
||||
/// <see cref="SyncService.Changed"/> after a comparison stored every link and state, the moment the Server screen
|
||||
/// reloads; a poll could instead see the local copy updated before the link that goes with it is stored. No other
|
||||
/// comparison may be running.
|
||||
/// </summary>
|
||||
private async Task ComparedAfterAsync(SyncFixture f, Action cause, string what)
|
||||
{
|
||||
// Continuations run on the pool, not inside the agent loop that raises Changed and that the test later stops.
|
||||
var compared = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
Action<string> onChanged = _ => compared.TrySetResult();
|
||||
f.Sync.Changed += onChanged;
|
||||
try
|
||||
{
|
||||
cause();
|
||||
await SignalAsync(compared.Task, what);
|
||||
}
|
||||
finally
|
||||
{
|
||||
f.Sync.Changed -= onChanged;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task SignalAsync(Task signal, string what)
|
||||
{
|
||||
try
|
||||
{
|
||||
await signal.WaitAsync(Deadline, context.Cancellation);
|
||||
}
|
||||
catch (TimeoutException)
|
||||
{
|
||||
Assert.Fail("Timed out waiting for " + what);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task WaitAsync(Func<bool> condition, string what) => await WaitAsync(() => Task.FromResult(condition()), what);
|
||||
|
||||
private async Task WaitAsync(Func<Task<bool>> condition, string what)
|
||||
{
|
||||
var until = DateTime.UtcNow + Deadline;
|
||||
while (!await condition())
|
||||
{
|
||||
if (DateTime.UtcNow > until) Assert.Fail("Timed out waiting for " + what);
|
||||
await Task.Delay(20, context.Cancellation);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user