CI / Build and test (push) Successful in 13m44s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 16s
Release / Build, test and publish (push) Successful in 26m34s
CI / PostgreSQL 16 integration (push) Failing after 17m36s
CI / PostgreSQL 17 integration (push) Failing after 15m36s
CI / Docker image (push) Successful in 1m12s
Release / Server image (push) Failing after 15s
The same time-lapse on a server and on this PC under different ids, or twice on this PC, is recognised, compared and settled as the owner asked in owner review 6. Matches are found after each sync refresh, through the server's new photo lookup, and after the jobs that change photos. The default is to ask every time. Server › Matches offers: - Keep apart, which is remembered; - Link only and Unlink; - the Compare dialog: photos, details line by line, projects and the plan. Integrate completes both sides. Photos default to Union, projects are copied across, and a losing version goes to the trash only after a hash check. Afterwards new photos move by themselves, and deletions wait for the user. A merge of two local sequences verifies every photo before the other sequence goes to its archive's trash. Upload all local skips suspected matches and flags them. Migration 0012 adds the found_copies and copy_probes tables. Jobs 25 (Integrate) and 26 (MergeSequences) are new, and so are the server capabilities photo-lookup and upload-into. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
148 lines
7.7 KiB
C#
148 lines
7.7 KiB
C#
using Chronos.Core.Model;
|
|
using Chronos.Data.Archiving;
|
|
using Chronos.Data.Jobs;
|
|
using Chronos.Data.Sync;
|
|
using Chronos.Data.Tests.Archiving;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Data.Tests.Sync;
|
|
|
|
/// <summary>A local archive and index, the sync engine over them and an in-memory server.</summary>
|
|
internal sealed class SyncFixture : IAsyncDisposable
|
|
{
|
|
public const string Window41 = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":41}}}""";
|
|
public const string Window33 = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":33}}}""";
|
|
|
|
private readonly List<IAsyncDisposable> _owned = [];
|
|
private int _seed;
|
|
|
|
private SyncFixture(ArchiveFixture archive, SyncService sync)
|
|
{
|
|
Archive = archive;
|
|
Sync = sync;
|
|
_owned.Add(archive);
|
|
}
|
|
|
|
public ArchiveFixture Archive { get; }
|
|
public SyncService Sync { get; }
|
|
public FakeSyncRemote Remote { get; } = new();
|
|
public ChronosDatabase Db => Archive.Db;
|
|
public string Server => Remote.Server;
|
|
public CancellationToken Ct => Archive.Ct;
|
|
|
|
/// <param name="identity">The servers known by id and the address keys they were reached under (default: none).</param>
|
|
public static async Task<SyncFixture> CreateAsync(TestContext context, Func<ServerIdentity>? identity = null)
|
|
{
|
|
var archive = await ArchiveFixture.CreateAsync(context);
|
|
var sync = new SyncService(archive.Db, archive.Service, new SyncOptions
|
|
{
|
|
Archive = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) },
|
|
ProxyCacheDirectory = context.CreateTempDirectory("proxies"),
|
|
Identity = identity,
|
|
});
|
|
return new SyncFixture(archive, sync);
|
|
}
|
|
|
|
public Task<SyncSnapshot> RefreshAsync(SyncPolicy? policy = null) => Sync.RefreshAsync(Remote, policy ?? new SyncPolicy(), Ct);
|
|
|
|
public async Task<SyncEntry> EntryAsync(string title) =>
|
|
(await Sync.ListAsync(Server, Ct)).Single(e => e.Title == title);
|
|
|
|
/// <summary>Distinct photos (the same bytes on both sides make the same original).</summary>
|
|
public List<byte[]> NewPhotos(int count)
|
|
{
|
|
var photos = new List<byte[]>(count);
|
|
for (var i = 0; i < count; i++, _seed++) photos.Add(Photos.Jpeg(ArchiveFixture.Start.AddSeconds(10 * _seed), 1000 + _seed));
|
|
return photos;
|
|
}
|
|
|
|
/// <summary>
|
|
/// A local sequence made through the archive ingest (hashed frames, a real sidecar), each frame captured 10 s after the
|
|
/// one before from <see cref="ArchiveFixture.Start"/>, or at <paramref name="capturedAt"/>.
|
|
/// </summary>
|
|
public async Task<Sequence> LocalAsync(string title, IReadOnlyList<byte[]> originals, string? settingsJson = null, IReadOnlyList<DateTime>? capturedAt = null)
|
|
{
|
|
Guid? id = null;
|
|
var staging = Path.Combine(Archive.Paths.StagingDirectory, "test");
|
|
Directory.CreateDirectory(staging);
|
|
for (var i = 0; i < originals.Count; i++)
|
|
{
|
|
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.part");
|
|
await File.WriteAllBytesAsync(path, originals[i], Ct);
|
|
var sha = Convert.ToHexStringLower(System.Security.Cryptography.SHA256.HashData(originals[i]));
|
|
var result = await Archive.Service.Ingest.CommitAsync(new IngestRequest(Archive.Archive.Id, id, id is null ? title : null, null, path,
|
|
$"IMG_{i + 1:0000}.JPG", originals[i].Length, sha, capturedAt?[i] ?? ArchiveFixture.Start.AddSeconds(10 * i), null), Ct);
|
|
id = result.SequenceId;
|
|
}
|
|
var sequence = (await Db.Sequences.GetAsync(id!.Value, Ct))!;
|
|
if (settingsJson is not null) sequence = await EditLocalSettingsAsync(sequence.Id, settingsJson);
|
|
return sequence;
|
|
}
|
|
|
|
/// <summary>Files one more original into a local sequence through the archive ingest (an earlier photo lands before the others).</summary>
|
|
public async Task AddLocalAsync(Guid sequenceId, byte[] original)
|
|
{
|
|
var staging = Path.Combine(Archive.Paths.StagingDirectory, "test");
|
|
Directory.CreateDirectory(staging);
|
|
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.part");
|
|
await File.WriteAllBytesAsync(path, original, Ct);
|
|
var sha = Convert.ToHexStringLower(System.Security.Cryptography.SHA256.HashData(original));
|
|
await Archive.Service.Ingest.CommitAsync(new IngestRequest(Archive.Archive.Id, sequenceId, null, null, path, $"IMG_{sha[..8]}.JPG", original.Length, sha,
|
|
null, null), Ct);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces the file of the local frame at <paramref name="index"/> with <paramref name="converted"/>, as a conversion's
|
|
/// Replace does on this PC (owner review 2, R7): the same frame, a tombstone naming the new content.
|
|
/// </summary>
|
|
public async Task ReplaceLocalAsync(Guid sequenceId, int index, byte[] converted)
|
|
{
|
|
var sequence = (await Db.Sequences.GetAsync(sequenceId, Ct))!;
|
|
var frame = Chronos.Core.Archiving.ManifestStore.ReadSequence(Archive.Paths.Sequence(sequence.Folder).ManifestPath).Frames[index];
|
|
var staging = Path.Combine(Archive.Paths.StagingDirectory, "convert-test");
|
|
Directory.CreateDirectory(staging);
|
|
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.jpeg");
|
|
await File.WriteAllBytesAsync(path, converted, Ct);
|
|
var sha = Convert.ToHexStringLower(System.Security.Cryptography.SHA256.HashData(converted));
|
|
var swap = new FrameSwap(frame.Id, Archive.Paths.ToRelative(path), [], (current, _) => Path.ChangeExtension(current.File, ".jpeg"), current => current with
|
|
{
|
|
Sha256 = sha,
|
|
Size = converted.Length,
|
|
Source = new Chronos.Core.Archiving.FrameSource { Sha256 = current.Sha256, Format = current.Format, File = current.File, Size = current.Size },
|
|
});
|
|
Assert.NotNull(await Archive.Service.FrameTrash.ReplaceAsync(Archive.Archive, sequenceId, null, [swap], null, null, null, null, Ct));
|
|
}
|
|
|
|
/// <summary>An edit on this PC, as the editor makes it (project file and index, settings version + 1).</summary>
|
|
public async Task<Sequence> EditLocalSettingsAsync(Guid id, string settingsJson)
|
|
{
|
|
var sequence = (await Db.Sequences.GetAsync(id, Ct))!;
|
|
var folder = Archive.Paths.Sequence(sequence.Folder);
|
|
await File.WriteAllTextAsync(folder.ProjectPath, settingsJson, Ct);
|
|
var result = await Db.Sequences.EditAsync(id, new Chronos.Data.Repositories.SequenceEdit { SettingsJson = settingsJson }, sequence.SettingsVersion, Ct);
|
|
return result.Sequence!;
|
|
}
|
|
|
|
/// <summary>A started engine with the archive and sync handlers; jobs reach the server through <paramref name="connector"/> (the fake by default).</summary>
|
|
public async Task<JobEngine> StartEngineAsync(ISyncConnector? connector = null)
|
|
{
|
|
var engine = new JobEngine(Db, [.. Archive.Service.CreateJobHandlers(), .. Sync.CreateJobHandlers(connector ?? new Connector(Remote))],
|
|
new JobEngineOptions { Workers = 2, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
|
|
_owned.Insert(0, engine);
|
|
await engine.StartAsync(Ct);
|
|
return engine;
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
foreach (var owned in _owned) await owned.DisposeAsync();
|
|
}
|
|
|
|
/// <summary>Hands out <paramref name="remote"/> for its own server; null for any other, or always when <paramref name="remote"/> is null.</summary>
|
|
public sealed class Connector(ISyncRemote? remote) : ISyncConnector
|
|
{
|
|
public ValueTask<ISyncRemote?> ConnectAsync(string server, CancellationToken cancellationToken) =>
|
|
ValueTask.FromResult(remote is not null && remote.Server == server ? remote : null);
|
|
}
|
|
}
|