public async Task <IConnectionHandle> AcquireConnectionAsync(CancellationToken cancellationToken)
{
try
{
StartCheckingOut();
var stopwatch = Stopwatch.StartNew();
_poolQueueWaitResult = await _pool._maxConnectionsQueue.WaitSignaledAsync(_timeout, cancellationToken).ConfigureAwait(false);
if (_poolQueueWaitResult == SemaphoreSlimSignalable.SemaphoreWaitResult.Entered)
{
PooledConnection pooledConnection = null;
var timeout = EnsureTimeout(stopwatch);
using (var connectionCreator = new ConnectionCreator(_pool, timeout))
{
pooledConnection = await connectionCreator.CreateOpenedOrReuseAsync(cancellationToken).ConfigureAwait(false);
}
return(EndCheckingOut(pooledConnection, stopwatch));
}
stopwatch.Stop();
throw CreateException(stopwatch);
}
catch (Exception ex)
{
HandleException(ex);
throw;
}
}
private void ReleaseConnection(PooledConnection connection)
{
if (_checkingInConnectionEventHandler != null)
{
_checkingInConnectionEventHandler(new ConnectionPoolCheckingInConnectionEvent(connection.ConnectionId, EventContext.OperationId));
}
if (_checkedInConnectionEventHandler != null)
{
_checkedInConnectionEventHandler(new ConnectionPoolCheckedInConnectionEvent(connection.ConnectionId, TimeSpan.Zero, EventContext.OperationId));
}
_checkOutReasonCounter.Decrement(connection.CheckOutReason);
if (!connection.IsExpired && !_poolState.IsDisposed)
{
_connectionHolder.Return(connection);
}
else
{
_serviceStates.DecrementConnectionCount(connection.Description?.ServiceId);
_connectionHolder.RemoveConnection(connection);
}
if (!_poolState.IsDisposed)
{
_maxConnectionsQueue.Release();
}
}
public AcquiredConnection(ExclusiveConnectionPool connectionPool, PooledConnection pooledConnection)
: base(pooledConnection)
{
_connectionPool = connectionPool;
_pooledConnection = pooledConnection;
_pooledConnection.IncrementReferenceCount();
}
public PooledConnection Acquire()
{
PooledConnection result = null;
lock (_lock)
{
while (_connections.Count > 0 && result == null)
{
var lastIndex = _connections.Count - 1;
var connection = _connections[lastIndex];
_connections.RemoveAt(lastIndex);
if (connection.IsExpired)
{
RemoveConnection(connection);
}
else
{
result = connection;
}
}
SignalOrReset();
}
return(result);
}
// private methods
private IConnectionHandle AcquireOrCreateConnection()
{
PooledConnection connection = _pool._connectionHolder.Acquire();
if (connection == null)
{
var addingConnectionEventHandler = _pool._addingConnectionEventHandler;
if (addingConnectionEventHandler != null)
{
addingConnectionEventHandler(new ConnectionPoolAddingConnectionEvent(_pool._serverId, EventContext.OperationId));
}
var stopwatch = Stopwatch.StartNew();
connection = _pool.CreateNewConnection();
stopwatch.Stop();
var addedConnectionEventHandler = _pool._addedConnectionEventHandler;
if (addedConnectionEventHandler != null)
{
addedConnectionEventHandler(new ConnectionPoolAddedConnectionEvent(connection.ConnectionId, stopwatch.Elapsed, EventContext.OperationId));
}
}
var reference = new ReferenceCounted <PooledConnection>(connection, _pool.ReleaseConnection);
return(new AcquiredConnection(_pool, reference));
}
private void ReleaseConnection(PooledConnection connection)
{
if (_checkingInConnectionEventHandler != null)
{
_checkingInConnectionEventHandler(new ConnectionPoolCheckingInConnectionEvent(connection.ConnectionId, EventContext.OperationId));
}
if (_checkedInConnectionEventHandler != null)
{
_checkedInConnectionEventHandler(new ConnectionPoolCheckedInConnectionEvent(connection.ConnectionId, TimeSpan.Zero, EventContext.OperationId));
}
if (!connection.IsExpired && _state.Value != State.Disposed)
{
_connectionHolder.Return(connection);
}
else
{
_connectionHolder.RemoveConnection(connection);
}
if (_state.Value != State.Disposed)
{
_poolQueue.Release();
}
}
public void Return(PooledConnection connection)
{
lock (_lock)
{
_connections.Add(connection);
}
}
public void UntrackInUseConnection(PooledConnection connection)
{
lock (_lockInUse)
{
_connectionsInUse.Remove(connection);
}
}
public void TrackInUseConnection(PooledConnection connection)
{
lock (_lockInUse)
{
_connectionsInUse.Add(connection);
}
}
public void Return(PooledConnection connection)
{
lock (_lock)
{
_connections.Add(connection);
SignalOrReset();
}
}
private PooledConnection CreateNewConnection()
{
var connection = _connectionFactory.CreateConnection(_serverId, _endPoint);
var pooledConnection = new PooledConnection(this, connection);
_connectionCreatedEventHandler?.Invoke(new ConnectionCreatedEvent(connection.ConnectionId, connection.Settings, EventContext.OperationId));
return(pooledConnection);
}
private PooledConnection CreateConnection()
{
var connection = _connectionFactory.CreateConnection(_serverId, _endPoint); // will be initialized by caller outside of the lock
var pooledConnection = new PooledConnection(connection);
_connections.Add(pooledConnection);
return(pooledConnection);
}
public ConnectionCreator(ExclusiveConnectionPool pool, TimeSpan connectingTimeout)
{
_pool = pool;
_connectingTimeout = connectingTimeout;
_connectingWaitStatus = SemaphoreSlimSignalable.SemaphoreWaitResult.None;
_connection = null;
_disposeConnection = true;
_stopwatch = null;
}
public void Return(PooledConnection connection)
{
if (connection.IsExpired)
{
RemoveConnection(connection);
return;
}
_connections.Enqueue(connection);
}
public void Return(PooledConnection connection)
{
UntrackInUseConnection(connection);
lock (_lock)
{
_connections.Add(connection);
SignalOrReset();
}
}
private void StartCreating(CancellationToken cancellationToken)
{
var addingConnectionEvent = new ConnectionPoolAddingConnectionEvent(_pool._serverId, EventContext.OperationId);
_pool._addingConnectionEventHandler?.Invoke(addingConnectionEvent);
cancellationToken.ThrowIfCancellationRequested();
_stopwatch = Stopwatch.StartNew();
_connection = _pool.CreateNewConnection();
}
public void Return(PooledConnection connection)
{
if (connection.IsExpired)
{
RemoveConnection(connection);
return;
}
lock (_lock)
{
_connections.Add(connection);
}
}
private IConnectionHandle EndCheckingOut(PooledConnection pooledConnection, Stopwatch stopwatch)
{
var reference = new ReferenceCounted <PooledConnection>(pooledConnection, _pool.ReleaseConnection);
var connectionHandle = new AcquiredConnection(_pool, reference);
stopwatch.Stop();
var checkedOutConnectionEvent = new ConnectionPoolCheckedOutConnectionEvent(connectionHandle.ConnectionId, stopwatch.Elapsed, EventContext.OperationId);
_pool._checkedOutConnectionEventHandler?.Invoke(checkedOutConnectionEvent);
// no need to release the semaphore
_poolQueueWaitResult = SemaphoreSlimSignalable.SemaphoreWaitResult.None;
return(connectionHandle);
}
public async Task <IConnectionHandle> EnteredPoolAsync(bool enteredPool, CancellationToken cancellationToken)
{
_enteredPool = enteredPool;
PooledConnection connection = null;
if (enteredPool)
{
var timeSpentInWaitQueue = _stopwatch.Elapsed;
using (var connectionCreator = new ConnectionCreator(_pool, _pool._settings.WaitQueueTimeout - timeSpentInWaitQueue))
{
connection = await connectionCreator.CreateOpenedOrReuseAsync(cancellationToken).ConfigureAwait(false);
}
}
return(FinalizePoolEnterance(connection));
}
public IConnectionHandle EnteredPool(bool enteredPool, CancellationToken cancellationToken)
{
_enteredPool = enteredPool;
PooledConnection connection = null;
if (enteredPool)
{
var timeSpentInWaitQueue = _stopwatch.Elapsed;
using (var connectionCreator = new ConnectionCreator(_pool, _pool._settings.WaitQueueTimeout - timeSpentInWaitQueue))
{
connection = connectionCreator.CreateOpenedOrReuse(cancellationToken);
}
}
return(FinalizePoolEnterance(connection));
}
private void RemoveConnection(PooledConnection connection)
{
if (_removingConnectionEventHandler != null)
{
_removingConnectionEventHandler(new ConnectionPoolRemovingConnectionEvent(connection.ConnectionId, EventContext.OperationId));
}
var stopwatch = Stopwatch.StartNew();
connection.Dispose();
stopwatch.Stop();
if (_removedConnectionEventHandler != null)
{
_removedConnectionEventHandler(new ConnectionPoolRemovedConnectionEvent(connection.ConnectionId, stopwatch.Elapsed, EventContext.OperationId));
}
}
private void RemoveConnection(PooledConnection connection)
{
if (_listener != null)
{
_listener.ConnectionPoolBeforeRemovingAConnection(new ConnectionPoolBeforeRemovingAConnectionEvent(connection.ConnectionId));
}
var stopwatch = Stopwatch.StartNew();
connection.Dispose();
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionPoolAfterRemovingAConnection(new ConnectionPoolAfterRemovingAConnectionEvent(connection.ConnectionId, stopwatch.Elapsed));
}
}
public void RemoveConnection(PooledConnection connection)
{
if (_removingConnectionEventHandler != null)
{
_removingConnectionEventHandler(new ConnectionPoolRemovingConnectionEvent(connection.ConnectionId, EventContext.OperationId));
}
var stopwatch = Stopwatch.StartNew();
UntrackInUseConnection(connection); // no op if connection is not in use
connection.Dispose();
stopwatch.Stop();
if (_removedConnectionEventHandler != null)
{
_removedConnectionEventHandler(new ConnectionPoolRemovedConnectionEvent(connection.ConnectionId, stopwatch.Elapsed, EventContext.OperationId));
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (!Disposed)
{
_pooledConnection.DecrementReferenceCount();
if (_pooledConnection.ReferenceCount == 0)
{
_connectionPool.ReleaseConnection(_pooledConnection);
}
}
Disposed = true;
_pooledConnection = null;
_connectionPool = null;
}
// don't call base.Dispose here because we don't want the underlying
// connection to get disposed...
}
private AcquiredConnection FinalizePoolEnterance(PooledConnection pooledConnection)
{
if (pooledConnection != null)
{
var reference = new ReferenceCounted <PooledConnection>(pooledConnection, _pool.ReleaseConnection);
var connectionHandle = new AcquiredConnection(_pool, reference);
var checkedOutConnectionEvent = new ConnectionPoolCheckedOutConnectionEvent(connectionHandle.ConnectionId, _stopwatch.Elapsed, EventContext.OperationId);
_pool._checkedOutConnectionEventHandler?.Invoke(checkedOutConnectionEvent);
return(connectionHandle);
}
else
{
_stopwatch.Stop();
var message = $"Timed out waiting for a connection after {_stopwatch.ElapsedMilliseconds}ms.";
throw new TimeoutException(message);
}
}
private IConnectionHandle AcquireConnection()
{
PooledConnection connection = _connectionHolder.Acquire();
if (connection == null)
{
if (_listener != null)
{
_listener.ConnectionPoolBeforeAddingAConnection(_serverId);
}
var stopwatch = Stopwatch.StartNew();
connection = CreateNewConnection();
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionPoolAfterAddingAConnection(connection.ConnectionId, stopwatch.Elapsed);
}
}
return(new AcquiredConnection(this, connection));
}
public PooledConnection Acquire()
{
PooledConnection result = null;
lock (_lock)
{
while (_connections.Count > 0 && result == null)
{
var lastIndex = _connections.Count - 1;
var connection = _connections[lastIndex];
_connections.RemoveAt(lastIndex);
if (connection.IsExpired)
{
RemoveConnection(connection);
}
else
{
result = connection;
}
}
SignalOrReset();
}
if (result != null)
{
TrackInUseConnection(result);
// This connection can be expired and not disposed by Prune. Dispose if needed
if (result.IsExpired)
{
RemoveConnection(result);
result = null;
}
}
return(result);
}
private IConnectionHandle AcquireConnection()
{
PooledConnection connection = _connectionHolder.Acquire();
if (connection == null)
{
if (_listener != null)
{
_listener.ConnectionPoolBeforeAddingAConnection(new ConnectionPoolBeforeAddingAConnectionEvent(_serverId));
}
var stopwatch = Stopwatch.StartNew();
connection = CreateNewConnection();
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionPoolAfterAddingAConnection(new ConnectionPoolAfterAddingAConnectionEvent(connection.ConnectionId, stopwatch.Elapsed));
}
}
var reference = new ReferenceCounted <PooledConnection>(connection, x => ReleaseConnection(x));
return(new AcquiredConnection(this, reference));
}
private void ReleaseConnection(PooledConnection connection)
{
if (_state.Value == State.Disposed)
{
connection.Dispose();
return;
}
if (_checkingInConnectionEventHandler != null)
{
_checkingInConnectionEventHandler(new ConnectionPoolCheckingInConnectionEvent(connection.ConnectionId, EventContext.OperationId));
}
var stopwatch = Stopwatch.StartNew();
_connectionHolder.Return(connection);
_poolQueue.Release();
stopwatch.Stop();
if (_checkedInConnectionEventHandler != null)
{
_checkedInConnectionEventHandler(new ConnectionPoolCheckedInConnectionEvent(connection.ConnectionId, stopwatch.Elapsed, EventContext.OperationId));
}
}
private void ReleaseConnection(PooledConnection connection)
{
if (_state.Value == State.Disposed)
{
connection.Dispose();
return;
}
if (_listener != null)
{
_listener.ConnectionPoolBeforeCheckingInAConnection(new ConnectionPoolBeforeCheckingInAConnectionEvent(connection.ConnectionId));
}
var stopwatch = Stopwatch.StartNew();
_connectionHolder.Return(connection);
_poolQueue.Release();
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionPoolAfterCheckingInAConnection(new ConnectionPoolAfterCheckingInAConnectionEvent(connection.ConnectionId, stopwatch.Elapsed));
}
}