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; }