private static bool TestConnection(ConnectionPoolItem item)
{
try
{
if (Debug)
{
WriteDebug("#pool.test: testing connection " + item.Connection.ServerInfo.ConnectionId);
}
item.Connection.SendCommand(Commands.Ping);
var result = item.Connection.ReadPacket();
if (!PacketReader.IsOkPacket(result))
{
if (Debug)
{
WriteDebug("#pool.test: test failed");
}
return(false);
}
if (Debug)
{
WriteDebug("#pool.test: test succeeded");
}
return(true);
}
catch (Exception e)
{
if (Debug)
{
WriteDebug("#pool.test: test blew up: " + e.Message);
}
return(false);
}
}
private static void Discard(ConnectionPoolItem item)
{
if (Debug)
{
WriteDebug("#pool.discard: closing connection " + item.Connection.ServerInfo.ConnectionId);
}
item.Connection.Shutdown();
}
private void InvokeWithFireAndForgetChoreography(ref ConnectionPoolItem poolItem, ref HttpContext context)
{
byte[] payload = context.Request.Body.ReadToEnd();
context.Response.StatusCode = 200;
IBasicProperties propsIn = poolItem.model.CreateBasicProperties();
ContextAdapter.FillPropertiesFromRequest(propsIn, context);
poolItem.model.BasicPublish(string.Empty, poolItem.queueName, propsIn, payload);
}
private ConnectionPoolItem RecycleConnectionPoolItem(ref ConnectionPoolItem connectionPoolItem)
{
connectionPoolItem.usage++;
if (connectionPoolItem.usage == this.configuration.MaxConnectionAge)
{
connectionPoolItem.model.Close();
connectionPoolItem.model.Dispose();
connectionPoolItem.connection.Close();
connectionPoolItem.connection.Dispose();
return(BuildConnectionPoolItem());
}
return(connectionPoolItem);
}
public static void ReleaseConnection(ConnectionPoolItem connectionItem)
{
lock (Pool)
{
try
{
ConnectionPoolItem connectionPoolItem = Pool.First(item => item == connectionItem);
connectionPoolItem.ConnectionIsUsed = false;
}
catch (Exception e)
{
Console.WriteLine("Das Item:" + connectionItem.Number + " wurde nicht gefunden");
throw;
}
}
}
public static ConnectionPoolItem GetConnection()
{
while (true)
{
lock (Pool)
{
if (Pool.Any(item => item.ConnectionIsUsed == false))
{
ConnectionPoolItem connectionPoolItem = Pool.First(item => item.ConnectionIsUsed == false);
connectionPoolItem.ConnectionIsUsed = true;
return(connectionPoolItem);
}
}
System.Threading.Thread.Sleep(10);
}
}
private void CreatePool()
{
bool oneTimeExec = true;
for (var connectionSeq = 1; connectionSeq <= this.configuration.PoolSize; connectionSeq++)
{
ConnectionPoolItem connectionPoolItem = this.BuildConnectionPoolItem();
if (oneTimeExec)
{
connectionPoolItem.model.QueueDeclare(this.configuration.GetQueueName(), true, false, false, null);
oneTimeExec = false;
}
connectionPool.Enqueue(connectionPoolItem);
}
}
/// <summary>
/// 用于收回指定的连接但不断开连接.
/// </summary>
/// <param name="connection">要收回的连接.</param>
public void ReleaseConnection(IDbConnection connection)
{
if (connection == null)
{
return;
}
lock (poolLocked)
{
IEnumerable <ConnectionPoolItem> items = usingPool.Where(p => Object.ReferenceEquals(connection, p.Connection));
if (items != null && items.Count() > 0)
{
ConnectionPoolItem item = items.First();
usingPool.Remove(item);
IdlePool.Enqueue(item);
}
}
RunForcedRelease();
}
private void InvokeWithRpcChoreography(ref ConnectionPoolItem poolItem, ref HttpContext context)
{
byte[] payload = context.Request.Body.ReadToEnd();
IBasicProperties propsIn = poolItem.model.CreateBasicProperties();
ContextAdapter.FillPropertiesFromRequest(propsIn, context);
using (var rpcClient = new SimpleRpcClient(
model: poolItem.model,
queueName: poolItem.queueName
))
{
payload = rpcClient.Call(propsIn, payload, out IBasicProperties propsOut);
ContextAdapter.FillResponseFromProperties(context, propsOut);
context.Response.Body.Write(payload, 0, payload.Length);
rpcClient.Subscription.Ack();
}
}
internal static void Consume(string key, Connection connection, DateTime?originalTime)
{
if (connection == null)
{
return;
}
if (!Enabled)
{
if (Debug)
{
WriteDebug("#pool.consume: not enabled, discarding " + connection.ServerInfo.ConnectionId);
}
connection.Shutdown();
return;
}
var item = new ConnectionPoolItem(connection, originalTime);
if (!TestConnection(item))
{
Discard(item);
return;
}
lock (Lock)
{
if (!Items.ContainsKey(key))
{
Items[key] = new List <ConnectionPoolItem>();
}
Items[key].Add(item);
if (Debug)
{
WriteDebug("#pool.consume: added connection " + connection.ServerInfo.ConnectionId);
}
}
}
public ConnectionUsable()
{
_connectionPoolItem = ConnectionPool.GetConnection();
}
/// <summary>
/// 从连接池中获取一个数据库连接.
/// </summary>
/// <param name="makeFactory">当连接池为空时用于创建连接的方法.</param>
/// <returns></returns>
public IDbConnection GetConnection(MakeConnectionFactory makeFactory)
{
if (makeFactory == null)
{
throw new ArgumentNullException(nameof(makeFactory));
}
if (IsDisposed)
{
throw new Exception("连接池已被释放.");
}
IDbConnection connection = null;
if (Count < MaximumConnections && IdlePool.Count < 1) // 当连接池中无闲置连接，并且连接数未达上限时创建新的连接.
{
connection = makeFactory();
Add(connection);
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
return(connection);
}
Exception tmpEx = null;
DateTime timeMemory = DateTime.Now;
ConnectionPoolItem poolItem = null;
do
{
if (IsDisposed)
{
tmpEx = new Exception("连接池已被释放.");
break;
}
if (IdlePool.Count > 0)
{
lock (poolLocked)
{
try
{
poolItem = IdlePool.Dequeue();
usingPool.Add(poolItem);
}
catch (Exception Ex)
{
tmpEx = Ex;
break;
}
}
break;
}
Thread.Sleep(1);
} while ((DateTime.Now - timeMemory).TotalSeconds < RequestTimeout.TotalSeconds);
if (tmpEx != null)
{
throw tmpEx;
}
if (poolItem == null)
{
throw new Exception("从数据库连接池中获取连接时超时. Timeout while getting connection from connection pool");
}
poolItem.LastUsed = DateTime.Now;
if (poolItem.Connection.State == ConnectionState.Closed)
{
poolItem.Connection.Open();
}
RunForcedRelease();
return(poolItem.Connection);
}
