C#: Remove the timeout bool logic in the feed manager.

Author: michaelnebel

csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/FeedManager.cs

@@ -60,17 +60,12 @@ internal sealed partial class FeedManager : IDisposable
         /// </summary>
         public ImmutableHashSet<string> InheritedFeeds => AllFeeds.Except(ExplicitFeeds).ToImmutableHashSet();
 
-        private readonly Lazy<(bool, ImmutableHashSet<string>)> lazyReachableExplicitFeeds;
-
-        /// <summary>
-        /// Gets whether there was a timeout when checking the reachability of the explicitly configured NuGet feeds.
-        /// </summary>
-        public bool ExplicitFeedTimeout => lazyReachableExplicitFeeds.Value.Item1;
+        private readonly Lazy<ImmutableHashSet<string>> lazyReachableExplicitFeeds;
 
         /// <summary>
         /// Gets the list of reachable NuGet feeds that are explicitly configured.
         /// </summary>
-        public ImmutableHashSet<string> ReachableExplicitFeeds => lazyReachableExplicitFeeds.Value.Item2;
+        public ImmutableHashSet<string> ReachableExplicitFeeds => lazyReachableExplicitFeeds.Value;
 
         private readonly Lazy<ImmutableHashSet<string>> lazyReachableFeeds;
         /// <summary>
@@ -96,15 +91,11 @@ public FeedManager(ILogger logger, IDotNet dotnet, DependabotProxy? dependabotPr
 
             lazyExplicitFeeds = new Lazy<ImmutableHashSet<string>>(GetExplicitFeeds);
             lazyAllFeeds = new Lazy<ImmutableHashSet<string>>(GetAllFeeds);
-            lazyReachableExplicitFeeds = new Lazy<(bool, ImmutableHashSet<string>)>(() =>
-            {
-                var timeout = CheckSpecifiedFeeds(ExplicitFeeds, out var reachableFeeds);
-                return (timeout, reachableFeeds);
-            });
+            lazyReachableExplicitFeeds = new Lazy<ImmutableHashSet<string>>(() => CheckSpecifiedFeeds(ExplicitFeeds));
             lazyReachableFeeds = new Lazy<ImmutableHashSet<string>>(() =>
             {
                 // Inherited feeds should only be used, if they are indeed reachable (as they may be environment specific).
-                CheckSpecifiedFeeds(InheritedFeeds, out var reachableInheritedFeeds);
+                var reachableInheritedFeeds = CheckSpecifiedFeeds(InheritedFeeds);
                 return ReachableExplicitFeeds.Union(reachableInheritedFeeds).ToImmutableHashSet();
             });
             lazyReachableFallbackFeeds = new Lazy<ImmutableHashSet<string>>(() =>
@@ -271,7 +262,7 @@ private static async Task<HttpResponseMessage> ExecuteGetRequest(string address,
             return await httpClient.GetAsync(address, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
         }
 
-        private bool IsFeedReachable(string feed, int timeoutMilliSeconds, int tryCount, out bool isTimeout)
+        private bool IsFeedReachable(string feed, int timeoutMilliSeconds, int tryCount)
         {
             logger.LogInfo($"Checking if NuGet feed '{feed}' is reachable...");
 
@@ -304,8 +295,6 @@ private bool IsFeedReachable(string feed, int timeoutMilliSeconds, int tryCount,
 
             using HttpClient client = new(httpClientHandler);
 
-            isTimeout = false;
-
             for (var i = 0; i < tryCount; i++)
             {
                 using var cts = new CancellationTokenSource();
@@ -335,7 +324,6 @@ private bool IsFeedReachable(string feed, int timeoutMilliSeconds, int tryCount,
             }
 
             logger.LogWarning($"Didn't receive answer from NuGet feed '{feed}'. Tried it {tryCount} times.");
-            isTimeout = true;
             return false;
         }
 
@@ -359,12 +347,8 @@ private HashSet<string> GetExcludedFeeds()
         /// Checks that we can connect to the specified NuGet feeds.
         /// </summary>
         /// <param name="feeds">The set of package feeds to check.</param>
-        /// <param name="reachableFeeds">The list of feeds that were reachable.</param>
-        /// <returns>
-        /// True if there is a timeout when trying to reach the feeds (excluding any feeds that are configured
-        /// to be excluded from the check) or false otherwise.
-        /// </returns>
-        private bool CheckSpecifiedFeeds(ImmutableHashSet<string> feeds, out ImmutableHashSet<string> reachableFeeds)
+        /// <returns>The list of feeds that were reachable.</returns>
+        private ImmutableHashSet<string> CheckSpecifiedFeeds(ImmutableHashSet<string> feeds)
         {
             // Exclude any feeds from the feed check that are configured by the corresponding environment variable.
             // These feeds are always assumed to be reachable.
@@ -380,12 +364,10 @@ private bool CheckSpecifiedFeeds(ImmutableHashSet<string> feeds, out ImmutableHa
                 return true;
             }).ToHashSet();
 
-            var reachable = GetReachableNuGetFeeds(feedsToCheck, isFallback: false, out var isTimeout);
+            var reachable = GetReachableNuGetFeeds(feedsToCheck, isFallback: false);
 
             // Always consider feeds excluded for the reachability check as reachable.
-            reachableFeeds = reachable.Union(feeds.Where(feed => excludedFeeds.Contains(feed))).ToImmutableHashSet();
-
-            return isTimeout;
+            return reachable.Union(feeds.Where(feed => excludedFeeds.Contains(feed))).ToImmutableHashSet();
         }
 
         /// <summary>
@@ -398,7 +380,7 @@ public bool IsDefaultFeedReachable()
             if (CheckNugetFeedResponsiveness)
             {
                 var (initialTimeout, tryCount) = GetFeedRequestSettings(isFallback: false);
-                return IsFeedReachable(PublicNugetOrgFeed, initialTimeout, tryCount, out var _);
+                return IsFeedReachable(PublicNugetOrgFeed, initialTimeout, tryCount);
             }
 
             return true;
@@ -409,22 +391,15 @@ public bool IsDefaultFeedReachable()
         /// </summary>
         /// <param name="feedsToCheck">The feeds to check.</param>
         /// <param name="isFallback">Whether the feeds are fallback feeds or not.</param>
-        /// <param name="isTimeout">Whether a timeout occurred while checking the feeds.</param>
         /// <returns>The list of feeds that could be reached.</returns>
-        private List<string> GetReachableNuGetFeeds(HashSet<string> feedsToCheck, bool isFallback, out bool isTimeout)
+        private List<string> GetReachableNuGetFeeds(HashSet<string> feedsToCheck, bool isFallback)
         {
             var fallbackStr = isFallback ? "fallback " : "";
             logger.LogInfo($"Checking {fallbackStr}NuGet feed reachability on feeds: {string.Join(", ", feedsToCheck.OrderBy(f => f))}");
 
             var (initialTimeout, tryCount) = GetFeedRequestSettings(isFallback);
-            var timeout = false;
             var reachableFeeds = feedsToCheck
-                .Where(feed =>
-                {
-                    var reachable = IsFeedReachable(feed, initialTimeout, tryCount, out var feedTimeout);
-                    timeout |= feedTimeout;
-                    return reachable;
-                })
+                .Where(feed => IsFeedReachable(feed, initialTimeout, tryCount))
                 .ToList();
 
             if (reachableFeeds.Count == 0)
@@ -436,7 +411,6 @@ private List<string> GetReachableNuGetFeeds(HashSet<string> feedsToCheck, bool i
                 logger.LogInfo($"Reachable {fallbackStr}NuGet feeds: {string.Join(", ", reachableFeeds.OrderBy(f => f))}");
             }
 
-            isTimeout = timeout;
             return reachableFeeds;
         }
 
@@ -460,7 +434,7 @@ private List<string> GetReachableFallbackNugetFeeds()
                 }
             }
 
-            return GetReachableNuGetFeeds(fallbackFeeds, isFallback: true, out var _);
+            return GetReachableNuGetFeeds(fallbackFeeds, isFallback: true);
         }
 
         private ImmutableHashSet<string> GetExplicitFeeds()