fix: fix downloading different URLs to same destination

spikecurtis · spikecurtis · commit 4bd685576446 · 2025-04-17T16:13:19.000+04:00
diff --git a/Tests.Vpn.Service/DownloaderTest.cs b/Tests.Vpn.Service/DownloaderTest.cs
@@ -284,6 +284,34 @@ public async Task Download(CancellationToken ct)
         Assert.That(await File.ReadAllTextAsync(destPath, ct), Is.EqualTo("test"));
     }
 
+    [Test(Description = "Perform 2 downloads with the same destination")]
+    [CancelAfter(30_000)]
+    public async Task DownloadSameDest(CancellationToken ct)
+    {
+        using var httpServer = EchoServer();
+        var url0 = new Uri(httpServer.BaseUrl + "/test0");
+        var url1 = new Uri(httpServer.BaseUrl + "/test1");
+        var destPath = Path.Combine(_tempDir, "test");
+
+        var manager = new Downloader(NullLogger<Downloader>.Instance);
+        var startTask0 = manager.StartDownloadAsync(new HttpRequestMessage(HttpMethod.Get, url0), destPath,
+            NullDownloadValidator.Instance, ct);
+        var startTask1 = manager.StartDownloadAsync(new HttpRequestMessage(HttpMethod.Get, url1), destPath,
+            NullDownloadValidator.Instance, 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.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.Progress, Is.EqualTo(1));
+        Assert.That(dlTask1.IsCompleted, Is.True);
+    }
+
     [Test(Description = "Download with custom headers")]
     [CancelAfter(30_000)]
     public async Task WithHeaders(CancellationToken ct)
@@ -395,9 +423,9 @@ public void CancelledOuter(CancellationToken ct)
         var manager = new Downloader(NullLogger<Downloader>.Instance);
         // The "outer" Task should fail.
         var smallerCt = new CancellationTokenSource(TimeSpan.FromSeconds(1)).Token;
-        Assert.ThrowsAsync<TaskCanceledException>(
-            async () => await manager.StartDownloadAsync(new HttpRequestMessage(HttpMethod.Get, url), destPath,
-                NullDownloadValidator.Instance, smallerCt));
+        Assert.ThrowsAsync<TaskCanceledException>(async () => await manager.StartDownloadAsync(
+            new HttpRequestMessage(HttpMethod.Get, url), destPath,
+            NullDownloadValidator.Instance, smallerCt));
     }
 
     [Test(Description = "Timeout on response body")]
diff --git a/Vpn.Service/Downloader.cs b/Vpn.Service/Downloader.cs
@@ -288,7 +288,9 @@ public async Task<DownloadTask> StartDownloadAsync(HttpRequestMessage req, strin
         {
             var task = _downloads.GetOrAdd(destinationPath,
                 _ => new DownloadTask(_logger, req, destinationPath, validator));
-            await task.EnsureStartedAsync(ct);
+            // EnsureStarted is a no-op if we didn't create a new DownloadTask.
+            // So, we will only remove the destination once for each time we start a new task.
+            task.EnsureStarted(tsk => _downloads.TryRemove(destinationPath, out _), ct);
 
             // If the existing (or new) task is for the same URL, return it.
             if (task.Request.RequestUri == req.RequestUri)
@@ -357,21 +359,19 @@ internal DownloadTask(ILogger logger, HttpRequestMessage req, string destination
                                                                   ".download-" + Path.GetRandomFileName());
     }
 
-    internal async Task<Task> EnsureStartedAsync(CancellationToken ct = default)
+    internal void EnsureStarted(Action<Task> continuation, CancellationToken ct = default)
     {
-        using var _ = await _semaphore.LockAsync(ct);
+        using var _ = _semaphore.Lock();
         if (Task == null!)
-            Task = await StartDownloadAsync(ct);
-
-        return Task;
+            Task = Start(ct).ContinueWith(continuation, CancellationToken.None);
     }
 
     /// <summary>
     ///     Starts downloading the file. The request will be performed in this task, but once started, the task will complete
     ///     and the download will continue in the background. The provided CancellationToken can be used to cancel the
     ///     download.
     /// </summary>
-    private async Task<Task> StartDownloadAsync(CancellationToken ct = default)
+    private async Task Start(CancellationToken ct = default)
     {
         Directory.CreateDirectory(_destinationDirectory);
 
@@ -398,8 +398,7 @@ private async Task<Task> StartDownloadAsync(CancellationToken ct = default)
                 throw new Exception("Existing file failed validation after 304 Not Modified", e);
             }
 
-            Task = Task.CompletedTask;
-            return Task;
+            return;
         }
 
         if (res.StatusCode != HttpStatusCode.OK)
@@ -432,11 +431,11 @@ private async Task<Task> StartDownloadAsync(CancellationToken ct = default)
             throw;
         }
 
-        Task = DownloadAsync(res, tempFile, ct);
-        return Task;
+        await Download(res, tempFile, ct);
+        return;
     }
 
-    private async Task DownloadAsync(HttpResponseMessage res, FileStream tempFile, CancellationToken ct)
+    private async Task Download(HttpResponseMessage res, FileStream tempFile, CancellationToken ct)
     {
         try
         {

Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,9 @@ public async Task<DownloadTask> StartDownloadAsync(HttpRequestMessage req, strin`
`288`	`288`	`{`
`289`	`289`	`var task = _downloads.GetOrAdd(destinationPath,`
`290`	`290`	`_ => new DownloadTask(_logger, req, destinationPath, validator));`
`291`		`- await task.EnsureStartedAsync(ct);`
	`291`	`+ // EnsureStarted is a no-op if we didn't create a new DownloadTask.`
	`292`	`+ // So, we will only remove the destination once for each time we start a new task.`
	`293`	`+ task.EnsureStarted(tsk => _downloads.TryRemove(destinationPath, out _), ct);`
`292`	`294`
`293`	`295`	`// If the existing (or new) task is for the same URL, return it.`
`294`	`296`	`if (task.Request.RequestUri == req.RequestUri)`
`@@ -357,21 +359,19 @@ internal DownloadTask(ILogger logger, HttpRequestMessage req, string destination`
`357`	`359`	`".download-" + Path.GetRandomFileName());`
`358`	`360`	`}`
`359`	`361`
`360`		`- internal async Task<Task> EnsureStartedAsync(CancellationToken ct = default)`
	`362`	`+ internal void EnsureStarted(Action<Task> continuation, CancellationToken ct = default)`
`361`	`363`	`{`
`362`		`- using var _ = await _semaphore.LockAsync(ct);`
	`364`	`+ using var _ = _semaphore.Lock();`
`363`	`365`	`if (Task == null!)`
`364`		`- Task = await StartDownloadAsync(ct);`
`365`		`-`
`366`		`- return Task;`
	`366`	`+ Task = Start(ct).ContinueWith(continuation, CancellationToken.None);`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`/// <summary>`
`370`	`370`	`/// Starts downloading the file. The request will be performed in this task, but once started, the task will complete`
`371`	`371`	`/// and the download will continue in the background. The provided CancellationToken can be used to cancel the`
`372`	`372`	`/// download.`
`373`	`373`	`/// </summary>`
`374`		`- private async Task<Task> StartDownloadAsync(CancellationToken ct = default)`
	`374`	`+ private async Task Start(CancellationToken ct = default)`
`375`	`375`	`{`
`376`	`376`	`Directory.CreateDirectory(_destinationDirectory);`
`377`	`377`
`@@ -398,8 +398,7 @@ private async Task<Task> StartDownloadAsync(CancellationToken ct = default)`
`398`	`398`	`throw new Exception("Existing file failed validation after 304 Not Modified", e);`
`399`	`399`	`}`
`400`	`400`
`401`		`- Task = Task.CompletedTask;`
`402`		`- return Task;`
	`401`	`+ return;`
`403`	`402`	`}`
`404`	`403`
`405`	`404`	`if (res.StatusCode != HttpStatusCode.OK)`
`@@ -432,11 +431,11 @@ private async Task<Task> StartDownloadAsync(CancellationToken ct = default)`
`432`	`431`	`throw;`
`433`	`432`	`}`
`434`	`433`
`435`		`- Task = DownloadAsync(res, tempFile, ct);`
`436`		`- return Task;`
	`434`	`+ await Download(res, tempFile, ct);`
	`435`	`+ return;`
`437`	`436`	`}`
`438`	`437`
`439`		`- private async Task DownloadAsync(HttpResponseMessage res, FileStream tempFile, CancellationToken ct)`
	`438`	`+ private async Task Download(HttpResponseMessage res, FileStream tempFile, CancellationToken ct)`
`440`	`439`	`{`
`441`	`440`	`try`
`442`	`441`	`{`