fix(external-system-gateway): resolve ExternalSystemGateway-015..017 — treat MaxRetries=0 as unset, scope HTTP connection cap to gateway clients, no bare trailing '?'

src/ScadaLink.ExternalSystemGateway/DatabaseGateway.cs

@@ -96,15 +96,20 @@ public class DatabaseGateway : IDatabaseGateway
             Parameters = parameters
         });
 
-        // The per-connection retry settings are passed through verbatim — a
-        // configured MaxRetries of 0 means "never retry" and must NOT be
-        // collapsed to the S&F default (ExternalSystemGateway-004).
+        // ExternalSystemGateway-015: the entity's MaxRetries is a non-nullable int
+        // whose default is 0, and the Store-and-Forward engine interprets a stored
+        // MaxRetries of 0 as "no limit" (retry forever) — see
+        // StoreAndForwardMessage.MaxRetries ("0 = no limit") and the retry-sweep
+        // guard `MaxRetries > 0 && ...`. Passing 0 verbatim would turn every
+        // unconfigured cached write into an unbounded retry loop. A 0 is treated as
+        // "unset" and passed as null so the bounded S&F default applies; the
+        // RetryDelay default of TimeSpan.Zero is likewise unset.
         await _storeAndForward.EnqueueAsync(
             StoreAndForwardCategory.CachedDbWrite,
             connectionName,
             payload,
             originInstanceName,
-            definition.MaxRetries,
+            definition.MaxRetries > 0 ? definition.MaxRetries : null,
             definition.RetryDelay > TimeSpan.Zero ? definition.RetryDelay : null);
     }
 

src/ScadaLink.ExternalSystemGateway/ExternalSystemClient.cs

@@ -114,15 +114,20 @@ public class ExternalSystemClient : IExternalSystemClient
             // attempt above; letting EnqueueAsync re-invoke the handler would
             // dispatch the same request a second time.
             //
-            // The per-system retry settings are passed through verbatim — a
-            // configured MaxRetries of 0 means "never retry" and must NOT be
-            // collapsed to the S&F default (ExternalSystemGateway-004).
+            // ExternalSystemGateway-015: the entity's MaxRetries is a non-nullable
+            // int whose default is 0, and the Store-and-Forward engine interprets a
+            // stored MaxRetries of 0 as "no limit" (retry forever) — see
+            // StoreAndForwardMessage.MaxRetries ("0 = no limit") and the retry-sweep
+            // guard `MaxRetries > 0 && ...`. Passing 0 verbatim would therefore turn
+            // every unconfigured cached call into an unbounded retry loop. A 0 is
+            // treated as "unset" and passed as null so the bounded S&F default
+            // applies; the RetryDelay default of TimeSpan.Zero is likewise unset.
             await _storeAndForward.EnqueueAsync(
                 StoreAndForwardCategory.ExternalSystem,
                 systemName,
                 payload,
                 originInstanceName,
-                system.MaxRetries,
+                system.MaxRetries > 0 ? system.MaxRetries : null,
                 system.RetryDelay > TimeSpan.Zero ? system.RetryDelay : null,
                 attemptImmediateDelivery: false);
 
@@ -329,7 +334,15 @@ public class ExternalSystemClient : IExternalSystemClient
             var queryString = string.Join("&",
                 parameters.Where(p => p.Value != null)
                     .Select(p => $"{Uri.EscapeDataString(p.Key)}={Uri.EscapeDataString(p.Value?.ToString() ?? "")}"));
-            url += "?" + queryString;
+
+            // Only append "?" when the effective query string is non-empty — a method
+            // whose parameter values are all null produces no query string, and the
+            // URL must then be identical to the no-parameters case rather than ending
+            // in a bare "?" (ExternalSystemGateway-017).
+            if (queryString.Length > 0)
+            {
+                url += "?" + queryString;
+            }
         }
 
         return url;

src/ScadaLink.ExternalSystemGateway/ServiceCollectionExtensions.cs

@@ -1,4 +1,5 @@
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Http;
 using Microsoft.Extensions.Options;
 using ScadaLink.Commons.Interfaces.Services;
 
@@ -6,6 +7,12 @@ namespace ScadaLink.ExternalSystemGateway;
 
 public static class ServiceCollectionExtensions
 {
+    /// <summary>
+    /// Name prefix of the per-system <see cref="System.Net.Http.HttpClient"/> clients
+    /// created by <see cref="ExternalSystemClient"/> (<c>ExternalSystem_{systemName}</c>).
+    /// </summary>
+    internal const string GatewayClientNamePrefix = "ExternalSystem_";
+
     public static IServiceCollection AddExternalSystemGateway(this IServiceCollection services)
     {
         services.AddOptions<ExternalSystemGatewayOptions>()
@@ -13,20 +20,18 @@ public static class ServiceCollectionExtensions
 
         services.AddHttpClient();
 
-        // ExternalSystemGateway-013: wire MaxConcurrentConnectionsPerSystem into the
-        // primary handler of every per-system named client ("ExternalSystem_{name}"),
-        // so the option an operator configures actually bounds concurrent connections
-        // instead of being silently ignored. ConfigureHttpClientDefaults applies to
-        // the dynamically-named clients created by ExternalSystemClient.
-        services.ConfigureHttpClientDefaults(builder =>
-            builder.ConfigurePrimaryHttpMessageHandler(sp =>
-            {
-                var options = sp.GetRequiredService<IOptions<ExternalSystemGatewayOptions>>().Value;
-                return new SocketsHttpHandler
-                {
-                    MaxConnectionsPerServer = options.MaxConcurrentConnectionsPerSystem,
-                };
-            }));
+        // ExternalSystemGateway-013 / -016: wire MaxConcurrentConnectionsPerSystem
+        // into the primary handler of the gateway's per-system named clients
+        // ("ExternalSystem_{name}") only. The names are created dynamically, so a
+        // static AddHttpClient("name") registration is not possible; instead a
+        // post-configure on HttpClientFactoryOptions is applied, filtered by the
+        // client-name prefix. ConfigureHttpClientDefaults is deliberately NOT used —
+        // it is process-global and would replace the primary handler of every
+        // HttpClient in the host (e.g. the Notification Service's OAuth2 token
+        // client), silently capping and overriding unrelated components.
+        services.AddSingleton<IConfigureOptions<HttpClientFactoryOptions>>(sp =>
+            new GatewayHttpClientConfigurator(
+                sp.GetRequiredService<IOptionsMonitor<ExternalSystemGatewayOptions>>()));
 
         services.AddScoped<ExternalSystemClient>();
         services.AddScoped<IExternalSystemClient>(sp => sp.GetRequiredService<ExternalSystemClient>());
@@ -42,4 +47,41 @@ public static class ServiceCollectionExtensions
         // Script Execution Actors run on dedicated blocking I/O dispatcher.
         return services;
     }
+
+    /// <summary>
+    /// ExternalSystemGateway-016: configures the primary HTTP message handler with the
+    /// gateway's <see cref="ExternalSystemGatewayOptions.MaxConcurrentConnectionsPerSystem"/>
+    /// cap, but only for the gateway's own named clients
+    /// (<see cref="GatewayClientNamePrefix"/>). Clients owned by other host components
+    /// are left untouched, so the cap does not leak process-wide.
+    /// </summary>
+    private sealed class GatewayHttpClientConfigurator
+        : IConfigureNamedOptions<HttpClientFactoryOptions>
+    {
+        private readonly IOptionsMonitor<ExternalSystemGatewayOptions> _options;
+
+        public GatewayHttpClientConfigurator(IOptionsMonitor<ExternalSystemGatewayOptions> options)
+        {
+            _options = options;
+        }
+
+        public void Configure(HttpClientFactoryOptions options)
+        {
+            // The default (unnamed) client is not a gateway client — do nothing.
+        }
+
+        public void Configure(string? name, HttpClientFactoryOptions options)
+        {
+            if (name == null || !name.StartsWith(GatewayClientNamePrefix, StringComparison.Ordinal))
+            {
+                return;
+            }
+
+            options.HttpMessageHandlerBuilderActions.Add(builder =>
+                builder.PrimaryHandler = new SocketsHttpHandler
+                {
+                    MaxConnectionsPerServer = _options.CurrentValue.MaxConcurrentConnectionsPerSystem,
+                });
+        }
+    }
 }