not working version with ReadWriteLock, tbd

Author: Dmitry-Bryliuk

src/tarantool.client/LogicalConnectionManager.cs

@@ -17,9 +17,7 @@ public class LogicalConnectionManager : ILogicalConnection
 
         private LogicalConnection _droppableLogicalConnection;
 
-        private readonly ManualResetEvent _connected = new ManualResetEvent(false);
-
-        private readonly AutoResetEvent _reconnectAvailable = new AutoResetEvent(true);
+        private readonly ReaderWriterLockSlim _connectionLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
         private Timer _timer;
 
@@ -29,13 +27,18 @@ public class LogicalConnectionManager : ILogicalConnection
 
         private const int _pingTimerInterval = 100;
 
-        private int _pingCheckInterval = 1000;
+        private readonly int _pingCheckInterval = 1000;
 
         private DateTimeOffset _nextPingTime = DateTimeOffset.MinValue;
 
         public LogicalConnectionManager(ClientOptions options)
         {
             _clientOptions = options;
+
+            if (_clientOptions.ConnectionOptions.PingCheckInterval >= 0)
+            {
+                _pingCheckInterval = _clientOptions.ConnectionOptions.PingCheckInterval;
+            }
         }
 
         public void Dispose()
@@ -51,26 +54,43 @@ public void Dispose()
 
         public async Task Connect()
         {
-            _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Connecting...");
+            if (!_connectionLock.TryEnterUpgradeableReadLock(_connectionTimeout))
+            {
+                throw ExceptionHelper.NotConnected();
+            }
 
-            _connected.Reset();
+            try
+            {
+                if (this.IsConnected())
+                {
+                    return;
+                }
 
-            var _newConnection = new LogicalConnection(_clientOptions, _requestIdCounter);
-            await _newConnection.Connect();
-            Interlocked.Exchange(ref _droppableLogicalConnection, _newConnection)?.Dispose();
+                _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Connecting...");
 
-            _connected.Set();
+                _connectionLock.EnterWriteLock();
 
-            _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Connected...");
+                try
+                {
+                    var _newConnection = new LogicalConnection(_clientOptions, _requestIdCounter);
+                    await _newConnection.Connect();
+                    Interlocked.Exchange(ref _droppableLogicalConnection, _newConnection)?.Dispose();
 
-            if (_clientOptions.ConnectionOptions.PingCheckInterval >= 0)
-            {
-                _pingCheckInterval = _clientOptions.ConnectionOptions.PingCheckInterval;
-            }
+                    _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Connected...");
 
-            if (_pingCheckInterval > 0)
+                    if (_pingCheckInterval > 0 && _timer == null)
+                    {
+                        //_timer = new Timer(x => CheckPing(), null, _pingTimerInterval, Timeout.Infinite);
+                    }
+                }
+                finally
+                {
+                    _connectionLock.ExitWriteLock();
+                }
+            }
+            finally
             {
-                _timer = new Timer(x => CheckPing(), null, _pingTimerInterval, Timeout.Infinite);
+                _connectionLock.ExitUpgradeableReadLock();
             }
         }
 
@@ -80,19 +100,12 @@ private void CheckPing()
         {
             try
             {
-                LogicalConnection savedConnection = _droppableLogicalConnection;
-
-                if (_nextPingTime > DateTimeOffset.UtcNow || savedConnection == null || !savedConnection.IsConnected())
+                if (_nextPingTime > DateTimeOffset.UtcNow)
                 {
                     return;
                 }
 
-                Task task = savedConnection.SendRequestWithEmptyResponse(_pingRequest);
-                if (Task.WaitAny(task) != 0 || task.Status != TaskStatus.RanToCompletion)
-                {
-                    _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Ping failed, dropping logical conection...");
-                    savedConnection.Dispose();
-                }
+                Task.WaitAny(SendRequestWithEmptyResponse(_pingRequest));
             }
             finally
             {
@@ -105,36 +118,18 @@ private void CheckPing()
 
         public bool IsConnected()
         {
-            return _droppableLogicalConnection?.IsConnected() ?? false;
-        }
-
-        private async Task EnsureConnection()
-        {
-            if (_connected.WaitOne(_connectionTimeout) && IsConnected())
-            {
-                return;
-            }
-
-            _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Connection lost, wait for reconnect...");
-
-            if (!_reconnectAvailable.WaitOne(_connectionTimeout))
+            if (!_connectionLock.TryEnterReadLock(_connectionTimeout))
             {
-                _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Failed to get lock for reconnect");
-                throw ExceptionHelper.NotConnected();
+                return false;
             }
 
             try
             {
-                if (!IsConnected())
-                {
-                    await Connect();
-                }
-
-                _clientOptions.LogWriter?.WriteLine($"{nameof(LogicalConnectionManager)}: Connection reacquired");
+                return _droppableLogicalConnection?.IsConnected() ?? false;
             }
             finally
             {
-                _reconnectAvailable.Set();
+                _connectionLock.ExitReadLock();
             }
         }
 
@@ -148,7 +143,7 @@ private void ScheduleNextPing()
 
         public async Task<DataResponse<TResponse[]>> SendRequest<TRequest, TResponse>(TRequest request) where TRequest : IRequest
         {
-            await EnsureConnection();
+            await Connect();
 
             var result = await _droppableLogicalConnection.SendRequest<TRequest, TResponse>(request);
 
@@ -159,7 +154,7 @@ public async Task<DataResponse<TResponse[]>> SendRequest<TRequest, TResponse>(TR
 
         public async Task SendRequestWithEmptyResponse<TRequest>(TRequest request) where TRequest : IRequest
         {
-            await EnsureConnection();
+            await Connect();
 
             await _droppableLogicalConnection.SendRequestWithEmptyResponse(request);