invariant in startup progress model

Author: deansheather

App/Models/RpcModel.cs

@@ -88,8 +88,8 @@ public class VpnStartupProgress
     private const double DownloadProgressMin = 0.05;
     private const double DownloadProgressMax = 0.80;
 
-    public VpnStartupStage Stage { get; set; } = VpnStartupStage.Unknown;
-    public VpnDownloadProgress? DownloadProgress { get; set; } = null;
+    public VpnStartupStage Stage { get; init; } = VpnStartupStage.Unknown;
+    public VpnDownloadProgress? DownloadProgress { get; init; } = null;
 
     // 0.0 to 1.0
     public double Progress
@@ -165,10 +165,25 @@ public class RpcModel
 {
     public RpcLifecycle RpcLifecycle { get; set; } = RpcLifecycle.Disconnected;
 
-    public VpnLifecycle VpnLifecycle { get; set; } = VpnLifecycle.Unknown;
+    public VpnLifecycle VpnLifecycle
+    {
+        get;
+        set
+        {
+            if (VpnLifecycle != value && value == VpnLifecycle.Starting)
+                // Reset the startup progress when the VPN lifecycle changes to
+                // Starting.
+                VpnStartupProgress = null;
+            field = value;
+        }
+    }
 
     // Nullable because it is only set when the VpnLifecycle is Starting
-    public VpnStartupProgress? VpnStartupProgress { get; set; }
+    public VpnStartupProgress? VpnStartupProgress
+    {
+        get => VpnLifecycle is VpnLifecycle.Starting ? field ?? new VpnStartupProgress() : null;
+        set;
+    }
 
     public IReadOnlyList<Workspace> Workspaces { get; set; } = [];
 

App/Services/RpcController.cs

@@ -164,7 +164,6 @@ public async Task StartVpn(CancellationToken ct = default)
         MutateState(state =>
         {
             state.VpnLifecycle = VpnLifecycle.Starting;
-            state.VpnStartupProgress = new VpnStartupProgress();
         });
 
         ServiceMessage reply;
@@ -255,9 +254,6 @@ private void MutateState(Action<RpcModel> mutator)
         using (_stateLock.Lock())
         {
             mutator(_state);
-            // Unset the startup progress if the VpnLifecycle is not Starting
-            if (_state.VpnLifecycle != VpnLifecycle.Starting)
-                _state.VpnStartupProgress = null;
             newState = _state.Clone();
         }
 
@@ -294,8 +290,8 @@ private void ApplyStartProgressUpdate(StartProgress message)
     {
         MutateState(state =>
         {
-            // MutateState will undo these changes if it doesn't believe we're
-            // in the "Starting" state.
+            // The model itself will ignore this value if we're not in the
+            // starting state.
             state.VpnStartupProgress = VpnStartupProgress.FromProto(message);
         });
     }

Vpn.Service/Manager.cs

@@ -331,7 +331,7 @@ private async Task FallibleBroadcast(ServiceMessage message, CancellationToken c
         // Broadcast the messages out with a low timeout. If clients don't
         // receive broadcasts in time, it's not a big deal.
         using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
-        //cts.CancelAfter(TimeSpan.FromMilliseconds(100));
+        cts.CancelAfter(TimeSpan.FromMilliseconds(30));
         try
         {
             await _managerRpc.BroadcastAsync(message, cts.Token);

Vpn.Service/ManagerRpc.cs

@@ -127,26 +127,33 @@ public async Task ExecuteAsync(CancellationToken stoppingToken)
 
     public async Task BroadcastAsync(ServiceMessage message, CancellationToken ct)
     {
+        // Sends messages to all clients simultaneously and waits for them all
+        // to send or fail/timeout.
+        //
         // Looping over a ConcurrentDictionary is exception-safe, but any items
         // added or removed during the loop may or may not be included.
-        foreach (var (clientId, client) in _activeClients)
+        await Task.WhenAll(_activeClients.Select(async item =>
+        {
             try
             {
-                var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+                // Enforce upper bound in case a CT with a timeout wasn't
+                // supplied.
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
                 cts.CancelAfter(TimeSpan.FromSeconds(2));
-                await client.Speaker.SendMessage(message, cts.Token);
+                await item.Value.Speaker.SendMessage(message, cts.Token);
             }
             catch (ObjectDisposedException)
             {
                 // The speaker was likely closed while we were iterating.
             }
             catch (Exception e)
             {
-                _logger.LogWarning(e, "Failed to send message to client {ClientId}", clientId);
+                _logger.LogWarning(e, "Failed to send message to client {ClientId}", item.Key);
                 // TODO: this should probably kill the client, but due to the
                 //       async nature of the client handling, calling Dispose
                 //       will not remove the client from the active clients list
             }
+        }));
     }
 
     private async Task HandleRpcClientAsync(ulong clientId, Speaker<ServiceMessage, ClientMessage> speaker,

Vpn.Service/TunnelSupervisor.cs

@@ -99,16 +99,16 @@ public async Task StartAsync(string binPath,
                 },
             };
             // TODO: maybe we should change the log format in the inner binary
-            // to something without a timestamp
+            //       to something without a timestamp
             _subprocess.OutputDataReceived += (_, args) =>
             {
                 if (!string.IsNullOrWhiteSpace(args.Data))
-                    _logger.LogDebug("stdout: {Data}", args.Data);
+                    _logger.LogInformation("stdout: {Data}", args.Data);
             };
             _subprocess.ErrorDataReceived += (_, args) =>
             {
                 if (!string.IsNullOrWhiteSpace(args.Data))
-                    _logger.LogDebug("stderr: {Data}", args.Data);
+                    _logger.LogInformation("stderr: {Data}", args.Data);
             };
 
             // Pass the other end of the pipes to the subprocess and dispose