Opt-in to set Connection:Close on downstream requests

src/Ocelot/Configuration/Builder/DownstreamRouteBuilder.cs

@@ -43,6 +43,7 @@ public class DownstreamRouteBuilder
     private HttpVersionPolicy _downstreamHttpVersionPolicy;
     private Dictionary<string, UpstreamHeaderTemplate> _upstreamHeaders;
     private MetadataOptions _metadataOptions;
+    private bool _connectionClose;
 
     public DownstreamRouteBuilder()
     {
@@ -282,6 +283,12 @@ public DownstreamRouteBuilder WithMetadata(MetadataOptions metadataOptions)
         return this;
     }
 
+    public DownstreamRouteBuilder WithConnectionClose(bool connectionClose)
+    {
+        _connectionClose = connectionClose;
+        return this;
+    }
+
     public DownstreamRoute Build()
     {
         return new DownstreamRoute(
@@ -321,6 +328,7 @@ public DownstreamRoute Build()
             _downstreamHttpVersion,
             _downstreamHttpVersionPolicy,
             _upstreamHeaders,
-            _metadataOptions);
+            _metadataOptions,
+            _connectionClose);
     }
 }

src/Ocelot/Configuration/Creator/ConnectionCloseCreator.cs

@@ -0,0 +1,14 @@
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public class ConnectionCloseCreator : IConnectionCloseCreator
+    {
+        public bool Create(bool fileRouteConnectionClose, FileGlobalConfiguration globalConfiguration)
+        {
+            var globalConnectionClose = globalConfiguration.ConnectionClose;
+
+            return fileRouteConnectionClose || globalConnectionClose;
+        }
+    }
+}

src/Ocelot/Configuration/Creator/IConnectionCloseCreator.cs

@@ -0,0 +1,9 @@
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public interface IConnectionCloseCreator
+    {
+        bool Create(bool fileRouteConnectionClose, FileGlobalConfiguration globalConfiguration);
+    }
+}

src/Ocelot/Configuration/Creator/RoutesCreator.cs

@@ -23,6 +23,7 @@ public class RoutesCreator : IRoutesCreator
         private readonly IVersionCreator _versionCreator;
         private readonly IVersionPolicyCreator _versionPolicyCreator;
         private readonly IMetadataCreator _metadataCreator;
+        private readonly IConnectionCloseCreator _connectionCloseCreator;
 
         public RoutesCreator(
             IClaimsToThingCreator claimsToThingCreator,
@@ -42,7 +43,8 @@ public RoutesCreator(
             IVersionCreator versionCreator,
             IVersionPolicyCreator versionPolicyCreator,
             IUpstreamHeaderTemplatePatternCreator upstreamHeaderTemplatePatternCreator,
-            IMetadataCreator metadataCreator)
+            IMetadataCreator metadataCreator,
+            IConnectionCloseCreator connectionCloseCreator)
         {
             _routeKeyCreator = routeKeyCreator;
             _loadBalancerOptionsCreator = loadBalancerOptionsCreator;
@@ -63,6 +65,7 @@ public RoutesCreator(
             _versionPolicyCreator = versionPolicyCreator;
             _upstreamHeaderTemplatePatternCreator = upstreamHeaderTemplatePatternCreator;
             _metadataCreator = metadataCreator;
+            _connectionCloseCreator = connectionCloseCreator;
         }
 
         public List<Route> Create(FileConfiguration fileConfiguration)
@@ -118,6 +121,8 @@ private DownstreamRoute SetUpDownstreamRoute(FileRoute fileRoute, FileGlobalConf
 
             var metadata = _metadataCreator.Create(fileRoute.Metadata, globalConfiguration);
 
+            var connectionClose = _connectionCloseCreator.Create(fileRoute.ConnectionClose, globalConfiguration);
+
             var route = new DownstreamRouteBuilder()
                 .WithKey(fileRoute.Key)
                 .WithDownstreamPathTemplate(fileRoute.DownstreamPathTemplate)
@@ -156,6 +161,7 @@ private DownstreamRoute SetUpDownstreamRoute(FileRoute fileRoute, FileGlobalConf
                 .WithDownstreamHttpVersionPolicy(downstreamHttpVersionPolicy)
                 .WithDownStreamHttpMethod(fileRoute.DownstreamHttpMethod)
                 .WithMetadata(metadata)
+                .WithConnectionClose(connectionClose)
                 .Build();
 
             return route;

src/Ocelot/Configuration/DownstreamRoute.cs

@@ -42,7 +42,8 @@ public DownstreamRoute(
             Version downstreamHttpVersion,
             HttpVersionPolicy downstreamHttpVersionPolicy,
             Dictionary<string, UpstreamHeaderTemplate> upstreamHeaders,
-            MetadataOptions metadataOptions)
+            MetadataOptions metadataOptions,
+            bool connectionClose)
         {
             DangerousAcceptAnyServerCertificateValidator = dangerousAcceptAnyServerCertificateValidator;
             AddHeadersToDownstream = addHeadersToDownstream;
@@ -81,6 +82,7 @@ public DownstreamRoute(
             DownstreamHttpVersionPolicy = downstreamHttpVersionPolicy;
             UpstreamHeaders = upstreamHeaders ?? new();
             MetadataOptions = metadataOptions;
+            ConnectionClose = connectionClose;
         }
 
         public string Key { get; }
@@ -137,5 +139,7 @@ public DownstreamRoute(
         public string Name() => string.IsNullOrEmpty(ServiceName) && !UseServiceDiscovery
             ? UpstreamPathTemplate?.Template ?? DownstreamPathTemplate?.Value ?? "?"
             : string.Join(':', ServiceNamespace, ServiceName, UpstreamPathTemplate?.Template);
+
+        public bool ConnectionClose { get; }
     }
 }

src/Ocelot/Configuration/File/FileGlobalConfiguration.cs

@@ -13,6 +13,7 @@ public FileGlobalConfiguration()
             HttpHandlerOptions = new FileHttpHandlerOptions();
             CacheOptions = new FileCacheOptions();
             MetadataOptions = new FileMetadataOptions();
+            ConnectionClose = false;
         }
 
         public string RequestIdKey { get; set; }
@@ -48,5 +49,7 @@ public FileGlobalConfiguration()
         public FileCacheOptions CacheOptions { get; set; }
 
         public FileMetadataOptions MetadataOptions { get; set; }
+
+        public bool ConnectionClose { get; set; }
     }
 }

src/Ocelot/Configuration/File/FileRoute.cs

@@ -26,6 +26,7 @@ public FileRoute()
             UpstreamHeaderTemplates = new Dictionary<string, string>();
             UpstreamHeaderTransform = new Dictionary<string, string>();
             UpstreamHttpMethod = new List<string>();
+            ConnectionClose = false;
         }
 
         public FileRoute(FileRoute from)
@@ -38,6 +39,7 @@ public FileRoute(FileRoute from)
         public Dictionary<string, string> AddQueriesToRequest { get; set; }
         public FileAuthenticationOptions AuthenticationOptions { get; set; }
         public Dictionary<string, string> ChangeDownstreamPathTemplate { get; set; }
+        public bool ConnectionClose { get; set; }
         public bool DangerousAcceptAnyServerCertificateValidator { get; set; }
         public List<string> DelegatingHandlers { get; set; }
         public Dictionary<string, string> DownstreamHeaderTransform { get; set; }
@@ -57,7 +59,7 @@ public FileRoute(FileRoute from)
         /// </remarks>
         public string DownstreamHttpVersionPolicy { get; set; }
         public string DownstreamPathTemplate { get; set; }
-        public string DownstreamScheme { get; set; }
+        public string DownstreamScheme { get; set; }
         public FileCacheOptions FileCacheOptions { get; set; }
         public FileHttpHandlerOptions HttpHandlerOptions { get; set; }
         public string Key { get; set; }
@@ -97,6 +99,7 @@ public static void DeepCopy(FileRoute from, FileRoute to)
             to.AddQueriesToRequest = new(from.AddQueriesToRequest);
             to.AuthenticationOptions = new(from.AuthenticationOptions);
             to.ChangeDownstreamPathTemplate = new(from.ChangeDownstreamPathTemplate);
+            to.ConnectionClose = from.ConnectionClose;
             to.DangerousAcceptAnyServerCertificateValidator = from.DangerousAcceptAnyServerCertificateValidator;
             to.DelegatingHandlers = new(from.DelegatingHandlers);
             to.DownstreamHeaderTransform = new(from.DownstreamHeaderTransform);
@@ -105,7 +108,7 @@ public static void DeepCopy(FileRoute from, FileRoute to)
             to.DownstreamHttpVersion = from.DownstreamHttpVersion;
             to.DownstreamHttpVersionPolicy = from.DownstreamHttpVersionPolicy;
             to.DownstreamPathTemplate = from.DownstreamPathTemplate;
-            to.DownstreamScheme = from.DownstreamScheme;
+            to.DownstreamScheme = from.DownstreamScheme;
             to.FileCacheOptions = new(from.FileCacheOptions);
             to.HttpHandlerOptions = new(from.HttpHandlerOptions);
             to.Key = from.Key;

src/Ocelot/DependencyInjection/OcelotBuilder.cs

@@ -71,6 +71,7 @@ public OcelotBuilder(IServiceCollection services, IConfiguration configurationRo
             Services.TryAddSingleton<IAuthenticationOptionsCreator, AuthenticationOptionsCreator>();
             Services.TryAddSingleton<IUpstreamTemplatePatternCreator, UpstreamTemplatePatternCreator>();
             Services.TryAddSingleton<IRequestIdKeyCreator, RequestIdKeyCreator>();
+            Services.TryAddSingleton<IConnectionCloseCreator, ConnectionCloseCreator>();
             Services.TryAddSingleton<IServiceProviderConfigurationCreator, ServiceProviderConfigurationCreator>();
             Services.TryAddSingleton<IQoSOptionsCreator, QoSOptionsCreator>();
             Services.TryAddSingleton<IRouteOptionsCreator, RouteOptionsCreator>();

src/Ocelot/Requester/HttpClientBuilder.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+
+using Ocelot.Configuration;
+
+using Ocelot.Logging;
+
+namespace Ocelot.Requester
+{
+    public interface IHttpClientBuilder { }
+    public interface IHttpClientCache
+    {
+        IHttpClient Get(DownstreamRoute cacheKey);
+        void Set(DownstreamRoute cacheKey, IHttpClient client, TimeSpan span);
+    }
+
+    public class HttpClientBuilder : IHttpClientBuilder
+    {
+        private readonly IDelegatingHandlerHandlerFactory _factory;
+        private readonly IHttpClientCache _cacheHandlers;
+        private readonly IOcelotLogger _logger;
+        private DownstreamRoute _cacheKey;
+        private HttpClient _httpClient;
+        private IHttpClient _client;
+        private readonly TimeSpan _defaultTimeout;
+
+        public HttpClientBuilder(
+            IDelegatingHandlerHandlerFactory factory,
+            IHttpClientCache cacheHandlers,
+            IOcelotLogger logger)
+        {
+            _factory = factory;
+            _cacheHandlers = cacheHandlers;
+            _logger = logger;
+
+            // This is hardcoded at the moment but can easily be added to configuration
+            // if required by a user request.
+            _defaultTimeout = TimeSpan.FromSeconds(90);
+        }
+
+        public IHttpClient Create(DownstreamRoute downstreamRoute)
+        {
+            _cacheKey = downstreamRoute;
+
+            var httpClient = _cacheHandlers.Get(_cacheKey);
+
+            if (httpClient != null)
+            {
+                _client = httpClient;
+                return httpClient;
+            }
+
+            var handler = CreateHandler(downstreamRoute);
+
+            if (downstreamRoute.DangerousAcceptAnyServerCertificateValidator)
+            {
+                handler.ServerCertificateCustomValidationCallback =
+                HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
+
+                _logger
+                    .LogWarning($"You have ignored all SSL warnings by using DangerousAcceptAnyServerCertificateValidator for this DownstreamRoute, UpstreamPathTemplate: {downstreamRoute.UpstreamPathTemplate}, DownstreamPathTemplate: {downstreamRoute.DownstreamPathTemplate}");
+            }
+
+            var timeout = downstreamRoute.QosOptions.TimeoutValue == 0
+                ? _defaultTimeout
+                : TimeSpan.FromMilliseconds(downstreamRoute.QosOptions.TimeoutValue);
+
+            _httpClient = new HttpClient(CreateHttpMessageHandler(handler, downstreamRoute))
+            {
+                Timeout = timeout,
+            };
+
+            _client = new HttpClientWrapper(_httpClient, downstreamRoute.ConnectionClose); // TODO
+
+            return _client;
+        }
+
+        private static HttpClientHandler CreateHandler(DownstreamRoute downstreamRoute)
+        {
+            // Dont' create the CookieContainer if UseCookies is not set or the HttpClient will complain
+            // under .Net Full Framework
+            var useCookies = downstreamRoute.HttpHandlerOptions.UseCookieContainer;
+
+            return useCookies ? UseCookiesHandler(downstreamRoute) : UseNonCookiesHandler(downstreamRoute);
+        }
+
+        private static HttpClientHandler UseNonCookiesHandler(DownstreamRoute downstreamRoute)
+        {
+            return new HttpClientHandler
+            {
+                AllowAutoRedirect = downstreamRoute.HttpHandlerOptions.AllowAutoRedirect,
+                UseCookies = downstreamRoute.HttpHandlerOptions.UseCookieContainer,
+                UseProxy = downstreamRoute.HttpHandlerOptions.UseProxy,
+                MaxConnectionsPerServer = downstreamRoute.HttpHandlerOptions.MaxConnectionsPerServer,
+
+            };
+        }
+
+        private static HttpClientHandler UseCookiesHandler(DownstreamRoute downstreamRoute)
+        {
+            return new HttpClientHandler
+            {
+                AllowAutoRedirect = downstreamRoute.HttpHandlerOptions.AllowAutoRedirect,
+                UseCookies = downstreamRoute.HttpHandlerOptions.UseCookieContainer,
+                UseProxy = downstreamRoute.HttpHandlerOptions.UseProxy,
+                MaxConnectionsPerServer = downstreamRoute.HttpHandlerOptions.MaxConnectionsPerServer,
+                CookieContainer = new CookieContainer(),
+            };
+        }
+
+        public void Save()
+        {
+            _cacheHandlers.Set(_cacheKey, _client, TimeSpan.FromHours(24));
+        }
+
+        private HttpMessageHandler CreateHttpMessageHandler(HttpMessageHandler httpMessageHandler, DownstreamRoute request)
+        {
+            //todo handle error
+            var handlers = _factory.Get(request).Data;
+
+            handlers
+                .Select(handler => handler)
+                .Reverse()
+                .ToList()
+                .ForEach(handler =>
+                {
+                    var delegatingHandler = handler();
+                    delegatingHandler.InnerHandler = httpMessageHandler;
+                    httpMessageHandler = delegatingHandler;
+                });
+            return httpMessageHandler;
+        }
+    }
+}

src/Ocelot/Requester/HttpClientWrapper.cs

@@ -0,0 +1,30 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Ocelot.Requester
+{
+    public interface IHttpClient { }
+
+    /// <summary>
+    /// This class was made to make unit testing easier when HttpClient is used.
+    /// </summary>
+    public class HttpClientWrapper : IHttpClient
+    {
+        public HttpClient Client { get; }
+
+        public bool ConnectionClose { get; } // TODO
+
+        public HttpClientWrapper(HttpClient client, bool connectionClose = false) // TODO
+        {
+            Client = client;
+            ConnectionClose = connectionClose;
+        }
+
+        public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken = default)
+        {
+            request.Headers.ConnectionClose = ConnectionClose;  // TODO
+            return Client.SendAsync(request, cancellationToken);
+        }
+    }
+}

test/Ocelot.UnitTests/Configuration/DownstreamRouteExtensionsTests.cs

@@ -51,7 +51,8 @@ public DownstreamRouteExtensionsTests()
             new Version(),
             HttpVersionPolicy.RequestVersionExact,
             new(),
-            new MetadataOptions(new FileMetadataOptions()));
+            new MetadataOptions(new FileMetadataOptions()),
+            false);
     }
 
     [Theory]