feat: add vpn start progress

Author: deansheather

.idea/.idea.Coder.Desktop/.idea/projectSettingsUpdater.xml

@@ -19,12 +19,30 @@ public enum VpnLifecycle
     Stopping,
 }
 
+public class VpnStartupProgress
+{
+    public double Progress { get; set; } = 0.0; // 0.0 to 1.0
+    public string Message { get; set; } = string.Empty;
+
+    public VpnStartupProgress Clone()
+    {
+        return new VpnStartupProgress
+        {
+            Progress = Progress,
+            Message = Message,
+        };
+    }
+}
+
 public class RpcModel
 {
     public RpcLifecycle RpcLifecycle { get; set; } = RpcLifecycle.Disconnected;
 
     public VpnLifecycle VpnLifecycle { get; set; } = VpnLifecycle.Unknown;
 
+    // Nullable because it is only set when the VpnLifecycle is Starting
+    public VpnStartupProgress? VpnStartupProgress { get; set; }
+
     public IReadOnlyList<Workspace> Workspaces { get; set; } = [];
 
     public IReadOnlyList<Agent> Agents { get; set; } = [];
@@ -35,6 +53,7 @@ public RpcModel Clone()
         {
             RpcLifecycle = RpcLifecycle,
             VpnLifecycle = VpnLifecycle,
+            VpnStartupProgress = VpnStartupProgress?.Clone(),
             Workspaces = Workspaces,
             Agents = Agents,
         };

App/Models/RpcModel.cs

@@ -161,7 +161,12 @@ public async Task StartVpn(CancellationToken ct = default)
             throw new RpcOperationException(
                 $"Cannot start VPN without valid credentials, current state: {credentials.State}");
 
-        MutateState(state => { state.VpnLifecycle = VpnLifecycle.Starting; });
+        MutateState(state =>
+        {
+            state.VpnLifecycle = VpnLifecycle.Starting;
+            // Explicitly clear the startup progress.
+            state.VpnStartupProgress = null;
+        });
 
         ServiceMessage reply;
         try
@@ -251,6 +256,9 @@ 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();
         }
 
@@ -283,15 +291,32 @@ private void ApplyStatusUpdate(Status status)
         });
     }
 
+    private void ApplyStartProgressUpdate(StartProgress message)
+    {
+        MutateState(state =>
+        {
+            // MutateState will undo these changes if it doesn't believe we're
+            // in the "Starting" state.
+            state.VpnStartupProgress = new VpnStartupProgress
+            {
+                Progress = message.Progress,
+                Message = message.Message,
+            };
+        });
+    }
+
     private void SpeakerOnReceive(ReplyableRpcMessage<ClientMessage, ServiceMessage> message)
     {
         switch (message.Message.MsgCase)
         {
+            case ServiceMessage.MsgOneofCase.Start:
+            case ServiceMessage.MsgOneofCase.Stop:
             case ServiceMessage.MsgOneofCase.Status:
                 ApplyStatusUpdate(message.Message.Status);
                 break;
-            case ServiceMessage.MsgOneofCase.Start:
-            case ServiceMessage.MsgOneofCase.Stop:
+            case ServiceMessage.MsgOneofCase.StartProgress:
+                ApplyStartProgressUpdate(message.Message.StartProgress);
+                break;
             case ServiceMessage.MsgOneofCase.None:
             default:
                 // TODO: log unexpected message

App/Properties/PublishProfiles/win-arm64.pubxml

@@ -29,7 +29,7 @@ public partial class TrayWindowViewModel : ObservableObject, IAgentExpanderHost
 {
     private const int MaxAgents = 5;
     private const string DefaultDashboardUrl = "https://coder.com";
-    private const string DefaultHostnameSuffix = ".coder";
+    private const string DefaultStartProgressMessage = "Starting Coder Connect...";
 
     private readonly IServiceProvider _services;
     private readonly IRpcController _rpcController;
@@ -53,6 +53,7 @@ public partial class TrayWindowViewModel : ObservableObject, IAgentExpanderHost
 
     [ObservableProperty]
     [NotifyPropertyChangedFor(nameof(ShowEnableSection))]
+    [NotifyPropertyChangedFor(nameof(ShowVpnStartProgressSection))]
     [NotifyPropertyChangedFor(nameof(ShowWorkspacesHeader))]
     [NotifyPropertyChangedFor(nameof(ShowNoAgentsSection))]
     [NotifyPropertyChangedFor(nameof(ShowAgentsSection))]
@@ -63,14 +64,33 @@ public partial class TrayWindowViewModel : ObservableObject, IAgentExpanderHost
 
     [ObservableProperty]
     [NotifyPropertyChangedFor(nameof(ShowEnableSection))]
+    [NotifyPropertyChangedFor(nameof(ShowVpnStartProgressSection))]
     [NotifyPropertyChangedFor(nameof(ShowWorkspacesHeader))]
     [NotifyPropertyChangedFor(nameof(ShowNoAgentsSection))]
     [NotifyPropertyChangedFor(nameof(ShowAgentsSection))]
     [NotifyPropertyChangedFor(nameof(ShowAgentOverflowButton))]
     [NotifyPropertyChangedFor(nameof(ShowFailedSection))]
     public partial string? VpnFailedMessage { get; set; } = null;
 
-    public bool ShowEnableSection => VpnFailedMessage is null && VpnLifecycle is not VpnLifecycle.Started;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(VpnStartProgressIsIndeterminate))]
+    [NotifyPropertyChangedFor(nameof(VpnStartProgressValueOrDefault))]
+    public partial int? VpnStartProgressValue { get; set; } = null;
+
+    public int VpnStartProgressValueOrDefault => VpnStartProgressValue ?? 0;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(VpnStartProgressMessageOrDefault))]
+    public partial string? VpnStartProgressMessage { get; set; } = null;
+
+    public string VpnStartProgressMessageOrDefault =>
+        string.IsNullOrEmpty(VpnStartProgressMessage) ? DefaultStartProgressMessage : VpnStartProgressMessage;
+
+    public bool VpnStartProgressIsIndeterminate => VpnStartProgressValueOrDefault == 0;
+
+    public bool ShowEnableSection => VpnFailedMessage is null && VpnLifecycle is not VpnLifecycle.Starting and not VpnLifecycle.Started;
+
+    public bool ShowVpnStartProgressSection => VpnFailedMessage is null && VpnLifecycle is VpnLifecycle.Starting;
 
     public bool ShowWorkspacesHeader => VpnFailedMessage is null && VpnLifecycle is VpnLifecycle.Started;
 
@@ -170,6 +190,20 @@ private void UpdateFromRpcModel(RpcModel rpcModel)
         VpnLifecycle = rpcModel.VpnLifecycle;
         VpnSwitchActive = rpcModel.VpnLifecycle is VpnLifecycle.Starting or VpnLifecycle.Started;
 
+        // VpnStartupProgress is only set when the VPN is starting.
+        if (rpcModel.VpnLifecycle is VpnLifecycle.Starting && rpcModel.VpnStartupProgress != null)
+        {
+            // Convert 0.00-1.00 to 0-100.
+            var progress = (int)(rpcModel.VpnStartupProgress.Progress * 100);
+            VpnStartProgressValue = Math.Clamp(progress, 0, 100);
+            VpnStartProgressMessage = string.IsNullOrEmpty(rpcModel.VpnStartupProgress.Message) ? null : rpcModel.VpnStartupProgress.Message;
+        }
+        else
+        {
+            VpnStartProgressValue = null;
+            VpnStartProgressMessage = null;
+        }
+
         // Add every known agent.
         HashSet<ByteString> workspacesWithAgents = [];
         List<AgentViewModel> agents = [];

App/Properties/PublishProfiles/win-x64.pubxml

@@ -36,7 +36,7 @@
         </HyperlinkButton>
 
         <HyperlinkButton
-            Command="{x:Bind ViewModel.ExitCommand, Mode=OneWay}"
+            Command="{x:Bind ViewModel.ExitCommand}"
             Margin="-12,-8,-12,-5"
             HorizontalAlignment="Stretch"
             HorizontalContentAlignment="Left"> 

App/Properties/PublishProfiles/win-x86.pubxml

@@ -43,6 +43,8 @@
             <ProgressRing
                 Grid.Column="1"
                 IsActive="{x:Bind ViewModel.VpnLifecycle, Converter={StaticResource ConnectingBoolConverter}, Mode=OneWay}"
+                IsIndeterminate="{x:Bind ViewModel.VpnStartProgressIsIndeterminate, Mode=OneWay}"
+                Value="{x:Bind ViewModel.VpnStartProgressValueOrDefault, Mode=OneWay}"
                 Width="24"
                 Height="24"
                 Margin="10,0"
@@ -74,6 +76,13 @@
             Visibility="{x:Bind ViewModel.ShowEnableSection, Converter={StaticResource BoolToVisibilityConverter}, Mode=OneWay}"
             Foreground="{ThemeResource SystemControlForegroundBaseMediumBrush}" />
 
+        <TextBlock
+            Text="{x:Bind ViewModel.VpnStartProgressMessageOrDefault, Mode=OneWay}"
+            TextWrapping="Wrap"
+            Margin="0,6,0,6"
+            Visibility="{x:Bind ViewModel.ShowVpnStartProgressSection, Converter={StaticResource BoolToVisibilityConverter}, Mode=OneWay}"
+            Foreground="{ThemeResource SystemControlForegroundBaseMediumBrush}" />
+
         <TextBlock
             Text="Workspaces"
             FontWeight="semibold"
@@ -344,7 +353,7 @@
             Command="{x:Bind ViewModel.ExitCommand, Mode=OneWay}"
             Margin="-12,-8,-12,-5"
             HorizontalAlignment="Stretch"
-            HorizontalContentAlignment="Left">          
+            HorizontalContentAlignment="Left">
 
             <TextBlock Text="Exit" Foreground="{ThemeResource DefaultTextForegroundThemeBrush}" />
         </HyperlinkButton>

App/Services/RpcController.cs

@@ -2,6 +2,7 @@
 using System.Security.Cryptography;
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
+using System.Threading.Channels;
 using Coder.Desktop.Vpn.Service;
 using Microsoft.Extensions.Logging.Abstractions;
 
@@ -278,7 +279,7 @@ public async Task Download(CancellationToken ct)
             NullDownloadValidator.Instance, ct);
         await dlTask.Task;
         Assert.That(dlTask.TotalBytes, Is.EqualTo(4));
-        Assert.That(dlTask.BytesRead, Is.EqualTo(4));
+        Assert.That(dlTask.BytesWritten, Is.EqualTo(4));
         Assert.That(dlTask.Progress, Is.EqualTo(1));
         Assert.That(dlTask.IsCompleted, Is.True);
         Assert.That(await File.ReadAllTextAsync(destPath, ct), Is.EqualTo("test"));
@@ -301,17 +302,56 @@ public async Task DownloadSameDest(CancellationToken ct)
         var dlTask0 = await startTask0;
         await dlTask0.Task;
         Assert.That(dlTask0.TotalBytes, Is.EqualTo(5));
-        Assert.That(dlTask0.BytesRead, Is.EqualTo(5));
+        Assert.That(dlTask0.BytesWritten, Is.EqualTo(5));
         Assert.That(dlTask0.Progress, Is.EqualTo(1));
         Assert.That(dlTask0.IsCompleted, Is.True);
         var dlTask1 = await startTask1;
         await dlTask1.Task;
         Assert.That(dlTask1.TotalBytes, Is.EqualTo(5));
-        Assert.That(dlTask1.BytesRead, Is.EqualTo(5));
+        Assert.That(dlTask1.BytesWritten, Is.EqualTo(5));
         Assert.That(dlTask1.Progress, Is.EqualTo(1));
         Assert.That(dlTask1.IsCompleted, Is.True);
     }
 
+    [Test(Description = "Download with X-Original-Content-Length")]
+    [CancelAfter(30_000)]
+    public async Task DownloadWithXOriginalContentLength(CancellationToken ct)
+    {
+        using var httpServer = new TestHttpServer(async ctx =>
+        {
+            ctx.Response.StatusCode = 200;
+            ctx.Response.Headers.Add("X-Original-Content-Length", "6"); // wrong but should be used until complete
+            ctx.Response.ContentType = "text/plain";
+            ctx.Response.ContentLength64 = 4; // This should be ignored.
+            await ctx.Response.OutputStream.WriteAsync("test"u8.ToArray(), ct);
+        });
+        var url = new Uri(httpServer.BaseUrl + "/test");
+        var destPath = Path.Combine(_tempDir, "test");
+        var manager = new Downloader(NullLogger<Downloader>.Instance);
+        var req = new HttpRequestMessage(HttpMethod.Get, url);
+        var dlTask = await manager.StartDownloadAsync(req, destPath, NullDownloadValidator.Instance, ct);
+
+        var progressChannel = Channel.CreateUnbounded<DownloadProgressEvent>();
+        dlTask.ProgressChanged += (_, args) =>
+            Assert.That(progressChannel.Writer.TryWrite(args), Is.True);
+
+        await dlTask.Task;
+        Assert.That(dlTask.TotalBytes, Is.EqualTo(4)); // should equal BytesWritten after completion
+        Assert.That(dlTask.BytesWritten, Is.EqualTo(4));
+        progressChannel.Writer.Complete();
+
+        var list = progressChannel.Reader.ReadAllAsync(ct).ToBlockingEnumerable(ct).ToList();
+        Assert.That(list.Count, Is.GreaterThanOrEqualTo(2)); // there may be an item in the middle
+        // The first item should be the initial progress with 0 bytes written.
+        Assert.That(list[0].BytesWritten, Is.EqualTo(0));
+        Assert.That(list[0].TotalBytes, Is.EqualTo(6)); // from X-Original-Content-Length
+        Assert.That(list[0].Progress, Is.EqualTo(0.0d));
+        // The last item should be final progress with the actual total bytes.
+        Assert.That(list[^1].BytesWritten, Is.EqualTo(4));
+        Assert.That(list[^1].TotalBytes, Is.EqualTo(4)); // from the actual bytes written
+        Assert.That(list[^1].Progress, Is.EqualTo(1.0d));
+    }
+
     [Test(Description = "Download with custom headers")]
     [CancelAfter(30_000)]
     public async Task WithHeaders(CancellationToken ct)
@@ -347,7 +387,7 @@ public async Task DownloadExisting(CancellationToken ct)
         var dlTask = await manager.StartDownloadAsync(new HttpRequestMessage(HttpMethod.Get, url), destPath,
             NullDownloadValidator.Instance, ct);
         await dlTask.Task;
-        Assert.That(dlTask.BytesRead, Is.Zero);
+        Assert.That(dlTask.BytesWritten, Is.Zero);
         Assert.That(await File.ReadAllTextAsync(destPath, ct), Is.EqualTo("test"));
         Assert.That(File.GetLastWriteTime(destPath), Is.LessThan(DateTime.Now - TimeSpan.FromDays(1)));
     }
@@ -368,7 +408,7 @@ public async Task DownloadExistingDifferentContent(CancellationToken ct)
         var dlTask = await manager.StartDownloadAsync(new HttpRequestMessage(HttpMethod.Get, url), destPath,
             NullDownloadValidator.Instance, ct);
         await dlTask.Task;
-        Assert.That(dlTask.BytesRead, Is.EqualTo(4));
+        Assert.That(dlTask.BytesWritten, Is.EqualTo(4));
         Assert.That(await File.ReadAllTextAsync(destPath, ct), Is.EqualTo("test"));
         Assert.That(File.GetLastWriteTime(destPath), Is.GreaterThan(DateTime.Now - TimeSpan.FromDays(1)));
     }

App/ViewModels/TrayWindowViewModel.cs

@@ -60,7 +60,8 @@ message ServiceMessage {
 	oneof msg {
 		StartResponse start = 2;
 		StopResponse stop = 3;
-		Status status = 4; // either in reply to a StatusRequest or broadcasted
+		Status status = 4;                // either in reply to a StatusRequest or broadcasted
+		StartProgress start_progress = 5; // broadcasted during startup
 	}
 }
 
@@ -218,6 +219,19 @@ message StartResponse {
 	string error_message = 2;
 }
 
+// StartProgress is sent from the manager to the client to indicate the
+// download/startup progress of the tunnel. This will be sent during the
+// processing of a StartRequest before the StartResponse is sent.
+//
+// Note: this is currently a broadcasted message to all clients due to the
+//       inability to easily send messages to a specific client in the Speaker
+//       implementation. If clients are not expecting these messages, they
+//       should ignore them.
+message StartProgress {
+	double progress = 1; // 0.0 to 1.0
+	string message = 2; // human-readable status message, must be set
+}
+
 // StopRequest is a request from the manager to stop the tunnel. The tunnel replies with a
 // StopResponse.
 message StopRequest {}

App/Views/Pages/TrayWindowLoginRequiredPage.xaml

@@ -338,32 +338,81 @@
     }
 }
 
+public class DownloadProgressEvent
+{
+    // TODO: speed calculation would be nice
+    public ulong BytesWritten { get; init; }
+    public ulong? TotalBytes { get; init; } // null if unknown
+    public double? Progress { get; init; }  // 0.0 - 1.0, null if unknown
+
+    public override string ToString()
+    {
+        var s = FriendlyBytes(BytesWritten);
+        if (TotalBytes != null)
+            s += $" of {FriendlyBytes(TotalBytes.Value)}";
+        else
+            s += " of unknown";
+        if (Progress != null)
+            s += $" ({Progress:0%})";
+        return s;
+    }
+
+    private static readonly string[] ByteSuffixes = ["B", "KB", "MB", "GB", "TB", "PB", "EB"];
+
+    // Unfortunately this is copied from FriendlyByteConverter in App. Ideally
+    // it should go into some shared utilities project, but it's overkill to do
+    // that for a single tiny function until we have more shared code.
+    private static string FriendlyBytes(ulong bytes)
+    {
+        if (bytes == 0)
+            return $"0 {ByteSuffixes[0]}";
+
+        var place = Convert.ToInt32(Math.Floor(Math.Log(bytes, 1024)));
+        var num = Math.Round(bytes / Math.Pow(1024, place), 1);
+        return $"{num} {ByteSuffixes[place]}";
+    }
+}
+
 /// <summary>
-///     Downloads an Url to a file on disk. The download will be written to a temporary file first, then moved to the final
+///     Downloads a Url to a file on disk. The download will be written to a temporary file first, then moved to the final
 ///     destination. The SHA1 of any existing file will be calculated and used as an ETag to avoid downloading the file if
 ///     it hasn't changed.
 /// </summary>
 public class DownloadTask
 {
     private const int BufferSize = 4096;
+    private const int ProgressUpdateDelayMs = 50;
+    private const string XOriginalContentLengthHeader = "X-Original-Content-Length"; // overrides Content-Length if available
 
-    private static readonly HttpClient HttpClient = new();
+    private static readonly HttpClient HttpClient = new(new HttpClientHandler
+    {
+        AutomaticDecompression = DecompressionMethods.All,
+    });
     private readonly string _destinationDirectory;
 
     private readonly ILogger _logger;
 
     private readonly RaiiSemaphoreSlim _semaphore = new(1, 1);
     private readonly IDownloadValidator _validator;
-    public readonly string DestinationPath;
+    private readonly string _destinationPath;
+    private readonly string _tempDestinationPath;
+
+    // ProgressChanged events are always delayed by up to 50ms to avoid
+    // flooding.
+    //
+    // This will be called:
+    // - once after the request succeeds but before the read/write routine
+    //   begins
+    // - occasionally while the file is being downloaded (at least 50ms apart)
+    // - once when the download is complete
+    public EventHandler<DownloadProgressEvent>? ProgressChanged;
 
     public readonly HttpRequestMessage Request;
-    public readonly string TempDestinationPath;
 
-    public ulong? TotalBytes { get; private set; }
-    public ulong BytesRead { get; private set; }
     public Task Task { get; private set; } = null!; // Set in EnsureStartedAsync
-
-    public double? Progress => TotalBytes == null ? null : (double)BytesRead / TotalBytes.Value;
+    public ulong BytesWritten { get; private set; }
+    public ulong? TotalBytes { get; private set; }
+    public double? Progress => TotalBytes == null ? null : (double)BytesWritten / TotalBytes.Value;
     public bool IsCompleted => Task.IsCompleted;
 
     internal DownloadTask(ILogger logger, HttpRequestMessage req, string destinationPath, IDownloadValidator validator)
@@ -374,17 +423,17 @@
 
         if (string.IsNullOrWhiteSpace(destinationPath))
             throw new ArgumentException("Destination path must not be empty", nameof(destinationPath));
-        DestinationPath = Path.GetFullPath(destinationPath);
-        if (Path.EndsInDirectorySeparator(DestinationPath))
-            throw new ArgumentException($"Destination path '{DestinationPath}' must not end in a directory separator",
+        _destinationPath = Path.GetFullPath(destinationPath);
+        if (Path.EndsInDirectorySeparator(_destinationPath))
+            throw new ArgumentException($"Destination path '{_destinationPath}' must not end in a directory separator",
                 nameof(destinationPath));
 
-        _destinationDirectory = Path.GetDirectoryName(DestinationPath)
+        _destinationDirectory = Path.GetDirectoryName(_destinationPath)
                                 ?? throw new ArgumentException(
-                                    $"Destination path '{DestinationPath}' must have a parent directory",
+                                    $"Destination path '{_destinationPath}' must have a parent directory",
                                     nameof(destinationPath));
 
-        TempDestinationPath = Path.Combine(_destinationDirectory, "." + Path.GetFileName(DestinationPath) +
+        _tempDestinationPath = Path.Combine(_destinationDirectory, "." + Path.GetFileName(_destinationPath) +
                                                                   ".download-" + Path.GetRandomFileName());
     }
 
@@ -406,9 +455,9 @@
 
         // If the destination path exists, generate a Coder SHA1 ETag and send
         // it in the If-None-Match header to the server.
-        if (File.Exists(DestinationPath))
+        if (File.Exists(_destinationPath))
         {
-            await using var stream = File.OpenRead(DestinationPath);
+            await using var stream = File.OpenRead(_destinationPath);
             var etag = Convert.ToHexString(await SHA1.HashDataAsync(stream, ct)).ToLower();
             Request.Headers.Add("If-None-Match", "\"" + etag + "\"");
         }
@@ -419,11 +468,11 @@
             _logger.LogInformation("File has not been modified, skipping download");
             try
             {
-                await _validator.ValidateAsync(DestinationPath, ct);
+                await _validator.ValidateAsync(_destinationPath, ct);
             }
             catch (Exception e)
             {
-                _logger.LogWarning(e, "Existing file '{DestinationPath}' failed custom validation", DestinationPath);
+                _logger.LogWarning(e, "Existing file '{DestinationPath}' failed custom validation", _destinationPath);
                 throw new Exception("Existing file failed validation after 304 Not Modified", e);
             }
 
@@ -448,6 +497,26 @@
         if (res.Content.Headers.ContentLength >= 0)
             TotalBytes = (ulong)res.Content.Headers.ContentLength;
 
+        // X-Original-Content-Length overrules Content-Length if set.
+        if (res.Headers.TryGetValues(XOriginalContentLengthHeader, out var headerValues))
+        {
+            // If there are multiple we only look at the first one.
+            var headerValue = headerValues.ToList().FirstOrDefault();
+            if (!string.IsNullOrEmpty(headerValue) && ulong.TryParse(headerValue, out var originalContentLength))
+                TotalBytes = originalContentLength;
+            else
+                _logger.LogWarning(
+                    "Failed to parse {XOriginalContentLengthHeader} header value '{HeaderValue}'",
+                    XOriginalContentLengthHeader, headerValue);
+        }
+
+        SendProgressUpdate(new DownloadProgressEvent
+        {
+            BytesWritten = 0,
+            TotalBytes = TotalBytes,
+            Progress = 0.0,
+        });
+
         await Download(res, ct);
     }
 
@@ -459,11 +528,11 @@
             FileStream tempFile;
             try
             {
-                tempFile = File.Create(TempDestinationPath, BufferSize, FileOptions.SequentialScan);
+                tempFile = File.Create(_tempDestinationPath, BufferSize, FileOptions.SequentialScan);
             }
             catch (Exception e)
             {
-                _logger.LogError(e, "Failed to create temporary file '{TempDestinationPath}'", TempDestinationPath);
+                _logger.LogError(e, "Failed to create temporary file '{TempDestinationPath}'", _tempDestinationPath);
                 throw;
             }
 
@@ -476,13 +545,31 @@
                 {
                     await tempFile.WriteAsync(buffer.AsMemory(0, n), ct);
                     sha1?.TransformBlock(buffer, 0, n, null, 0);
-                    BytesRead += (ulong)n;
+                    BytesWritten += (ulong)n;
+                    await QueueProgressUpdate(new DownloadProgressEvent
+                    {
+                        BytesWritten = BytesWritten,
+                        TotalBytes = TotalBytes,
+                        Progress = Progress,
+                    }, ct);
                 }
             }
 
-            if (TotalBytes != null && BytesRead != TotalBytes)
+            // Clear any pending progress updates to ensure they won't be sent
+            // after the final update.
+            await ClearQueuedProgressUpdate(ct);
+            // Then write the final status update.
+            TotalBytes = BytesWritten;
+            SendProgressUpdate(new DownloadProgressEvent
+            {
+                BytesWritten = BytesWritten,
+                TotalBytes = BytesWritten,
+                Progress = 1.0,
+            });
+
+            if (TotalBytes != null && BytesWritten != TotalBytes)
                 throw new IOException(
-                    $"Downloaded file size does not match response Content-Length: Content-Length={TotalBytes}, BytesRead={BytesRead}");
+                    $"Downloaded file size does not match response Content-Length: Content-Length={TotalBytes}, BytesRead={BytesWritten}");
 
             // Verify the ETag if it was sent by the server.
             if (res.Headers.Contains("ETag") && sha1 != null)
@@ -497,26 +584,99 @@
 
             try
             {
-                await _validator.ValidateAsync(TempDestinationPath, ct);
+                await _validator.ValidateAsync(_tempDestinationPath, ct);
             }
             catch (Exception e)
             {
                 _logger.LogWarning(e, "Downloaded file '{TempDestinationPath}' failed custom validation",
-                    TempDestinationPath);
+                    _tempDestinationPath);
                 throw new HttpRequestException("Downloaded file failed validation", e);
             }
 
-            File.Move(TempDestinationPath, DestinationPath, true);
+            File.Move(_tempDestinationPath, _destinationPath, true);
         }
-        finally
+        catch
         {
 #if DEBUG
             _logger.LogWarning("Not deleting temporary file '{TempDestinationPath}' in debug mode",
-                TempDestinationPath);
+                _tempDestinationPath);
 #else
-            if (File.Exists(TempDestinationPath))
-                File.Delete(TempDestinationPath);
+            try
+            {
+                if (File.Exists(TempDestinationPath))
+                    File.Delete(TempDestinationPath);
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Failed to delete temporary file '{TempDestinationPath}'", _tempDestinationPath);
+            }
 #endif
+            throw;
         }
     }
+
+    // _progressEventLock protects _progressUpdateTask and _pendingProgressEvent.
+    private readonly RaiiSemaphoreSlim _progressEventLock = new(1, 1);
+    private readonly CancellationTokenSource _progressUpdateCts = new();
+    private Task? _progressUpdateTask;
+    private DownloadProgressEvent? _pendingProgressEvent;
+
+    // Can be called multiple times, but must not be called or in progress while
+    // SendQueuedProgressUpdateNow is called.
+    private async Task QueueProgressUpdate(DownloadProgressEvent e, CancellationToken ct)
+    {
+        using var _1 = await _progressEventLock.LockAsync(ct);
+        _pendingProgressEvent = e;
+
+        if (_progressUpdateCts.IsCancellationRequested)
+            throw new InvalidOperationException("Progress update task was cancelled, cannot queue new progress update");
+
+        // Start a task with a 50ms delay unless one is already running.
+        var cts = CancellationTokenSource.CreateLinkedTokenSource(ct, _progressUpdateCts.Token);
+        cts.CancelAfter(TimeSpan.FromSeconds(5));
+        _progressUpdateTask ??= Task.Delay(ProgressUpdateDelayMs, cts.Token)
+            .ContinueWith(t =>
+            {
+                cts.Cancel();
+                using var _2 = _progressEventLock.Lock();
+                _progressUpdateTask = null;
+                if (t.IsFaulted || t.IsCanceled) return;
+
+                var ev = _pendingProgressEvent;
+                if (ev != null) SendProgressUpdate(ev);
+            }, cts.Token);
+    }
+
+    // Must only be called after all QueueProgressUpdate calls have completed.
+    private async Task ClearQueuedProgressUpdate(CancellationToken ct)
+    {
+        Task? t;
+        using (var _ = _progressEventLock.LockAsync(ct))
+        {
+            await _progressUpdateCts.CancelAsync();
+            t = _progressUpdateTask;
+        }
+
+        // We can't continue to hold the lock here because the continuation
+        // grabs a lock. We don't need to worry about a new task spawning after
+        // this because the token is cancelled.
+        if (t == null) return;
+        try
+        {
+            await t.WaitAsync(ct);
+        }
+        catch (TaskCanceledException)
+        {
+            // Ignore
+        }
+    }
+
+    private void SendProgressUpdate(DownloadProgressEvent e)
+    {
+        var handler = ProgressChanged;
+        if (handler == null)
+            return;
+        // Start a new task in the background to invoke the event.
+        _ = Task.Run(() => handler.Invoke(this, e));
+    }
 }

App/Views/Pages/TrayWindowMainPage.xaml

@@ -26,6 +26,10 @@ public interface IManager : IDisposable
 /// </summary>
 public class Manager : IManager
 {
+    // We scale the download progress to 0.00-0.90, and use 0.90-1.00 for the
+    // remainder of startup.
+    private const double DownloadProgressScale = 0.90;
+
     private readonly ManagerConfig _config;
     private readonly IDownloader _downloader;
     private readonly ILogger<Manager> _logger;
@@ -131,6 +135,8 @@ private async ValueTask<StartResponse> HandleClientMessageStart(ClientMessage me
         {
             try
             {
+                await BroadcastStartProgress(0.0, "Starting Coder Connect...", ct);
+
                 var serverVersion =
                     await CheckServerVersionAndCredentials(message.Start.CoderUrl, message.Start.ApiToken, ct);
                 if (_status == TunnelStatus.Started && _lastStartRequest != null &&
@@ -151,10 +157,14 @@ private async ValueTask<StartResponse> HandleClientMessageStart(ClientMessage me
                 _lastServerVersion = serverVersion;
 
                 // TODO: each section of this operation needs a timeout
+
                 // Stop the tunnel if it's running so we don't have to worry about
                 // permissions issues when replacing the binary.
                 await _tunnelSupervisor.StopAsync(ct);
+
                 await DownloadTunnelBinaryAsync(message.Start.CoderUrl, serverVersion.SemVersion, ct);
+
+                await BroadcastStartProgress(DownloadProgressScale, "Starting Coder Connect...", ct);
                 await _tunnelSupervisor.StartAsync(_config.TunnelBinaryPath, HandleTunnelRpcMessage,
                     HandleTunnelRpcError,
                     ct);
@@ -237,6 +247,9 @@ private void HandleTunnelRpcMessage(ReplyableRpcMessage<ManagerMessage, TunnelMe
                     _logger.LogWarning("Received unexpected message reply type {MessageType}", message.Message.MsgCase);
                     break;
                 case TunnelMessage.MsgOneofCase.Log:
+                    // Ignored. We already log stdout/stderr from the tunnel
+                    // binary.
+                    break;
                 case TunnelMessage.MsgOneofCase.NetworkSettings:
                     _logger.LogWarning("Received message type {MessageType} that is not expected on Windows",
                         message.Message.MsgCase);
@@ -311,12 +324,28 @@ private async ValueTask<Status> CurrentStatus(CancellationToken ct = default)
     private async Task BroadcastStatus(TunnelStatus? newStatus = null, CancellationToken ct = default)
     {
         if (newStatus != null) _status = newStatus.Value;
-        await _managerRpc.BroadcastAsync(new ServiceMessage
+        await FallibleBroadcast(new ServiceMessage
         {
             Status = await CurrentStatus(ct),
         }, ct);
     }
 
+    private async Task FallibleBroadcast(ServiceMessage message, CancellationToken ct = default)
+    {
+        // 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));
+        try
+        {
+            await _managerRpc.BroadcastAsync(message, cts.Token);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Could not broadcast low priority message to all RPC clients: {Message}", message);
+        }
+    }
+
     private void HandleTunnelRpcError(Exception e)
     {
         _logger.LogError(e, "Manager<->Tunnel RPC error");
@@ -427,10 +456,44 @@ private async Task DownloadTunnelBinaryAsync(string baseUrl, SemVersion expected
 
         var downloadTask = await _downloader.StartDownloadAsync(req, _config.TunnelBinaryPath, validators, ct);
 
-        // TODO: monitor and report progress when we have a mechanism to do so
+        var progressLock = new RaiiSemaphoreSlim(1, 1);
+        var progressBroadcastCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        downloadTask.ProgressChanged += (sender, ev) =>
+        {
+            using var _ = progressLock.Lock();
+            if (progressBroadcastCts.IsCancellationRequested) return;
+            _logger.LogInformation("Download progress: {ev}", ev);
+
+            // Scale the progress value to be between 0.00 and 0.90.
+            var progress = ev.Progress * DownloadProgressScale ?? 0.0;
+            var message = $"Downloading Coder Connect binary...\n{ev}";
+            BroadcastStartProgress(progress, message, progressBroadcastCts.Token).Wait(progressBroadcastCts.Token);
+        };
 
         // Awaiting this will check the checksum (via the ETag) if the file
         // exists, and will also validate the signature and version.
         await downloadTask.Task;
+
+        // Prevent any lagging progress events from being sent.
+        // ReSharper disable once PossiblyMistakenUseOfCancellationToken
+        using (await progressLock.LockAsync(ct))
+            await progressBroadcastCts.CancelAsync();
+
+        // We don't send a broadcast here as we immediately send one in the
+        // parent routine.
+        _logger.LogInformation("Completed downloading VPN binary");
+    }
+
+    private async Task BroadcastStartProgress(double progress, string message, CancellationToken ct = default)
+    {
+        _logger.LogInformation("Start progress: {Progress:0%} - {Message}", progress, message);
+        await FallibleBroadcast(new ServiceMessage
+        {
+            StartProgress = new StartProgress
+            {
+                Progress = progress,
+                Message = message,
+            },
+        }, ct);
     }
 }

Tests.Vpn.Service/DownloaderTest.cs

@@ -133,7 +133,7 @@ public async Task BroadcastAsync(ServiceMessage message, CancellationToken ct)
             try
             {
                 var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
-                cts.CancelAfter(5 * 1000);
+                cts.CancelAfter(TimeSpan.FromSeconds(2));
                 await client.Speaker.SendMessage(message, cts.Token);
             }
             catch (ObjectDisposedException)

Vpn.Proto/vpn.proto

@@ -16,10 +16,12 @@ public static class Program
 #if !DEBUG
     private const string ServiceName = "Coder Desktop";
     private const string ConfigSubKey = @"SOFTWARE\Coder Desktop\VpnService";
+    private const string DefaultLogLevel = "Information";
 #else
     // This value matches Create-Service.ps1.
     private const string ServiceName = "Coder Desktop (Debug)";
     private const string ConfigSubKey = @"SOFTWARE\Coder Desktop\DebugVpnService";
+    private const string DefaultLogLevel = "Debug";
 #endif
 
     private const string ManagerConfigSection = "Manager";
@@ -81,6 +83,10 @@ private static async Task BuildAndRun(string[] args)
         builder.Services.AddSingleton<ITelemetryEnricher, TelemetryEnricher>();
 
         // Services
+        builder.Services.AddHostedService<ManagerService>();
+        builder.Services.AddHostedService<ManagerRpcService>();
+
+        // Either run as a Windows service or a console application
         if (!Environment.UserInteractive)
         {
             MainLogger.Information("Running as a windows service");
@@ -91,9 +97,6 @@ private static async Task BuildAndRun(string[] args)
             MainLogger.Information("Running as a console application");
         }
 
-        builder.Services.AddHostedService<ManagerService>();
-        builder.Services.AddHostedService<ManagerRpcService>();
-
         var host = builder.Build();
         Log.Logger = (ILogger)host.Services.GetService(typeof(ILogger))!;
         MainLogger.Information("Application is starting");
@@ -108,7 +111,7 @@ private static void AddDefaultConfig(IConfigurationBuilder builder)
             ["Serilog:Using:0"] = "Serilog.Sinks.File",
             ["Serilog:Using:1"] = "Serilog.Sinks.Console",
 
-            ["Serilog:MinimumLevel"] = "Information",
+            ["Serilog:MinimumLevel"] = DefaultLogLevel,
             ["Serilog:Enrich:0"] = "FromLogContext",
 
             ["Serilog:WriteTo:0:Name"] = "File",

Vpn.Service/Downloader.cs

@@ -100,17 +100,15 @@ public async Task StartAsync(string binPath,
             };
             // TODO: maybe we should change the log format in the inner binary
             // to something without a timestamp
-            var outLogger = Log.ForContext("SourceContext", "coder-vpn.exe[OUT]");
-            var errLogger = Log.ForContext("SourceContext", "coder-vpn.exe[ERR]");
             _subprocess.OutputDataReceived += (_, args) =>
             {
                 if (!string.IsNullOrWhiteSpace(args.Data))
-                    outLogger.Debug("{Data}", args.Data);
+                    _logger.LogDebug("stdout: {Data}", args.Data);
             };
             _subprocess.ErrorDataReceived += (_, args) =>
             {
                 if (!string.IsNullOrWhiteSpace(args.Data))
-                    errLogger.Debug("{Data}", args.Data);
+                    _logger.LogDebug("stderr: {Data}", args.Data);
             };
 
             // Pass the other end of the pipes to the subprocess and dispose

Vpn.Service/Manager.cs

@@ -123,7 +123,7 @@ public async Task StartAsync(CancellationToken ct = default)
         // Handshakes should always finish quickly, so enforce a 5s timeout.
         using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct, _cts.Token);
         cts.CancelAfter(TimeSpan.FromSeconds(5));
-        await PerformHandshake(ct);
+        await PerformHandshake(cts.Token);
 
         // Start ReceiveLoop in the background.
         _receiveTask = ReceiveLoop(_cts.Token);