fix(app): viewers open server sequences with proxies, the editor follows the sign-in

An account without Edit is offered Open with proxies on a server that keeps
projects and checks nothing out, since it could never push. The editor of a
server's workspace project connects with the sign-in in use at each call, so a
project opened signed out renders once signed in; SyncHost tells every session
start and stop so workspace projects read their state again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-11-04 12:54:46 +01:00
1 parent cdd29f8e84
commit 48d8158fd7
8 files changed
+165 -24

No files matched your search

+4 -1
View File
@@ -62,6 +62,9 @@ public sealed class SampleData
private SampleData(AppServices services) => _services = services;
/// <summary>What the sample server says it can do (none: an older server, whose sequences open with proxies); tests set it.</summary>
public IReadOnlyList<string> Capabilities { get; set; } = [];
/// <summary>The server-only sequence whose proxies <see cref="CacheProxiesAsync"/> keeps on this PC (Sunrise over Superga).</summary>
public Guid ProxiedSequenceId => _sunrise;
@@ -762,7 +765,7 @@ public sealed class SampleData
{
await Task.Delay(14, ct);
if (!trusted.Contains(ServerFingerprint, StringComparer.OrdinalIgnoreCase)) throw new UntrustedCertificateException(ServerFingerprint);
return new ServerInfo("Studio NAS", "1.3.0", 1, [], ServerFingerprint, [], new ServerLimits(0, 0));
return new ServerInfo("Studio NAS", "1.3.0", 1, sample.Capabilities, ServerFingerprint, [], new ServerLimits(0, 0));
}
public Task<LoginResponse> LoginAsync(string username, string password, CancellationToken ct)
@@ -32,11 +32,25 @@ public interface IProjectRenders
}
/// <summary>
/// A workspace project's home when it is a server (owner review 2, R8, phase 5b): the connection its analyses and renders
/// travel on, which the source owns; null while this PC is not signed in to that server (the project still opens from the
/// workspace, its jobs are refused saying so).
/// A workspace project's home when it is a server (owner review 2, R8, phase 5b): how the source connects for its analyses
/// and renders (<paramref name="connect"/>: a connection the source owns, null while this PC is not signed in to that
/// server, when the project still opens from the workspace and its jobs are refused saying so), and the sign-in it would
/// connect with (<paramref name="session"/>): when that changes (signed in, out, or anew), the source connects again.
/// </summary>
public sealed record WorkspaceServerHome(IRemoteSequenceApi? Api);
public sealed class WorkspaceServerHome(Func<IRemoteSequenceApi?> connect, Func<object?> session)
{
/// <summary>One connection for good (null: never signed in), as a test or a capture holds it.</summary>
public WorkspaceServerHome(IRemoteSequenceApi? api)
: this(() => api, () => api)
{
}
/// <summary>The sign-in <see cref="Connect"/> would use now; compared by reference.</summary>
public object? Session => session();
/// <summary>A new connection of the current sign-in; null while signed out.</summary>
public IRemoteSequenceApi? Connect() => connect();
}
/// <summary>
/// A workspace project open in the editor (owner review 2, R8: editing happens in the workspace, never inside the
@@ -71,6 +85,9 @@ public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
private IRenderFrameSource? _frames;
private IFrameSource? _pixels;
private ServerJobs? _serverJobs;
private IRemoteSequenceApi? _api;
private object? _apiSession;
private bool _connected;
private int _frameCount;
private int _framesVersion = -1;
private Guid[] _frameIds = [];
@@ -273,12 +290,37 @@ public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
/// <summary>The server's jobs of the sequence, followed from now on; null while this PC is not signed in to the server.</summary>
private ServerJobs? ServerJobsOf(Guid sequenceId, string title)
{
if (_server?.Api is not { } api) return null;
if (Api() is not { } api) return null;
lock (_gate)
{
if (Volatile.Read(ref _disposed) == 1 || !ReferenceEquals(api, _api)) return null;
return _serverJobs ??= new ServerJobs(api, sequenceId, title, job => JobChanged?.Invoke(job));
}
}
/// <summary>
/// The connection of the sign-in in use now: made at first use, and again once the sign-in changed (the jobs followed
/// on the old one stop with it, so a project opened signed out renders once signed in); null while signed out.
/// </summary>
private IRemoteSequenceApi? Api()
{
if (_server is null) return null;
var session = _server.Session;
IRemoteSequenceApi? api, stale;
ServerJobs? staleJobs;
lock (_gate)
{
if (Volatile.Read(ref _disposed) == 1) return null;
return _serverJobs ??= new ServerJobs(api, sequenceId, title, job => JobChanged?.Invoke(job));
if (_connected && ReferenceEquals(session, _apiSession)) return _api;
(stale, staleJobs) = (_api, _serverJobs);
_serverJobs = null;
_api = api = _server.Connect();
(_apiSession, _connected) = (session, true);
}
// The jobs own their connection.
if (staleJobs is not null) _ = staleJobs.DisposeAsync().AsTask();
else stale?.Dispose();
return api;
}
/// <summary>The server's deep report when it describes these frames, else the copy the workspace took; whether one of another number of frames was read instead.</summary>
@@ -325,7 +367,7 @@ public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
{
if (Workspace is not { } workspace || MediaFramesVersion < 0) return false;
if (_server is null) return await _db.Sequences.GetAsync(workspace.Home.SequenceId, cancellationToken) is { } row && row.FramesVersion != MediaFramesVersion;
if (_server.Api is not { } api) return false;
if (Api() is not { } api) return false;
try
{
if ((await api.GetSequenceAsync(workspace.Home.SequenceId, cancellationToken)).FramesVersion != MediaFramesVersion) return true;
@@ -463,7 +505,7 @@ public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
public async Task<IReadOnlyList<Job>> ListJobsAsync(CancellationToken cancellationToken)
{
if (_server is null) return (await _db.Jobs.ListAsync(null, JobsListed, null, cancellationToken)).Items;
if (Volatile.Read(ref _serverJobs) is not { } jobs) return [];
if (Api() is null || Volatile.Read(ref _serverJobs) is not { } jobs) return [];
try
{
return await jobs.ListAsync(cancellationToken);
@@ -554,17 +596,18 @@ public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
if (_engine is not null) _engine.JobChanged -= OnJobChanged;
List<IRenderFrameSource> sources;
ServerJobs? jobs;
IRemoteSequenceApi? api;
lock (_gate)
{
sources = [.. _retired];
if (_frames is not null) sources.Add(_frames);
_retired.Clear();
(_frames, _pixels) = (null, null);
(jobs, _serverJobs) = (_serverJobs, null);
(jobs, _serverJobs, api, _api) = (_serverJobs, null, _api, null);
}
// The server's connection is the source's: it closes with it, also when no read made the jobs' listener.
if (jobs is not null) await jobs.DisposeAsync();
else _server?.Api?.Dispose();
else api?.Dispose();
foreach (var source in sources)
{
if (source is IAsyncDisposable disposable) await disposable.DisposeAsync();
@@ -574,8 +617,7 @@ public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
/// <summary>The server's jobs of the project's sequence, or why there are none.</summary>
/// <exception cref="EditorException">This PC is not signed in to the server of the project.</exception>
private ServerJobs ServerJobsOrThrow() =>
Volatile.Read(ref _serverJobs)
?? (Workspace is { } workspace ? ServerJobsOf(workspace.Home.SequenceId, Project.ReadBundle().Sequence.Title ?? string.Empty) : null)
(Workspace is { } workspace ? ServerJobsOf(workspace.Home.SequenceId, Project.ReadBundle().Sequence.Title ?? string.Empty) : null)
?? throw new EditorException(Loc.L("Editor.Error.SignedOut"));
/// <summary>
@@ -726,12 +726,15 @@ public sealed class SequenceViewModel : SectionViewModel
{
TakeRequest(remoteId);
workspace.Remember(remoteId, entry.ProjectId);
// Its analyses and renders travel on a connection of the signed-in session, when that is the project's server.
var api = string.Equals(sync.Server, entry.Home.Server, StringComparison.OrdinalIgnoreCase) ? sync.ConnectEditor() : null;
return new ServerOpen((new WorkspaceSequenceSource(workspace.Sync, entry.ProjectId, db, decoder, services.Engine, new WorkspaceServerHome(api)),
entry.SequenceTitle));
// Its analyses and renders travel on a connection of the signed-in session, when that is the project's server:
// made again whenever the sign-in changes, so a project opened signed out renders once signed in.
var server = entry.Home.Server;
var editorHome = new WorkspaceServerHome(() => string.Equals(sync.Server, server, StringComparison.OrdinalIgnoreCase) ? sync.ConnectEditor() : null,
() => sync.Session);
return new ServerOpen((new WorkspaceSequenceSource(workspace.Sync, entry.ProjectId, db, decoder, services.Engine, editorHome), entry.SequenceTitle));
}
if (sync.ServerHome(remoteId) is not { } home) return null;
// An account that may not edit checks nothing out: it is shown with proxies, read-only, as on an older server.
if (!sync.Policy.CanEdit || sync.ServerHome(remoteId) is not { } home) return null;
TakeRequest(remoteId);
try
{
+9 -1
View File
@@ -100,7 +100,8 @@ public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDispo
/// <summary>
/// A project of a sequence of the signed-in server changed there (the server's key, and its <c>projectChanged</c>), or,
/// with null, changes may have been missed while its events were lost (any thread).
/// with null, changes may have been missed while its events were lost, or the session with that server started or
/// stopped (its projects become reachable, or offline) (any thread).
/// </summary>
public event Action<string, ProjectChangedEvent?>? ProjectChanged;
@@ -139,6 +140,9 @@ public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDispo
engine.JobChanged += OnJobChanged;
}
/// <summary>The sign-in <see cref="ConnectEditor"/> uses now (another object once signed in anew); null while signed out.</summary>
public object? Session => Volatile.Read(ref _credentials);
/// <summary>A connection for the editor of a sequence of the signed-in server; null while signed out.</summary>
public IRemoteSequenceApi? ConnectEditor() =>
Volatile.Read(ref _credentials) is { } c ? EditorFactory(c.Address, c.Token, c.Fingerprints) : null;
@@ -260,7 +264,10 @@ public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDispo
await previous.ConfigureAwait(false);
if (Volatile.Read(ref _running) is { } running && wanted is { } same && running.Credentials.Address == same.Address && running.Credentials.Token == same.Token)
return;
var stopped = Volatile.Read(ref _running)?.Remote.Server;
await StopAsync().ConfigureAwait(false);
// The projects of the server left are offline now: their state is read again.
if (stopped is not null) ProjectChanged?.Invoke(stopped, null);
if (wanted is not { } start || Service is not { } service)
{
Changed?.Invoke();
@@ -274,6 +281,7 @@ public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDispo
Volatile.Write(ref _running, new Running(agent, remote, start));
Log.Info("sync", $"Comparing with {remote.Server}");
Changed?.Invoke();
ProjectChanged?.Invoke(remote.Server, null);
}
private async Task StopAsync()
+3 -3
View File
@@ -235,15 +235,15 @@ public static class SyncText
actions.Add(SyncAction.Upload);
break;
// A server that keeps projects edits its sequences in the workspace; an older one's open with proxies, the
// workspace offered disabled with the reason (phase 5b).
case SyncStatus.RemoteOnly or SyncStatus.ProxiesOnly when rights.KeepsProjects:
// workspace offered disabled with the reason (phase 5b). An account that may not edit only looks: with proxies.
case SyncStatus.RemoteOnly or SyncStatus.ProxiesOnly when rights is { KeepsProjects: true, CanEdit: true }:
actions.Add(SyncAction.OpenInWorkspace);
if (rights.CanFetchOriginals) actions.Add(SyncAction.DownloadOriginals);
break;
case SyncStatus.RemoteOnly or SyncStatus.ProxiesOnly:
actions.Add(SyncAction.OpenWithProxies);
if (rights.CanFetchOriginals) actions.Add(SyncAction.DownloadOriginals);
actions.Add(SyncAction.OpenInWorkspace);
if (!rights.KeepsProjects) actions.Add(SyncAction.OpenInWorkspace);
break;
case SyncStatus.LocalAhead when entry.Link is { MissingRemote: > 0 }:
if (rights.CanUpload) actions.Add(SyncAction.Upload);
@@ -1,7 +1,10 @@
using System.Collections.Concurrent;
using System.Diagnostics;
using Chronos.App.DesignTime;
using Chronos.App.Infrastructure;
using Chronos.App.Tests.Uploader;
using Chronos.Data.Projects;
using Chronos.Protocol;
using Chronos.Testing;
namespace Chronos.App.Tests.Server;
@@ -58,4 +61,67 @@ public sealed class SyncHostTests
environment.DeleteCaptureData();
}
}
/// <summary>
/// Phase 5b glue: a server that keeps projects is the home of its sequences' workspace projects while signed in to it,
/// never another server's; each session start and stop is told as "changes may have been missed", so the workspace
/// reads its projects' state again (offline once signed out, reachable once signed in anew).
/// </summary>
[Test]
[WindowsOnly]
public void TheSignedInServerIsTheHomeOfItsProjectsAndEverySessionChangeIsTold()
{
var environment = AppEnvironment.ForCapture();
try
{
SingleThreadedContext.Run(async () =>
{
await using var services = new AppServices(environment, new AppSettings { Language = "en" }, () => { }, new NoDialogs());
var sample = SampleData.Configure(services);
sample.Capabilities = [ServerCapabilities.Projects];
await sample.OpenEmptyAsync();
await sample.FillAsync();
services.Settings.RenderNodeOptIn = false;
var told = new ConcurrentQueue<(string Server, ProjectChangedEvent? Change)>();
services.Sync.ProjectChanged += (server, change) => told.Enqueue((server, change));
var sequence = Guid.CreateVersion7();
await services.Server.RestoreAsync();
await UntilAsync(() => services.Sync.Agent is not null && !told.IsEmpty, "session started and told");
var server = Assert.NotNull(services.Sync.Server);
Assert.True(services.Sync.HasProjects, "the server keeps projects");
var home = Assert.NotNull(services.Sync.ServerHome(sequence));
var reached = (ServerProjectHome)Assert.NotNull(services.Sync.ProjectHome(home));
Assert.Equal(sequence, reached.SequenceId);
Assert.Null(services.Sync.ProjectHome(home with { Server = "https://other.example:8443" }));
Assert.Same(reached.Client, ((ServerProjectHome)services.Sync.ProjectHome(home)!).Client);
// Signed out: told again, and its projects have no home to reach (offline) until signed in anew.
var before = told.Count;
services.Server.Disconnect();
await UntilAsync(() => told.Count > before && services.Sync.Agent is null, "session stop told");
Assert.Null(services.Sync.ProjectHome(home));
Assert.False(services.Sync.HasProjects);
before = told.Count;
await services.Server.RestoreAsync();
await UntilAsync(() => told.Count > before && services.Sync.Agent is not null, "new session told");
Assert.NotNull(services.Sync.ProjectHome(home));
Assert.True(told.All(t => t.Server == server && t.Change is null), "only session changes were told");
});
}
finally
{
environment.DeleteCaptureData();
}
}
private static async Task UntilAsync(Func<bool> condition, string what)
{
var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(10));
while (!condition())
{
Assert.True(DateTime.UtcNow < until, what);
await Task.Delay(20);
}
}
}
@@ -82,7 +82,9 @@ public sealed class SyncTextTests
// Owner review 2, R8, phase 5b: the workspace replaces Open with proxies, and the originals can still come down.
var projects = Editor with { KeepsProjects = true };
Assert.SequenceEqual([SyncAction.OpenInWorkspace, SyncAction.DownloadOriginals], SyncText.Actions(Entry(SyncStatus.RemoteOnly, local: null), projects));
Assert.SequenceEqual([SyncAction.OpenInWorkspace], SyncText.Actions(Entry(SyncStatus.ProxiesOnly, local: null), Viewer with { KeepsProjects = true }));
// An account that may not edit only looks, with proxies: it is offered no workspace copy it could not push.
Assert.SequenceEqual([SyncAction.OpenWithProxies], SyncText.Actions(Entry(SyncStatus.ProxiesOnly, local: null), Viewer with { KeepsProjects = true }));
Assert.SequenceEqual([SyncAction.OpenWithProxies], SyncText.Actions(Entry(SyncStatus.RemoteOnly, local: null), Viewer with { KeepsProjects = true }));
Assert.True(SyncText.IsEnabled(SyncAction.OpenInWorkspace, projects), "a server that keeps projects opens them");
Assert.Equal(Loc.L("Tooltips.Server.Sync.OpenInWorkspace"), SyncText.ToolTip(Entry(SyncStatus.RemoteOnly, local: null), SyncAction.OpenInWorkspace, projects));
// An older server's row says why its workspace action is disabled; the other actions are not.
@@ -2,6 +2,7 @@ using System.Globalization;
using System.Text.Json;
using Chronos.App.Editor;
using Chronos.App.Infrastructure;
using Chronos.App.Tests.Editor;
using Chronos.App.Workspace;
using Chronos.Core.Imaging.Decoders;
using Chronos.Core.Localization;
@@ -143,7 +144,10 @@ public sealed class ServerHomeTests(TestContext context)
var told = new List<WorkspaceHomeChange>();
host.HomeChanged += told.Add;
var source = new WorkspaceSequenceSource(host.Sync, projectId, bed.Db, DecoderFactory.CreateClient(null), bed.Engine, new WorkspaceServerHome(null));
// Opened signed out; the sign-in made later is the one the source connects with.
FakeRemoteSequenceApi? signedIn = null;
var source = new WorkspaceSequenceSource(host.Sync, projectId, bed.Db, DecoderFactory.CreateClient(null), bed.Engine,
new WorkspaceServerHome(() => signedIn, () => signedIn));
var content = await source.LoadAsync(bed.Ct);
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
var ui = new RecordingUi();
@@ -160,6 +164,19 @@ public sealed class ServerHomeTests(TestContext context)
Assert.Empty(await source.ListJobsAsync(bed.Ct));
var refused = await Assert.ThrowsAsync<EditorException>(() => source.SubmitAsync(session.RenderRequests(session.Project.Export)[0], bed.Ct));
Assert.Equal(Loc.L("Editor.Error.SignedOut"), refused.Message);
// Signed in since: the render goes to the server on that sign-in's connection; signed in anew, on the new one's.
var first = new FakeRemoteSequenceApi(await bed.RowAsync(), []);
signedIn = first;
await source.SubmitAsync(session.RenderRequests(session.Project.Export)[0], bed.Ct);
Assert.Equal(1, first.Posted.Count);
var second = new FakeRemoteSequenceApi(await bed.RowAsync(), []);
signedIn = second;
await source.SubmitAsync(session.RenderRequests(session.Project.Export)[0], bed.Ct);
Assert.Equal((1, 1), (first.Posted.Count, second.Posted.Count));
var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(10));
while (!first.Disposed && DateTime.UtcNow < until) await Task.Delay(20, bed.Ct);
Assert.True(first.Disposed, "the old sign-in's connection closes");
signedIn = null;
// In step with the server: the render names the version it holds, whose settings the server renders.
Assert.True(await menu.ReadyToRenderAsync(), "nothing to send");