fix: Add backoff logic to the HTTP clients; only update cache when remote fetch happens.

Author: patricktcoakley

GDVM.CLI/Http/ExponentialBackoffHandler.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GDVM.Http;
+
+internal sealed class ExponentialBackoffHandler : DelegatingHandler
+{
+    private readonly TimeSpan _initialDelay;
+    private readonly int _maxRetries;
+
+    public ExponentialBackoffHandler(TimeSpan initialDelay, int maxRetries)
+    {
+        if (maxRetries < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(maxRetries));
+        }
+
+        _initialDelay = initialDelay;
+        _maxRetries = maxRetries;
+    }
+
+    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+    {
+        var attempt = 0;
+        var delay = _initialDelay;
+
+        while (true)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                var response = await base.SendAsync(request, cancellationToken);
+
+                if (!ShouldRetry(response.StatusCode) || attempt >= _maxRetries)
+                {
+                    return response;
+                }
+
+                response.Dispose();
+            }
+            catch (HttpRequestException) when (attempt < _maxRetries)
+            {
+                // swallowed intentionally to retry
+            }
+            catch (TaskCanceledException ex) when (!cancellationToken.IsCancellationRequested && attempt < _maxRetries)
+            {
+                // Timeout or transient cancellation; retry
+                if (ex.InnerException is OperationCanceledException && cancellationToken.IsCancellationRequested)
+                {
+                    throw;
+                }
+            }
+
+            attempt++;
+
+            try
+            {
+                await Task.Delay(delay, cancellationToken);
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                throw;
+            }
+
+            delay = TimeSpan.FromTicks(delay.Ticks * 2);
+        }
+    }
+
+    private static bool ShouldRetry(HttpStatusCode statusCode) =>
+        statusCode == HttpStatusCode.RequestTimeout ||
+        statusCode == (HttpStatusCode)429 || // Too Many Requests
+        (int)statusCode >= 500;
+}

GDVM.CLI/Program.cs

@@ -3,6 +3,7 @@
 using GDVM.Environment;
 using GDVM.Filter;
 using GDVM.Godot;
+using GDVM.Http;
 using GDVM.Progress;
 using GDVM.Services;
 using Microsoft.Extensions.Configuration;
@@ -65,15 +66,19 @@ public static int Main(string[] args)
                 var version = typeof(Program).Assembly.GetName().Version?.ToString() ?? "unknown";
                 client.DefaultRequestHeaders.UserAgent.Clear();
                 client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("gdvm", version));
-            });
+                client.Timeout = TimeSpan.FromSeconds(30);
+            })
+            .AddHttpMessageHandler(() => new ExponentialBackoffHandler(TimeSpan.FromSeconds(2), 3));
 
         services.AddHttpClient<ITuxFamilyClient, TuxFamilyClient>("tuxfamily")
             .ConfigureHttpClient((_, client) =>
             {
                 var version = typeof(Program).Assembly.GetName().Version?.ToString() ?? "unknown";
                 client.DefaultRequestHeaders.UserAgent.Clear();
                 client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("gdvm", version));
-            });
+                client.Timeout = TimeSpan.FromSeconds(30);
+            })
+            .AddHttpMessageHandler(() => new ExponentialBackoffHandler(TimeSpan.FromSeconds(2), 3));
 
         // Register core services
         services.AddSingleton<IDownloadClient, DownloadClient>();

GDVM/Services/InstallationService.cs

@@ -237,7 +237,8 @@ public async Task<string[]> FetchReleaseNames(CancellationToken cancellationToke
         var lastWriteTime = File.GetLastWriteTime(pathService.ReleasesPath);
         var isCacheValid = !remote && File.Exists(pathService.ReleasesPath) && DateTime.Now.AddDays(-1) <= lastWriteTime;
 
-        IEnumerable<string> releaseNames = [];
+        string[] releaseNames;
+        var fetchedRemote = false;
 
         if (isCacheValid)
         {
@@ -247,13 +248,17 @@ public async Task<string[]> FetchReleaseNames(CancellationToken cancellationToke
             {
                 releaseNames = cachedReleases;
             }
-
-            logger.LogWarning("Cached releases file is empty, fetching from remote");
+            else
+            {
+                logger.LogWarning("Cached releases file is empty, fetching from remote");
+                releaseNames = (await releaseManager.ListReleases(cancellationToken)).ToArray();
+                fetchedRemote = true;
+            }
         }
         else
         {
-            releaseNames = await releaseManager
-                .ListReleases(cancellationToken);
+            releaseNames = (await releaseManager.ListReleases(cancellationToken)).ToArray();
+            fetchedRemote = true;
         }
 
         // Always sort releases using Release.CompareTo for consistent ordering
@@ -270,7 +275,11 @@ public async Task<string[]> FetchReleaseNames(CancellationToken cancellationToke
             return [];
         }
 
-        await File.WriteAllLinesAsync(pathService.ReleasesPath, sortedReleases, cancellationToken);
+        if (fetchedRemote)
+        {
+            await File.WriteAllLinesAsync(pathService.ReleasesPath, sortedReleases, cancellationToken);
+        }
+
         return sortedReleases;
     }