Positions crossing copies could still land on other photos in three windows: - A push translated a row snapshot's settings against local frames listed later, after a manifest round trip: an import of earlier photos meanwhile moved the row's positions, and the server stored shifted exclusions, hero and keyframes. SyncPositions now reads this copy's row with its frames as one state (frames listed between two reads of the row at the same frames version) and translates that row's settings, at the settings version being pushed. The conflict comparison and ApplyLocallyAsync compare against that same row. When the copy was edited since, or its frames keep changing, nothing is sent or applied and the next comparison translates again (Keep mine reports a changed conflict; PushAll sends an edit saved meanwhile). - The manifest read the sequence row, then paged its frames: an upload committed in between paired settings of one frames version with frames of the next. The server now lists them again while the frames version moved during the listing, then inside a transaction holding the row (on SQLite, on that transaction's connection, so no second pooled connection waits behind the write lock). The client also refuses to translate against a manifest whose frames are not each listed once at 0..n-1. - Server capture times were fetched only when something was unhashed, so the same parked photo was written with or without capturedAt. They are now fetched whenever the two frame lists differ; an equal project then compares equal, and an entry can be placed on a photo that arrives unhashed. CompareOriginals counted unhashed server frames one-to-one against this PC's photos, so two copies of one photo in a folder the server adopted left Download on offer forever while the download fetched nothing. A photo on either side is now there when any photo of the other side matches it, as downloads and uploads find them. Paged frame listings keep each frame once (an insertion between pages lists one again). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
121 lines
5.8 KiB
C#
121 lines
5.8 KiB
C#
using Titano.Core.Model;
|
|
using Titano.Data.Archiving;
|
|
using Titano.Data.Jobs;
|
|
using Titano.Data.Sync;
|
|
using Titano.Data.Tests.Archiving;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.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 TitanoDatabase Db => Archive.Db;
|
|
public string Server => Remote.Server;
|
|
public CancellationToken Ct => Archive.Ct;
|
|
|
|
public static async Task<SyncFixture> CreateAsync(TestContext context)
|
|
{
|
|
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"),
|
|
});
|
|
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).</summary>
|
|
public async Task<Sequence> LocalAsync(string title, IReadOnlyList<byte[]> originals, string? settingsJson = 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, 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>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 Titano.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);
|
|
}
|
|
}
|