From cdd29f8e8434dd6c818299f6f10390eb61caccbb Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Wed, 4 Nov 2026 12:54:45 +0100 Subject: [PATCH] fix(workspace): follow server renames, never keep a thumbnail as a proxy on resume A pull and the server's renamed event write the home's name into the copy, so a rename made on the server reaches the workspace. A copy from a server marks a thumbnail taken for a missing proxy before moving it into place; a resumed run reads the marker and fetches the proxy the server has now, instead of recording the thumbnail as one. Tests also cover the frames stamp (frames read only when it moves), an older server's copy refusal and a viewer's 403 push. Co-Authored-By: Claude Opus 5.5 --- src/Chronos.App/Workspace/WorkspaceHost.cs | 25 ++- .../Workspaces/WorkspaceCopyJobHandler.cs | 18 +- src/Chronos.Data/Workspaces/WorkspaceSync.cs | 31 ++++ .../Workspaces/ServerWorkspaceTests.cs | 160 +++++++++++++++++- 4 files changed, 227 insertions(+), 7 deletions(-) diff --git a/src/Chronos.App/Workspace/WorkspaceHost.cs b/src/Chronos.App/Workspace/WorkspaceHost.cs index 4739dddb..f45ffae6 100644 --- a/src/Chronos.App/Workspace/WorkspaceHost.cs +++ b/src/Chronos.App/Workspace/WorkspaceHost.cs @@ -249,17 +249,38 @@ public sealed class WorkspaceHost return; } // The folder is named by the project's id: only a project this workspace holds, of that server and sequence, is told. + BundleHome home; try { - if (!IsAvailable || Store.Find(change.ProjectId)?.ReadBundle().Workspace?.Home is not { IsArchive: false } home || home.SequenceId != change.SequenceId - || !string.Equals(home.Server, server, StringComparison.OrdinalIgnoreCase)) + if (!IsAvailable || Store.Find(change.ProjectId)?.ReadBundle().Workspace?.Home is not { IsArchive: false } held || held.SequenceId != change.SequenceId + || !string.Equals(held.Server, server, StringComparison.OrdinalIgnoreCase)) return; + home = held; } catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException) { Log.Info("workspace", $"A change of project {change.ProjectId} on {server} could not be matched: {ex.Message}"); return; } + if (change.Change != ProjectChanges.Renamed) + { + HomeChanged?.Invoke(new WorkspaceHomeChange(server, change.ProjectId, change.Change)); + return; + } + // A rename at the server is written to the copy here before it is told, so the state read again shows the new name. + _ = FollowNameThenTellAsync(server, home, change); + } + + private async Task FollowNameThenTellAsync(string server, BundleHome home, ProjectChangedEvent change) + { + try + { + if (HomeOf(home) is { } reached) await Sync.FollowNameAsync(change.ProjectId, reached).ConfigureAwait(false); + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + Log.Info("workspace", $"The new name of project {change.ProjectId} on {server} could not be followed: {ex.Message}"); + } HomeChanged?.Invoke(new WorkspaceHomeChange(server, change.ProjectId, change.Change)); } diff --git a/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs index f8c9de97..1cf3f769 100644 --- a/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs +++ b/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs @@ -115,6 +115,9 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService private static readonly TimeSpan LockWait = TimeSpan.FromMinutes(2); private static readonly TimeSpan CheckpointEvery = TimeSpan.FromSeconds(5); + /// Beside a server's thumbnail downloaded for a frame until the copy commits: what it is, should the run stop first. + internal const string StandInSuffix = ".thumb"; + /// Bytes left free on the workspace's drive besides the copy, as a download keeps (). internal const long SpaceReserve = 512L << 20; @@ -540,11 +543,13 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService { var keptSha = await ContentHash.Sha256Async(target, cancellationToken: cancellationToken).ConfigureAwait(false); // The editor's file of another photo of the frame (a conversion since) was left by an earlier copy, not this run. - if (!listed || keptSha != current!.FileSha256 || SamePhoto(current, frame)) + // A run stopped before it recorded the file's kind left a marker beside a thumbnail it took for a missing proxy. + var keptKind = KindOf(fetched, keptSha) ?? KindOf(current, keptSha) + ?? (File.Exists(StandInMarker(target)) ? ProxyCache.Thumb : offered.FirstOrDefault() ?? ProxyCache.Proxy); + if ((!listed || keptSha != current!.FileSha256 || SamePhoto(current, frame)) && !(keptKind == ProxyCache.Thumb && offered.Contains(ProxyCache.Proxy))) { tally.Keep(); - return WorkspaceFrame.Of(frame, name, keptSha, new FileInfo(target).Length, - KindOf(fetched, keptSha) ?? KindOf(current, keptSha) ?? offered.FirstOrDefault() ?? ProxyCache.Proxy); + return WorkspaceFrame.Of(frame, name, keptSha, new FileInfo(target).Length, keptKind); } } // What this run downloaded in an earlier pass, then the editor's file of the same photo, unless a thumbnail stands in @@ -602,6 +607,9 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService file = WorkspaceProject.ProxyName(frame.Id, received); path = project.MediaFile(file); } + // The kind is known on disk before the file is: a run stopped after the move resumes with it. + if (kind == ProxyCache.Thumb) File.WriteAllBytes(StandInMarker(path), []); + else if (File.Exists(StandInMarker(path))) File.Delete(StandInMarker(path)); File.Move(part, path, overwrite: true); if (await ContentHash.Sha256Async(path, cancellationToken: cancellationToken).ConfigureAwait(false) == received) { @@ -612,6 +620,8 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService if (attempt == 2) throw new IOException(Loc.L("Errors.Workspace.CopyMismatch", path)); } + static string StandInMarker(string file) => file + StandInSuffix; + static string? KindOf(WorkspaceFrame? entry, string sha) => entry is { FileSha256: { } held } && string.Equals(held, sha, StringComparison.OrdinalIgnoreCase) ? entry.FileKind ?? ProxyCache.Proxy : null; } @@ -867,6 +877,8 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService { if (!listed.Contains(Path.GetFileName(file))) TryDelete(file); } + // The media committed record each file's kind: the markers of a run are done with. + foreach (var marker in Directory.EnumerateFiles(project.ProxiesDirectory, "*" + StandInSuffix)) TryDelete(marker); } private static void TryDelete(string file) diff --git a/src/Chronos.Data/Workspaces/WorkspaceSync.cs b/src/Chronos.Data/Workspaces/WorkspaceSync.cs index 24a446ca..9819427d 100644 --- a/src/Chronos.Data/Workspaces/WorkspaceSync.cs +++ b/src/Chronos.Data/Workspaces/WorkspaceSync.cs @@ -370,10 +370,41 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName) return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], pulled); } if (project.ReadSync().Conflict is null) PruneReplaced(project); + await FollowNameLockedAsync(project, home, cancellationToken).ConfigureAwait(false); return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], pulled); } } + /// + /// The project's name (and whether it is Main) as its home has them now, written to the copy here: a rename made at the + /// home reaches the workspace. True when the copy's name changed; false when it already matched, or the home could not + /// say (unreachable, or no longer listing the project): the next pull or status tells those. + /// + public async Task FollowNameAsync(Guid projectId, IProjectHome home, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(home); + var project = Existing(projectId); + using (await project.LockAsync(LockWait, cancellationToken).ConfigureAwait(false)) + return await FollowNameLockedAsync(project, home, cancellationToken).ConfigureAwait(false); + } + + private static async Task FollowNameLockedAsync(WorkspaceProject project, IProjectHome home, CancellationToken cancellationToken) + { + SequenceProject? listed; + try + { + listed = (await home.ListAsync(cancellationToken).ConfigureAwait(false)).FirstOrDefault(p => p.Id == project.ProjectId); + } + catch (Exception ex) when (ex is HomeUnavailableException or ProjectException) + { + return false; + } + var bundle = project.ReadBundle(); + if (listed is null || bundle.Workspace is not { } workspace || (workspace.Name == listed.Name && workspace.IsMain == listed.IsMain)) return false; + project.WriteBundle(bundle with { Workspace = workspace with { Name = listed.Name, IsMain = listed.IsMain } }); + return true; + } + /// /// Settles the conflict a pull or push stopped at, as the user was shown it (, else the one /// recorded). keeps this workspace's values (but for the members in diff --git a/tests/Chronos.Server.Tests/Workspaces/ServerWorkspaceTests.cs b/tests/Chronos.Server.Tests/Workspaces/ServerWorkspaceTests.cs index d3ffcbfb..d53335c8 100644 --- a/tests/Chronos.Server.Tests/Workspaces/ServerWorkspaceTests.cs +++ b/tests/Chronos.Server.Tests/Workspaces/ServerWorkspaceTests.cs @@ -235,6 +235,132 @@ public sealed class ServerWorkspaceTests(TestContext context) Assert.SequenceEqual([1], (await home.HistoryAsync(vertical.Id, null, 10, context.Cancellation)).Select(v => v.Number)); } + [Test] + public async Task AResumedCopyNeverRecordsAThumbnailAsAProxy() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (_, _, token) = await server.UserAsync("alberto", "editor"); + var sid = await SequenceAsync(server, token, 3); + await using var a = await WorkspaceClient.StartAsync(context, server, token, "PC-A"); + var home = a.Home(sid); + var main = (await home.ListAsync(context.Cancellation)).Single(); + await a.CheckoutAsync(home, main.Id); + var project = a.Store.Find(main.Id)!; + var media = Assert.NotNull(project.ReadMedia()); + var manifest = await a.Client.GetManifestAsync(sid, context.Cancellation); + var frame = manifest.Frames.OrderBy(f => f.Index).First(f => f.HasProxy); + var entry = media.Frames.Single(f => f.Id == frame.Id); + Assert.Equal("proxy", entry.FileKind); + Assert.Empty(Directory.EnumerateFiles(project.ProxiesDirectory, "*.thumb")); + + // A run stopped after it took the thumbnail for a proxy the server had not made yet, which it has now: the resumed + // run (every frame done by its checkpoint) downloads the proxy instead of keeping the thumbnail as one. + var file = project.MediaFile(entry.File!); + await using (var thumb = File.Create(file)) + await a.Client.DownloadFrameAsync(frame.Id, "thumb", thumb, null, context.Cancellation); + File.WriteAllBytes(file + ".thumb", []); + File.Delete(project.MediaIndexPath); + await a.CopyAsync(sid, main.Id, $"copy:{manifest.Frames.Count}:{manifest.FramesVersion}"); + var resumed = Assert.NotNull(project.ReadMedia()).Frames.Single(f => f.Id == frame.Id); + Assert.Equal(("proxy", entry.FileSha256), (resumed.FileKind, resumed.FileSha256)); + Assert.Equal(entry.FileSha256, Sha(project.MediaFile(resumed.File!))); + Assert.Empty(Directory.EnumerateFiles(project.ProxiesDirectory, "*.thumb")); + } + + [Test] + public async Task AViewersPushIsRefusedForGoodAndItsVersionWaits() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (_, _, token) = await server.UserAsync("alberto", "editor"); + var (_, _, viewing) = await server.UserAsync("vera", "viewer"); + var sid = await SequenceAsync(server, token, 2); + await using var v = await WorkspaceClient.StartAsync(context, server, viewing, "PC-V"); + var home = v.Home(sid); + var main = (await home.ListAsync(context.Cancellation)).Single(); + await v.CheckoutAsync(home, main.Id); + await v.EditAsync(main.Id, s => s with { HeroFrame = 1 }); + Assert.NotNull(await v.Sync.CommitAsync(main.Id, cancellationToken: context.Cancellation)); + + // 403: a refusal, never "out of reach" (nothing to wait out); the version stays here, the server's head as it was. + var refused = await Assert.ThrowsAsync(() => v.Sync.PushAsync(main.Id, home, context.Cancellation)); + Assert.Equal(System.Net.HttpStatusCode.Forbidden, refused.Status); + Assert.False(ServerProjectHome.IsUnavailable(refused)); + Assert.Equal(1, v.Sync.Unpushed(main.Id).Count); + Assert.Equal(1, (await home.HeadAsync(main.Id, context.Cancellation)).Number); + Assert.Equal(WorkspaceState.Ahead, (await v.Sync.StatusAsync(main.Id, home, context.Cancellation)).State); + } + + [Test] + public async Task TheStatusReadsTheServersFramesAgainOnlyWhenTheirStampMoved() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (_, _, token) = await server.UserAsync("alberto", "editor"); + var sid = await SequenceAsync(server, token, 2); + var tap = new Tap(); + await using var a = await WorkspaceClient.StartAsync(context, server, token, "PC-A", tap); + var home = a.Home(sid); + var main = (await home.ListAsync(context.Cancellation)).Single(); + await a.CheckoutAsync(home, main.Id); + + // The frames are downloaded once; asked again with nothing changed, only their stamp is. + await a.Sync.StatusAsync(main.Id, home, context.Cancellation); + var read = tap.Frames; + Assert.True(read > 0, "the frames were read"); + await a.Sync.StatusAsync(main.Id, home, context.Cancellation); + await a.Sync.StatusAsync(main.Id, home, context.Cancellation); + Assert.Equal(read, tap.Frames); + Assert.True(tap.Stamps >= 3, "the stamp was asked each time"); + + // A photo more on the server moves the stamp: the frames are read again, and the copy reads as outdated. + await Uploads.UploadAsync(server.NewClient(token), Photo(42), "IMG_0042.JPG", sid, capturedAt: new DateTime(2026, 9, 28, 18, 30, 11)); + await JobsDoneAsync(server); + var status = await a.Sync.StatusAsync(main.Id, home, context.Cancellation); + Assert.Equal(read + 1, tap.Frames); + Assert.True(status.MediaOutdated, "the server's frames moved"); + } + + [Test] + public async Task ACopyFromAServerThatKeepsNoProjectsIsRefusedSayingSo() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (_, _, token) = await server.UserAsync("alberto", "editor"); + var sid = await SequenceAsync(server, token, 2); + var tap = new Tap(); + await using var a = await WorkspaceClient.StartAsync(context, server, token, "PC-A", tap); + var home = a.Home(sid); + var main = (await home.ListAsync(context.Cancellation)).Single(); + await a.Sync.CheckoutAsync(home, main.Id, cancellationToken: context.Cancellation); + + // An older server's API knows no such call (404 naming nothing): the copy fails saying the server keeps no projects. + tap.OlderServer = true; + var job = await a.EnqueueAsync(WorkspaceJobs.CopyFromServer(sid, Title, a.Server, a.Store.Root, main.Id)); + Assert.Equal(Loc.L("Errors.Workspace.NoProjects"), (await a.WaitAsync(job.Id, JobState.Failed)).Error); + Assert.Null(a.Store.Find(main.Id)!.ReadMedia()); + } + + [Test] + public async Task ARenameOnTheServerReachesTheCopyAtItsNextPull() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (_, _, token) = await server.UserAsync("alberto", "editor"); + var sid = await SequenceAsync(server, token, 2); + await using var a = await WorkspaceClient.StartAsync(context, server, token, "PC-A"); + var home = a.Home(sid); + var vertical = await home.CreateAsync("Vertical", null, null, context.Cancellation); + await a.CheckoutAsync(home, vertical.Id); + + // Renamed from another program: the copy here takes the name at its next pull, and says so when asked alone. + using var other = new ChronosClient(server.HttpBase, new CertificatePinning([]), "PC-B") { Token = token }; + var otherHome = new ServerProjectHome(other, sid); + await otherHome.RenameAsync(vertical.Id, "Square", context.Cancellation); + await a.Sync.PullAsync(vertical.Id, home, context.Cancellation); + Assert.Equal("Square", a.Bundle(vertical.Id).Workspace!.Name); + await otherHome.RenameAsync(vertical.Id, "Wide", context.Cancellation); + Assert.True(await a.Sync.FollowNameAsync(vertical.Id, home, context.Cancellation)); + Assert.False(await a.Sync.FollowNameAsync(vertical.Id, home, context.Cancellation)); + Assert.Equal("Wide", a.Bundle(vertical.Id).Workspace!.Name); + } + [Test] public async Task AServerOutOfReachLeavesTheProjectOfflineAndItsWorkWaits() { @@ -315,6 +441,36 @@ public sealed class ServerWorkspaceTests(TestContext context) return JpegEncoder.Encode(pixels, width, height, 3, new JpegEncodeOptions { Quality = 90 }); } + /// The desktop's requests as they go: the frames and stamps read, and an older server's answer to the frames. + private sealed class Tap() : DelegatingHandler(new HttpClientHandler()) + { + private int _frames; + private int _stamps; + + public int Frames => Volatile.Read(ref _frames); + + public int Stamps => Volatile.Read(ref _stamps); + + /// The frames answer 404 naming nothing, as the API's fallback of a server without the projects does. + public bool OlderServer { get; set; } + + protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + var path = request.RequestUri!.AbsolutePath; + if (path.EndsWith("/projects/frames/stamp", StringComparison.Ordinal)) Interlocked.Increment(ref _stamps); + if (path.EndsWith("/projects/frames", StringComparison.Ordinal)) + { + Interlocked.Increment(ref _frames); + if (OlderServer) + return Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.NotFound) + { + Content = new StringContent("""{"code":"not_found","message":"Not found"}""", System.Text.Encoding.UTF8, "application/json"), + }); + } + return base.SendAsync(request, cancellationToken); + } + } + /// A desktop's side: its own index (for the job engine), the workspace copy job connected to the test server, a workspace and its sync. private sealed class WorkspaceClient : IAsyncDisposable { @@ -342,13 +498,13 @@ public sealed class ServerWorkspaceTests(TestContext context) /// Whether the copy job finds this PC signed in to the server. public bool Connected { get; set; } = true; - public static async Task StartAsync(TestContext context, TestServer server, string token, string name) + public static async Task StartAsync(TestContext context, TestServer server, string token, string name, HttpMessageHandler? handler = null) { var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory(name + "-db"), "chronos.db")), context.Cancellation); var archives = new ArchiveService(db, new ArchiveServiceOptions { Owner = name }); // This PC's own library: the copy of a server project never writes into it. var archive = await archives.CreateAsync(context.CreateTempDirectory(name + "-archive"), "Local", cancellationToken: context.Cancellation); - var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), name) { Token = token }; + var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), name, handler) { Token = token }; WorkspaceClient? created = null; var engine = new JobEngine(db, WorkspaceJobs.CreateHandlers(db, archives, new Connector(client, () => created?.Connected ?? true)), new JobEngineOptions { Workers = 1, WorkerId = name, PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });