refactor: deal with socket disposed exception

cnblogs-dudu · cnblogs-dudu · commit b25aabc41654 · 2024-11-24T07:08:28.000+08:00
diff --git a/src/Enyim.Caching/Memcached/MemcachedNode.cs b/src/Enyim.Caching/Memcached/MemcachedNode.cs
@@ -1,8 +1,6 @@
 using Enyim.Caching.Configuration;
-using Enyim.Caching.Memcached.Protocol.Binary;
 using Enyim.Caching.Memcached.Results;
 using Enyim.Caching.Memcached.Results.Extensions;
-using Enyim.Collections;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Concurrent;
@@ -12,8 +10,6 @@
 using System.Net;
 using System.Net.Security;
 using System.Net.Sockets;
-using System.Runtime.Serialization;
-using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -899,49 +895,71 @@ protected internal virtual PooledSocket CreateSocket()
         {
             try
             {
-                var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
-#if NET5_0_OR_GREATER
-                    _useSslStream, _useIPv6, _sslClientAuthOptions);
-#else
-                    _useSslStream, _useIPv6);
-#endif
-                ps.Connect();
-                return ps;
+                return CreateSocketInternal();
             }
-            catch (Exception ex)
+            catch
             {
-                _logger.LogError(ex, $"Create {nameof(PooledSocket)}");
-                throw;
+                try
+                {
+                    return CreateSocketInternal();
+                }
+                catch (Exception ex)
+                {
+                    LogCreateSocketError(ex, nameof(CreateSocket));
+                    throw;
+                }
             }
         }
 
-        protected internal virtual async Task<PooledSocket> CreateSocketAsync()
+        private PooledSocket CreateSocketInternal()
         {
-            try
-            {
-                var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
+            var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
 #if NET5_0_OR_GREATER
-                    _useSslStream, _useIPv6, _sslClientAuthOptions);
+            _useSslStream, _useIPv6, _sslClientAuthOptions);
 #else
-                    _useSslStream, _useIPv6);
+            _useSslStream, _useIPv6);
 #endif
-                await ps.ConnectAsync();
-                return ps;
+            ps.Connect();
+            return ps;
+        }
+
+        protected internal virtual async Task<PooledSocket> CreateSocketAsync()
+        {
+            try
+            {
+                return await CreateSocketInternalAsync();
             }
-            catch (Exception ex)
+            catch
             {
-                var endPointStr = _endPoint.ToString().Replace("Unspecified/", string.Empty);
-                _logger.LogError(ex, $"Failed to {nameof(CreateSocketAsync)} to {endPointStr}");
-                throw;
+                try
+                {
+                    return await CreateSocketInternalAsync();
+                }
+                catch (Exception ex)
+                {
+                    LogCreateSocketError(ex, nameof(CreateSocketAsync));
+                    throw;
+                }
             }
         }
 
-        //protected internal virtual PooledSocket CreateSocket(IPEndPoint endpoint, TimeSpan connectionTimeout, TimeSpan receiveTimeout)
-        //{
-        //    PooledSocket retval = new PooledSocket(endPoint, connectionTimeout, receiveTimeout);
+        private async Task<PooledSocket> CreateSocketInternalAsync()
+        {
+            var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
+#if NET5_0_OR_GREATER
+            _useSslStream, _useIPv6, _sslClientAuthOptions);
+#else
+                _useSslStream, _useIPv6);
+#endif
+            await ps.ConnectAsync();
+            return ps;
+        }
 
-        //    return retval;
-        //}
+        private void LogCreateSocketError(Exception ex, string operation)
+        {
+            var endPointStr = _endPoint.ToString().Replace("Unspecified/", string.Empty);
+            _logger.LogError(ex, "Failed to {operation} to {EndPoint}", operation, endPointStr);
+        }
 
         protected virtual IPooledSocketResult ExecuteOperation(IOperation op)
         {
diff --git a/src/Enyim.Caching/Memcached/PooledSocket.cs b/src/Enyim.Caching/Memcached/PooledSocket.cs
@@ -18,9 +18,10 @@ public partial class PooledSocket : IDisposable
         private readonly ILogger _logger;
 
         private bool _isAlive;
-        private bool _useSslStream;
-        private bool _useIPv6;
+        private readonly bool _useSslStream;
+        private readonly bool _useIPv6;
         private Socket _socket;
+        private bool _isSocketDisposed;
         private readonly EndPoint _endpoint;
         private readonly int _connectionTimeout;
 
@@ -74,7 +75,7 @@ public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan rece
             _socket = socket;
         }
 
-        public void Connect()
+        public bool Connect()
         {
             bool success = false;
 
@@ -86,20 +87,21 @@ void Cancel()
             {
                 if (_socket != null && !_socket.Connected)
                 {
-                    _socket.Dispose();
-                    _socket = null;
+                    DisposeSocket();
                 }
             }
 
             cts.Token.Register(Cancel);
 
             try
             {
+                if (_isSocketDisposed) return false;
                 _socket.Connect(_endpoint);
             }
             catch (PlatformNotSupportedException)
             {
                 var ep = GetIPEndPoint(_endpoint);
+                if (_isSocketDisposed) return false;
                 _socket.Connect(ep.Address, ep.Port);
             }
 
@@ -111,8 +113,7 @@ void Cancel()
                 }
                 else
                 {
-                    _socket.Dispose();
-                    _socket = null;
+                    DisposeSocket();
                 }
             }
 
@@ -133,17 +134,24 @@ void Cancel()
                 {
                     _inputStream = new NetworkStream(_socket);
                 }
+
+                return true;
             }
             else
             {
                 throw new TimeoutException($"Could not connect to {_endpoint}.");
             }
         }
 
-        public async Task ConnectAsync()
+        public async Task<bool> ConnectAsync()
         {
             bool success = false;
 
+            if (_isSocketDisposed)
+            {
+                return false;
+            }
+
             try
             {
                 var connTask = _socket.ConnectAsync(_endpoint);
@@ -156,8 +164,7 @@ public async Task ConnectAsync()
                 {
                     if (_socket != null)
                     {
-                        _socket.Dispose();
-                        _socket = null;
+                        DisposeSocket();
                     }
 
                     throw new TimeoutException($"Timeout to connect to {_endpoint}.");
@@ -166,6 +173,7 @@ public async Task ConnectAsync()
             catch (PlatformNotSupportedException)
             {
                 var ep = GetIPEndPoint(_endpoint);
+                if (_isSocketDisposed) return false;
                 await _socket.ConnectAsync(ep.Address, ep.Port);
             }
 
@@ -177,8 +185,7 @@ public async Task ConnectAsync()
                 }
                 else
                 {
-                    _socket.Dispose();
-                    _socket = null;
+                    DisposeSocket();
                 }
             }
 
@@ -199,6 +206,8 @@ await _sslStream.AuthenticateAsClientAsync(
                 {
                     _inputStream = new NetworkStream(_socket);
                 }
+
+                return true;
             }
             else
             {
@@ -333,7 +342,7 @@ protected void Dispose(bool disposing)
                 }
                 catch (Exception e)
                 {
-                    _logger.LogError(nameof(PooledSocket), e);
+                    _logger.LogError(e, nameof(PooledSocket));
                 }
             }
             else
@@ -352,8 +361,17 @@ void IDisposable.Dispose()
 
         private void CheckDisposed()
         {
-            if (_socket == null)
+            if (_isSocketDisposed || _socket == null)
+            {
                 throw new ObjectDisposedException("PooledSocket");
+            }
+        }
+
+        private void DisposeSocket()
+        {
+            _isSocketDisposed = true;
+            _socket.Dispose();
+            _socket = null;
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,10 @@ public partial class PooledSocket : IDisposable`
`18`	`18`	`private readonly ILogger _logger;`
`19`	`19`
`20`	`20`	`private bool _isAlive;`
`21`		`- private bool _useSslStream;`
`22`		`- private bool _useIPv6;`
	`21`	`+ private readonly bool _useSslStream;`
	`22`	`+ private readonly bool _useIPv6;`
`23`	`23`	`private Socket _socket;`
	`24`	`+ private bool _isSocketDisposed;`
`24`	`25`	`private readonly EndPoint _endpoint;`
`25`	`26`	`private readonly int _connectionTimeout;`
`26`	`27`
`@@ -74,7 +75,7 @@ public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan rece`
`74`	`75`	`_socket = socket;`
`75`	`76`	`}`
`76`	`77`
`77`		`- public void Connect()`
	`78`	`+ public bool Connect()`
`78`	`79`	`{`
`79`	`80`	`bool success = false;`
`80`	`81`
`@@ -86,20 +87,21 @@ void Cancel()`
`86`	`87`	`{`
`87`	`88`	`if (_socket != null && !_socket.Connected)`
`88`	`89`	`{`
`89`		`- _socket.Dispose();`
`90`		`- _socket = null;`
	`90`	`+ DisposeSocket();`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`cts.Token.Register(Cancel);`
`95`	`95`
`96`	`96`	`try`
`97`	`97`	`{`
	`98`	`+ if (_isSocketDisposed) return false;`
`98`	`99`	`_socket.Connect(_endpoint);`
`99`	`100`	`}`
`100`	`101`	`catch (PlatformNotSupportedException)`
`101`	`102`	`{`
`102`	`103`	`var ep = GetIPEndPoint(_endpoint);`
	`104`	`+ if (_isSocketDisposed) return false;`
`103`	`105`	`_socket.Connect(ep.Address, ep.Port);`
`104`	`106`	`}`
`105`	`107`
`@@ -111,8 +113,7 @@ void Cancel()`
`111`	`113`	`}`
`112`	`114`	`else`
`113`	`115`	`{`
`114`		`- _socket.Dispose();`
`115`		`- _socket = null;`
	`116`	`+ DisposeSocket();`
`116`	`117`	`}`
`117`	`118`	`}`
`118`	`119`
`@@ -133,17 +134,24 @@ void Cancel()`
`133`	`134`	`{`
`134`	`135`	`_inputStream = new NetworkStream(_socket);`
`135`	`136`	`}`
	`137`	`+`
	`138`	`+ return true;`
`136`	`139`	`}`
`137`	`140`	`else`
`138`	`141`	`{`
`139`	`142`	`throw new TimeoutException($"Could not connect to {_endpoint}.");`
`140`	`143`	`}`
`141`	`144`	`}`
`142`	`145`
`143`		`- public async Task ConnectAsync()`
	`146`	`+ public async Task<bool> ConnectAsync()`
`144`	`147`	`{`
`145`	`148`	`bool success = false;`
`146`	`149`
	`150`	`+ if (_isSocketDisposed)`
	`151`	`+ {`
	`152`	`+ return false;`
	`153`	`+ }`
	`154`	`+`
`147`	`155`	`try`
`148`	`156`	`{`
`149`	`157`	`var connTask = _socket.ConnectAsync(_endpoint);`
`@@ -156,8 +164,7 @@ public async Task ConnectAsync()`
`156`	`164`	`{`
`157`	`165`	`if (_socket != null)`
`158`	`166`	`{`
`159`		`- _socket.Dispose();`
`160`		`- _socket = null;`
	`167`	`+ DisposeSocket();`
`161`	`168`	`}`
`162`	`169`
`163`	`170`	`throw new TimeoutException($"Timeout to connect to {_endpoint}.");`
`@@ -166,6 +173,7 @@ public async Task ConnectAsync()`
`166`	`173`	`catch (PlatformNotSupportedException)`
`167`	`174`	`{`
`168`	`175`	`var ep = GetIPEndPoint(_endpoint);`
	`176`	`+ if (_isSocketDisposed) return false;`
`169`	`177`	`await _socket.ConnectAsync(ep.Address, ep.Port);`
`170`	`178`	`}`
`171`	`179`
`@@ -177,8 +185,7 @@ public async Task ConnectAsync()`
`177`	`185`	`}`
`178`	`186`	`else`
`179`	`187`	`{`
`180`		`- _socket.Dispose();`
`181`		`- _socket = null;`
	`188`	`+ DisposeSocket();`
`182`	`189`	`}`
`183`	`190`	`}`
`184`	`191`
`@@ -199,6 +206,8 @@ await _sslStream.AuthenticateAsClientAsync(`
`199`	`206`	`{`
`200`	`207`	`_inputStream = new NetworkStream(_socket);`
`201`	`208`	`}`
	`209`	`+`
	`210`	`+ return true;`
`202`	`211`	`}`
`203`	`212`	`else`
`204`	`213`	`{`
`@@ -333,7 +342,7 @@ protected void Dispose(bool disposing)`
`333`	`342`	`}`
`334`	`343`	`catch (Exception e)`
`335`	`344`	`{`
`336`		`- _logger.LogError(nameof(PooledSocket), e);`
	`345`	`+ _logger.LogError(e, nameof(PooledSocket));`
`337`	`346`	`}`
`338`	`347`	`}`
`339`	`348`	`else`
`@@ -352,8 +361,17 @@ void IDisposable.Dispose()`
`352`	`361`
`353`	`362`	`private void CheckDisposed()`
`354`	`363`	`{`
`355`		`- if (_socket == null)`
	`364`	`+ if (_isSocketDisposed \|\| _socket == null)`
	`365`	`+ {`
`356`	`366`	`throw new ObjectDisposedException("PooledSocket");`
	`367`	`+ }`
	`368`	`+ }`
	`369`	`+`
	`370`	`+ private void DisposeSocket()`
	`371`	`+ {`
	`372`	`+ _isSocketDisposed = true;`
	`373`	`+ _socket.Dispose();`
	`374`	`+ _socket = null;`
`357`	`375`	`}`
`358`	`376`
`359`	`377`	`/// <summary>`