Increase HTTP connection pool size and add config override

The connection pool was previously sized to Environment.ProcessorCount (e.g., 8
on an 8-core machine). HTTP object downloads are I/O-bound, not CPU-bound, so
CPU count is a poor proxy for optimal connection concurrency. Under burst
workloads like git checkout, connections saturate almost instantly.

Set the default to 2x ProcessorCount. This provides more headroom during burst
object download scenarios without being overly aggressive for machines with
multiple mounts.

The pool size can be overridden via git config:

    git config gvfs.max-http-connections <value>

Any positive integer is accepted. The semaphore is adjusted in-place (via
Release/Wait) rather than replaced, so in-flight requests always release
permits to the correct instance.

Work item: 60167591

Assisted-by: Claude Opus 4.6
Signed-off-by: Tyrie Vella <tyrielv@gmail.com>

Author: tyrielv

GVFS/GVFS.Common/GVFSConstants.cs

@@ -46,6 +46,8 @@ public static class GitConfig
 
             public const string ShowHydrationStatus = GVFSPrefix + "show-hydration-status";
             public const bool ShowHydrationStatusDefault = false;
+
+            public const string MaxHttpConnectionsConfig = GVFSPrefix + "max-http-connections";
         }
 
         public static class LocalGVFSConfig

GVFS/GVFS.Common/Http/HttpRequestor.cs

@@ -19,6 +19,7 @@ public abstract class HttpRequestor : IDisposable
     {
         private static long requestCount = 0;
         private static SemaphoreSlim availableConnections;
+        private static int connectionLimitConfigured = 0;
 
         private readonly ProductInfoHeaderValue userAgentHeader;
 
@@ -34,8 +35,12 @@ static HttpRequestor()
             using (var machineConfigLock = GetMachineConfigLock())
             {
                 ServicePointManager.SecurityProtocol = ServicePointManager.SecurityProtocol | SecurityProtocolType.Tls12;
-                ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount;
-                availableConnections = new SemaphoreSlim(ServicePointManager.DefaultConnectionLimit);
+
+                // HTTP downloads are I/O-bound, not CPU-bound, so we default to
+                // 2x ProcessorCount. Can be overridden via gvfs.max-http-connections.
+                int connectionLimit = 2 * Environment.ProcessorCount;
+                ServicePointManager.DefaultConnectionLimit = connectionLimit;
+                availableConnections = new SemaphoreSlim(connectionLimit);
             }
         }
 
@@ -47,6 +52,13 @@ protected HttpRequestor(ITracer tracer, RetryConfig retryConfig, Enlistment enli
 
             this.Tracer = tracer;
 
+            // On first instantiation, check git config for a custom connection limit.
+            // This runs before any requests are made (during mount initialization).
+            if (Interlocked.CompareExchange(ref connectionLimitConfigured, 1, 0) == 0)
+            {
+                TryApplyConnectionLimitFromConfig(tracer, enlistment);
+            }
+
             HttpClientHandler httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
 
             this.authentication.ConfigureHttpClientHandlerSslIfNeeded(this.Tracer, httpClientHandler, enlistment.CreateGitProcess());
@@ -337,6 +349,58 @@ private static bool TryGetResponseMessageFromHttpRequestException(HttpRequestExc
 
         }
 
+        private static void TryApplyConnectionLimitFromConfig(ITracer tracer, Enlistment enlistment)
+        {
+            try
+            {
+                GitProcess.ConfigResult result = enlistment.CreateGitProcess().GetFromConfig(GVFSConstants.GitConfig.MaxHttpConnectionsConfig);
+                string error;
+                int configuredLimit;
+                if (!result.TryParseAsInt(0, 1, out configuredLimit, out error))
+                {
+                    EventMetadata metadata = new EventMetadata();
+                    metadata.Add("error", error);
+                    tracer.RelatedWarning(metadata, "HttpRequestor: Invalid gvfs.max-http-connections config value, using default");
+                    return;
+                }
+
+                if (configuredLimit > 0)
+                {
+                    int currentLimit = ServicePointManager.DefaultConnectionLimit;
+                    ServicePointManager.DefaultConnectionLimit = configuredLimit;
+
+                    // Adjust the existing semaphore rather than replacing it, so any
+                    // in-flight waiters release permits to the correct instance.
+                    int delta = configuredLimit - currentLimit;
+                    if (delta > 0)
+                    {
+                        for (int i = 0; i < delta; i++)
+                        {
+                            availableConnections.Release();
+                        }
+                    }
+                    else if (delta < 0)
+                    {
+                        for (int i = 0; i < -delta; i++)
+                        {
+                            availableConnections.Wait();
+                        }
+                    }
+
+                    EventMetadata metadata = new EventMetadata();
+                    metadata.Add("configuredLimit", configuredLimit);
+                    metadata.Add("previousLimit", currentLimit);
+                    tracer.RelatedEvent(EventLevel.Informational, "HttpRequestor_ConnectionLimitConfigured", metadata);
+                }
+            }
+            catch (Exception e)
+            {
+                EventMetadata metadata = new EventMetadata();
+                metadata.Add("Exception", e.ToString());
+                tracer.RelatedWarning(metadata, "HttpRequestor: Failed to read gvfs.max-http-connections config, using default");
+            }
+        }
+
         private static FileStream GetMachineConfigLock()
         {
             var machineConfigLocation = RuntimeEnvironment.SystemConfigurationFile;