private void AddConnectionToPool(PooledConnection pooledConnection)
{
if (_pool.All(e => e.Connection != pooledConnection.Connection) && pooledConnection.Connection.State == ConnectionState.Open)
{
_pool.Add(pooledConnection);
}
}
public void ShouldAddPooledConnectionErrorHandler()
{
var mockedSocketConn = new Mock <IConnection>();
var conn = new PooledConnection(mockedSocketConn.Object);
mockedSocketConn.Verify(x => x.AddConnectionErrorHander(It.IsAny <PooledConnection.PooledConnectionErrorHandler>()), Times.Once);
}
public IPooledConnection CreateNewPooledConnection()
{
PooledConnection conn = null;
try
{
_statistics?.IncrementConnectionToCreate();
conn = _fakeConnection != null
? new PooledConnection(_fakeConnection, Release)
: new PooledConnection(new SocketConnection(_uri, _connectionSettings, _logger), Release);
conn.Init();
_statistics?.IncrementConnectionCreated();
return(conn);
}
catch
{
_statistics?.IncrementConnectionFailedToCreate();
// shut down and clean all the resources of the conneciton if failed to establish
if (conn != null)
{
CloseConnection(conn);
}
throw;
}
}
static async Task <CachedWorld[]> LoadUncachedQueries(int id, int i, int count, CachedWorld[] result)
{
using var pooledConnection = new PooledConnection(DataProvider.ConnectionString);
await pooledConnection.OpenAsync();
var(pooledCommand, dbDataParameter) = CreateReadCommand(pooledConnection);
using (pooledCommand)
{
Func <ICacheEntry, Task <CachedWorld> > create = async(entry) =>
{
return(await ReadSingleRow(pooledCommand));
};
var cacheKeys = _cacheKeys;
var key = cacheKeys[id];
dbDataParameter.Value = id;
for (; i < result.Length; i++)
{
result[i] = await _cache.GetOrCreateAsync <CachedWorld>(key, create);
id = _random.Next(1, 10001);
dbDataParameter.Value = id;
key = cacheKeys[id];
}
}
return(result);
}
public List <PurOrderSummary> GetByVendorProduct(VendorProductId vendorProductId)
{
List <PurOrderSummary> results = new List <PurOrderSummary>();
using (PooledConnection pooledCon = GetPooledConnection())
{
using (SqlCommand cmd = SqlHelper.CreateProc("dbo.GetPurOrderByVendorProduct", pooledCon))
{
SqlHelper.AddParamInputId(cmd, "@VendorProductId", vendorProductId.Value);
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
PurOrderSummary sum = new PurOrderSummary();
sum.VendorId = new VendorId((int)reader["VendorId"]);
sum.PurOrderId = new PurOrderId((int)reader["PurOrderId"]);
sum.OrderDate = (DateTime)reader["OrderDate"];
sum.QtyOrdered = (int)reader["QtyOrdered"];
object orderedEaches = reader["OrderedEaches"];
sum.OrderedEaches = (byte)orderedEaches != 0;
if (sum.OrderedEaches)
{
sum.EachesEquivalent = sum.QtyOrdered;
}
else
{
sum.EachesEquivalent = sum.QtyOrdered * (int)reader["CountInCase"];
}
results.Add(sum);
}
}
}
}
return(results);
}
private PooledConnection CreateConnection(ConnectionFactory connectionFactory)
{
var connectionId = GetConnectionId(connectionFactory);
TryRemoveConnection(connectionId);
s_logger.Value.DebugFormat("RMQMessagingGateway: Creating connection to Rabbit MQ endpoint {0}", connectionFactory.Endpoint);
connectionFactory.RequestedHeartbeat = _connectionHeartbeat;
connectionFactory.RequestedConnectionTimeout = 5000;
connectionFactory.SocketReadTimeout = 5000;
connectionFactory.SocketWriteTimeout = 5000;
var connection = connectionFactory.CreateConnection(_connectionName);
s_logger.Value.DebugFormat("RMQMessagingGateway: new connected to {0} added to pool named {1}", connection.Endpoint, connection.ClientProvidedName);
EventHandler <ShutdownEventArgs> ShutdownHandler = delegate { TryRemoveConnection(connectionId); };
connection.ConnectionShutdown += ShutdownHandler;
var pooledConnection = new PooledConnection {
Connection = connection, ShutdownHandler = ShutdownHandler
};
s_connectionPool.Add(connectionId, pooledConnection);
return(pooledConnection);
}
// Return a connection to the pool for later use
internal void ReturnPooledConnection(PooledConnection pooledConnection)
{
lock (_pool)
{
AddConnectionToPool(pooledConnection);
}
}
public ConnectionWrapper(PooledConnection oPooled)
{
Connection = oPooled.Connection;
Pooled = oPooled;
IsOpen = false;
Transaction = null;
} // constructor
private void CloseConnection(PooledConnection connection)
{
try
{
connection.Dispose();
}
catch { }
}
public void ShouldNotReportErrorIfIsOtherExceptions()
{
var mockResponseHandler = new Mock <IMessageResponseHandler>();
var con = new PooledConnection(SocketConnectionTests.NewSocketConnection(handler: mockResponseHandler.Object));
mockResponseHandler.Setup(x => x.Error).Returns(new ClientException("BLAH", "lalala"));
con.HasUnrecoverableError.Should().BeFalse();
}
public void ShouldReportErrorIfIsTransientException()
{
var mock = MockSocketClient;
var mockResponseHandler = new Mock <IMessageResponseHandler>();
var con = new PooledConnection(new SocketConnection(mock.Object, AuthTokens.None, Logger, mockResponseHandler.Object));
mockResponseHandler.Setup(x => x.Error).Returns(new TransientException("BLAH", "lalala"));
con.HasUnrecoverableError.Should().BeFalse();
}
public async Task ShouldCloseConnectionOnAuthorizationException()
{
var connection = new Mock <IConnection>();
var releaseManager = new Mock <IConnectionReleaseManager>();
var pooledConnection = new PooledConnection(connection.Object, releaseManager.Object);
var resultException = await Record.ExceptionAsync(async() => await pooledConnection.OnErrorAsync(new AuthorizationException("Authorization error")));
releaseManager.Verify(rm => rm.MarkConnectionsForReauthorization(pooledConnection), Times.Once());
}
public async Task ShouldReturnConnectionErrorOnErrorAsync(Type exceptionType)
{
var connection = new Mock <IConnection>().Object;
var releaseManager = new Mock <IConnectionReleaseManager>().Object;
var pooledConnection = new PooledConnection(connection, releaseManager);
var exception = (Exception)Activator.CreateInstance(exceptionType);
var resultingException = await Record.ExceptionAsync(async() => await pooledConnection.OnErrorAsync(exception));
Assert.Equal(resultingException.GetType(), typeof(ServiceUnavailableException));
}
public async Task ShouldHaveUnrecoverableErrorOnErrorAsync(Type exceptionType)
{
var connection = new Mock <IConnection>().Object;
var releaseManager = new Mock <IConnectionReleaseManager>().Object;
var pooledConnection = new PooledConnection(connection, releaseManager);
var exception = (Exception)Activator.CreateInstance(exceptionType, "Testing exception");
var resultingException = await Record.ExceptionAsync(async() => await pooledConnection.OnErrorAsync(exception));
Assert.Equal(resultingException.GetType(), exceptionType);
Assert.True(pooledConnection.HasUnrecoverableError);
}
// Get a connection from the pool. If one does not exist, create it.
public PooledConnection GetConnection(string connectionString)
{
PooledConnection connection = GetConnectionFromPool(connectionString);
if (connection == null)
{
// Create a new connection, since one was not found in the pool. After use it will be returned to the pool
connection = CreatePooledConnection(connectionString);
}
return(connection);
}
public static async Task <World[]> ReadMultipleRows(int count)
{
int j = 0;
var ids = PlatformBenchmarks.BatchUpdateString.Ids;
var worlds = new World[count];
string queryString;
if (_queriesMultipleRows[count] != null)
{
queryString = _queriesMultipleRows[count];
}
else
{
var stringBuilder = PlatformBenchmarks.StringBuilderCache.Acquire();
for (int i = 0; i < count; i++)
{
stringBuilder.Append("SELECT * FROM world WHERE id=?;");
}
queryString = _queriesMultipleRows[count] = PlatformBenchmarks.StringBuilderCache.GetStringAndRelease(stringBuilder);
}
using var pooledConnection = new PooledConnection(DataProvider.ConnectionString);
await pooledConnection.OpenAsync();
using var pooledCommand = new PooledCommand(queryString, pooledConnection);
for (int i = 0; i < count; i++)
{
pooledCommand.CreateParameter(ids[i], DbType.Int32, _random.Next(1, 10001));
}
var dataReader = await pooledCommand.ExecuteReaderAsync(CommandBehavior.Default& CommandBehavior.SequentialAccess);
do
{
dataReader.Read();
worlds[j] = new World
{
Id = dataReader.GetInt32(0),
RandomNumber = dataReader.GetInt32(1)
};
j++;
} while (await dataReader.NextResultAsync());
dataReader.Close();
return(worlds);
}
public void ShouldBeFalseWhenConnectionHasUnrecoverableError()
{
var mockClient = new Mock <ISocketClient>();
mockClient.Setup(x => x.IsOpen).Returns(false);
var mockResponseHandler = new Mock <IMessageResponseHandler>();
mockResponseHandler.Setup(x => x.Error).Returns(new DatabaseException()); // unrecoverable error
var conn = new PooledConnection(SocketConnectionTests.NewSocketConnection(mockClient.Object, mockResponseHandler.Object));
conn.IsOpen.Should().BeFalse();
}
public void ShouldBeFalseWhenConectionIsNotOpen()
{
var mockClient = new Mock <ISocketClient>();
mockClient.Setup(x => x.IsOpen).Returns(false);
var mockResponseHandler = new Mock <IMessageResponseHandler>();
mockResponseHandler.Setup(x => x.Error).Returns(new ClientException()); // has no unrecoverable error
var conn = new PooledConnection(new SocketConnection(mockClient.Object, AuthTokens.None, Logger, mockResponseHandler.Object));
conn.IsOpen.Should().BeFalse();
}
public void ShouldReturnTrueWhenIsHealthy()
{
var mockClient = new Mock <ISocketClient>();
mockClient.Setup(x => x.IsOpen).Returns(true);
var mockResponseHandler = new Mock <IMessageResponseHandler>();
mockResponseHandler.Setup(x => x.Error).Returns(new ClientException()); // has no unrecoverable error
var conn = new PooledConnection(SocketConnectionTests.NewSocketConnection(mockClient.Object, mockResponseHandler.Object));
conn.IsOpen.Should().BeTrue();
}
} // GetFirst
public virtual ConnectionWrapper GetPersistent()
{
var pc = new PooledConnection {
IsPooled = false,
Connection = CreateConnection()
};
lock (ms_oFreeConnectionLock)
pc.PoolItemID = ++ms_nFreeConnectionGenerator;
Log.Debug("A non-pooled connection {0} has been created.", pc.Name);
return(new ConnectionWrapper(pc).Open());
} // GetPersistent
public static async Task <World> LoadSingleQueryRow()
{
using var pooledConnection = new PooledConnection(DataProvider.ConnectionString);
await pooledConnection.OpenAsync();
var(pooledCommand, _) = CreateReadCommand(pooledConnection);
using (pooledCommand)
{
var world = await ReadSingleRow(pooledCommand);
return(world);
}
}
public static async Task <World[]> LoadMultipleUpdatesRows(int count)
{
var worlds = new World[count];
using var pooledConnection = new PooledConnection(DataProvider.ConnectionString);
await pooledConnection.OpenAsync();
var(queryCommand, dbDataParameter) = CreateReadCommand(pooledConnection);
using (queryCommand)
{
for (int i = 0; i < count; i++)
{
worlds[i] = await ReadSingleRow(queryCommand);
dbDataParameter.Value = _random.Next(1, 10001);
}
}
using var updateCommand = new PooledCommand(PlatformBenchmarks.BatchUpdateString.Query(count), pooledConnection);
var ids = PlatformBenchmarks.BatchUpdateString.Ids;
var randoms = PlatformBenchmarks.BatchUpdateString.Randoms;
#if !MYSQL
var jds = PlatformBenchmarks.BatchUpdateString.Jds;
#endif
for (int i = 0; i < count; i++)
{
var randomNumber = _random.Next(1, 10001);
updateCommand.CreateParameter(ids[i], DbType.Int32, worlds[i].Id);
updateCommand.CreateParameter(randoms[i], DbType.Int32, randomNumber);
worlds[i].RandomNumber = randomNumber;
}
#if !MYSQL
for (int i = 0; i < count; i++)
{
updateCommand.CreateParameter(jds[i], DbType.Int32, worlds[i].Id);
}
#endif
await updateCommand.ExecuteNonQueryAsync();
return(worlds);
}
/// <summary>
/// <inheritdoc cref="GetPooledConnection(out SqlConnection)"/>
/// Only use this overload if it is safe to bypass the normal scheduler check. Only startup code (which runs
/// before any reads/writes/flushes happen) should use this.
/// </summary>
private PooledConnection GetPooledConnection(bool checkScheduler, out SqlConnection connection)
{
if (checkScheduler)
{
var scheduler = TaskScheduler.Current;
if (scheduler != _readerWriterLock.ConcurrentScheduler && scheduler != _readerWriterLock.ExclusiveScheduler)
{
throw new InvalidOperationException("Cannot get a connection to the DB unless running on one of _readerWriterLock's schedulers");
}
}
var result = new PooledConnection(this, GetConnection());
connection = result.Connection;
return(result);
}
private ConnectionPool(IRemoteConnection conn, int size)
{
_available = new Promise <bool>();
_ref = conn;
_pool = new PooledConnection[size];
for (var i = 0; i < size; i++)
{
var idx = i;
conn.Clone(true)
.Done(c =>
{
_pool[idx] = new PooledConnection(c);
_available.Resolve(true);
});
}
}
public void ShouldReportErrorIfIsDatabaseException()
{
var mockResponseHandler = new Mock <IMessageResponseHandler>();
var con = new PooledConnection(SocketConnectionTests.NewSocketConnection(handler: mockResponseHandler.Object));
mockResponseHandler.Setup(x => x.HasError).Returns(true);
mockResponseHandler.Setup(x => x.Error).Returns(new DatabaseException("BLAH", "lalala"));
var exception = Record.Exception(() => con.ReceiveOne());
exception.Should().BeOfType <DatabaseException>();
exception.Message.Should().Be("lalala");
con.HasUnrecoverableError.Should().BeTrue();
mockResponseHandler.VerifySet(x => x.Error = null, Times.Once);
}
public static async Task PopulateCache()
{
using var pooledConnection = new PooledConnection(DataProvider.ConnectionString);
await pooledConnection.OpenAsync();
var(pooledCommand, dbDataParameter) = CreateReadCommand(pooledConnection);
using (pooledCommand)
{
var cacheKeys = _cacheKeys;
var cache = _cache;
for (var i = 1; i < 10001; i++)
{
dbDataParameter.Value = i;
cache.Set <CachedWorld>(cacheKeys[i], await ReadSingleRow(pooledCommand));
}
}
}
private PooledConnection GetConnection()
{
PooledConnection result = null;
for (var i = 0; i < _pool.Length; i++)
{
var curr = _pool[i];
if (curr != null)
{
if (result == null)
{
result = curr;
}
else if (result.ConcurrentQueries > curr.ConcurrentQueries)
{
result = curr;
}
}
}
return(result);
}
public static async Task <World[]> LoadMultipleQueriesRows(int count)
{
var worlds = new World[count];
using var pooledConnection = new PooledConnection(DataProvider.ConnectionString);
await pooledConnection.OpenAsync();
var(pooledCommand, dbDataParameter) = CreateReadCommand(pooledConnection);
using (pooledCommand)
{
for (int i = 0; i < count; i++)
{
worlds[i] = await ReadSingleRow(pooledCommand);
dbDataParameter.Value = _random.Next(1, 10001);
}
}
return(worlds);
}
} // GetPersistentTransaction
public ConnectionWrapper TakeFromPool()
{
PooledConnection pc = ms_oPool.Give();
if (pc == null)
{
throw new NullReferenceException("Cannot create a DB connection.");
}
if (pc.Connection == null)
{
pc.Connection = CreateConnection();
}
// uint nReminder = pc.OutOfPoolCount % 10;
//string sSuffix = "th";
//switch (nReminder) {
//case 1:
// sSuffix = "st";
// break;
//case 2:
// sSuffix = "nd";
// break;
//case 3:
// sSuffix = "rd";
// break;
//} // switch
//Log.Debug("An object (i.e. connection) {3}({2}) is taken from the pool for the {0}{1} time.",
// pc.OutOfPoolCount,
// sSuffix,
// pc.PoolItemID,
// pc.Name
//);
return(new ConnectionWrapper(pc));
} // TakeFromPool
private PooledConnection CreateConnection(ConnectionFactory connectionFactory)
{
var connectionId = GetConnectionId(connectionFactory);
TryRemoveConnection(connectionId);
s_logger.LogDebug("RmqMessageGatewayConnectionPool: Creating subscription to Rabbit MQ endpoint {URL}", connectionFactory.Endpoint);
connectionFactory.RequestedHeartbeat = TimeSpan.FromSeconds(_connectionHeartbeat);
connectionFactory.RequestedConnectionTimeout = TimeSpan.FromMilliseconds(5000);
connectionFactory.SocketReadTimeout = TimeSpan.FromMilliseconds(5000);
connectionFactory.SocketWriteTimeout = TimeSpan.FromMilliseconds(5000);
var connection = connectionFactory.CreateConnection(_connectionName);
s_logger.LogDebug("RmqMessageGatewayConnectionPool: new connected to {URL} added to pool named {ProviderName}", connection.Endpoint, connection.ClientProvidedName);
void ShutdownHandler(object sender, ShutdownEventArgs e)
{
s_logger.LogWarning("RmqMessageGatewayConnectionPool: The subscription {URL} has been shutdown due to {ErrorMessage}", connection.Endpoint, e.ToString());
lock (s_lock)
{
TryRemoveConnection(connectionId);
}
}
connection.ConnectionShutdown += ShutdownHandler;
var pooledConnection = new PooledConnection {
Connection = connection, ShutdownHandler = ShutdownHandler
};
s_connectionPool.Add(connectionId, pooledConnection);
return(pooledConnection);
}
private void RemoveConnection(PooledConnection connection)
{
if (_removingConnectionEventHandler != null)
{
_removingConnectionEventHandler(new ConnectionPoolRemovingConnectionEvent(connection.ConnectionId));
}
var stopwatch = Stopwatch.StartNew();
connection.Dispose();
stopwatch.Stop();
if (_removedConnectionEventHandler != null)
{
_removedConnectionEventHandler(new ConnectionPoolRemovedConnectionEvent(connection.ConnectionId, stopwatch.Elapsed));
}
}
private void RemoveConnection(PooledConnection connection)
{
if (_listener != null)
{
_listener.ConnectionPoolBeforeRemovingAConnection(connection.ConnectionId);
}
var stopwatch = Stopwatch.StartNew();
connection.Dispose();
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionPoolAfterRemovingAConnection(connection.ConnectionId, stopwatch.Elapsed);
}
}
private IDbConnection GetConnection()
{
while(true) {
PooledConnection conn = null;
int idx;
lock(this._Connections) {
idx = this.FindPool();
if(idx >= 0) {
conn = this._Connections[idx];
if(conn != null) {
// reuse
conn.Wait();
if(conn.State == ConnectionState.Open) {
return conn;
} else {
continue;
}
} else {
// new
conn = new PooledConnection(this._Factory.CreateConnection());
conn.ConnectionString = this._ConnectionString;
conn.Open();
this._Connections[idx] = conn;
conn.Wait();
return conn;
}
}
}
if(idx < 0) {
// wait
WaitHandle.WaitAny(this._Connections.Where(c => c != null).Select(c => c.WaitHandle).ToArray());
}
}
}
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...
}
public void Return(PooledConnection connection)
{
if (connection.IsExpired)
{
RemoveConnection(connection);
return;
}
lock (_lock)
{
_connections.Add(connection);
}
}
public AcquiredConnection(ExclusiveConnectionPool connectionPool, PooledConnection pooledConnection)
: base(pooledConnection)
{
_connectionPool = connectionPool;
_pooledConnection = pooledConnection;
_pooledConnection.IncrementReferenceCount();
}
private void ReleaseConnection(PooledConnection connection)
{
if (_state.Value == State.Disposed)
{
connection.Dispose();
return;
}
if (_listener != null)
{
_listener.ConnectionPoolBeforeCheckingInAConnection(connection.ConnectionId);
}
var stopwatch = Stopwatch.StartNew();
_connectionHolder.Return(connection);
_poolQueue.Release();
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionPoolAfterCheckingInAConnection(connection.ConnectionId, stopwatch.Elapsed);
}
}
// constructors
public AcquiredConnection(PooledConnection wrapped)
: base(wrapped)
{
_pooledConnection = Ensure.IsNotNull(wrapped, "wrapped");
_pooledConnection.IncrementReferenceCount();
}
private void ReleaseConnection(PooledConnection connection)
{
if (_state.Value == State.Disposed)
{
connection.Dispose();
return;
}
if (_checkingInConnectionEventHandler != null)
{
_checkingInConnectionEventHandler(new ConnectionPoolCheckingInConnectionEvent(connection.ConnectionId));
}
var stopwatch = Stopwatch.StartNew();
_connectionHolder.Return(connection);
_poolQueue.Release();
stopwatch.Stop();
if (_checkedInConnectionEventHandler != null)
{
_checkedInConnectionEventHandler(new ConnectionPoolCheckedInConnectionEvent(connection.ConnectionId, stopwatch.Elapsed));
}
}
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;
}
