重构ReverseHttpClientFactory

Author: xljiulang

HttpMouse/Implementions/ReverseConnectionService.cs

@@ -14,7 +14,7 @@ namespace HttpMouse.Implementions
     /// <summary>
     /// 表示反向连接服务
     /// </summary>
-    sealed class ReverseConnectionService: IReverseConnectionService
+    sealed class ReverseConnectionService : IReverseConnectionService
     {
         private uint _reverseConnectionId = 0;
         private readonly HttpRequestOptionsKey<string> clientDomainKey = new("ClientDomain");
@@ -52,7 +52,7 @@ public async ValueTask<Stream> CreateReverseConnectionAsync(SocketsHttpConnectio
 
             if (this.mainConnectionService.TryGetValue(clientDomain, out var mainConnection) == false)
             {
-                throw new Exception("无法创建反向连接：目标未连接");
+                throw new Exception($"无法创建反向连接：上游{clientDomain}未连接");
             }
 
             var reverseConnectionId = Interlocked.Increment(ref this._reverseConnectionId);

HttpMouse/Implementions/ReverseHttpClientFactory.cs

@@ -1,38 +1,84 @@
 using Microsoft.Extensions.Logging;
+using System;
+using System.IO;
+using System.Net;
 using System.Net.Http;
+using System.Net.Security;
+using System.Threading;
+using System.Threading.Tasks;
 using Yarp.ReverseProxy.Forwarder;
 
 namespace HttpMouse.Implementions
 {
     /// <summary>
     /// 反向连接的HttpClient工厂
     /// </summary>
-    sealed class ReverseHttpClientFactory : ForwarderHttpClientFactory, IForwarderHttpClientFactory
+    sealed class ReverseHttpClientFactory : IForwarderHttpClientFactory, IDisposable
     {
+        private readonly SocketsHttpHandler httpHandler;
         private readonly IReverseConnectionService reverseConnectionService;
+        private readonly ILogger<ReverseHttpClientFactory> logger;
 
         /// <summary>
         /// 反向连接的HttpClient工厂
         /// </summary>
         /// <param name="reverseConnectionService"></param>
         /// <param name="logger"></param>
         public ReverseHttpClientFactory(
-            IReverseConnectionService reverseConnectionService,
-            ILogger<ForwarderHttpClientFactory> logger)
-            : base(logger)
+            IReverseConnectionService reverseConnectionService, ILogger<ReverseHttpClientFactory> logger)
         {
             this.reverseConnectionService = reverseConnectionService;
+            this.logger = logger;
+
+            this.httpHandler = new SocketsHttpHandler
+            {
+                UseProxy = false,
+                UseCookies = false,
+                AllowAutoRedirect = false,
+                AutomaticDecompression = DecompressionMethods.None,
+                ConnectCallback = this.ConnectCallback,
+                SslOptions = new SslClientAuthenticationOptions
+                {
+                    RemoteCertificateValidationCallback = delegate { return true; }
+                }
+            };
+        }
+
+        /// <summary>
+        /// 连接回调
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="cancellation"></param>
+        /// <returns></returns>
+        private async ValueTask<Stream> ConnectCallback(SocketsHttpConnectionContext context, CancellationToken cancellation)
+        {
+            try
+            {
+                return await this.reverseConnectionService.CreateReverseConnectionAsync(context, cancellation);
+            }
+            catch (Exception ex)
+            {
+                this.logger.LogWarning(ex.Message);
+                throw;
+            }
         }
 
         /// <summary>
-        /// 配置连接
+        /// 创建HttpMessageInvoker
         /// </summary>
         /// <param name="context"></param>
-        /// <param name="handler"></param>
-        protected override void ConfigureHandler(ForwarderHttpClientContext context, SocketsHttpHandler handler)
+        /// <returns></returns>
+        public HttpMessageInvoker CreateClient(ForwarderHttpClientContext context)
+        {
+            return new HttpMessageInvoker(this.httpHandler, disposeHandler: false);
+        }
+
+        /// <summary>
+        /// 释放资源
+        /// </summary>
+        public void Dispose()
         {
-            base.ConfigureHandler(context, handler);
-            handler.ConnectCallback = this.reverseConnectionService.CreateReverseConnectionAsync;
+            this.httpHandler.Dispose();
         }
     }
 }