internal void PutConnection(IInnerConnection innerConnection)
{
Debug.WriteLineIf(CLI.FnTrace.Enabled, "ConnectionPool.PutConnection ()");
// Was connection in use when the pool was last cleared?
// If so, don't return it to the pool.
if (innerConnection.TimeStamp < lastCleared)
{
innerConnection.Close();
return;
}
innerConnection.OuterConnectionWeakRef = null;
if (CanPool(innerConnection))
{
if (innerConnection.DistributedTransaction != null &&
ContextUtil.IsInTransaction &&
ContextUtil.TransactionId == (Guid)innerConnection.DistributedTransactionId)
{
DoDtcPool(innerConnection);
}
else
{
DoPool(innerConnection);
}
}
else
{
innerConnection.Close();
}
}
private void ExpireConnections(object state)
{
Debug.WriteLineIf(CLI.FnTrace.Enabled, "ConnectionPool.ExpireConnections ()");
IInnerConnection connectionToClose = null;
lock (this)
{
if (pool == null)
{
return;
}
if (size > minSize)
{
connectionToClose = pool[--size];
}
}
if (connectionToClose != null)
{
Debug.WriteLineIf(Switch.Enabled, "Closing an expired connection.");
try
{
connectionToClose.Close();
connectionToClose.OuterConnectionWeakRef = null;
}
catch (Exception e)
{
Debug.WriteLineIf(Switch.Enabled, "Error closing expired connections: " + e);
Trace.WriteLine("Error closing expired connections: " + e);
}
}
}
internal IInnerConnection GetConnection(ConnectionOptions options, VirtuosoConnection connection)
{
Debug.WriteLineIf(CLI.FnTrace.Enabled, "ConnectionPool.GetConnection ()");
IInnerConnection innerConnection = null;
if (options.Enlist && ContextUtil.IsInTransaction)
{
innerConnection = (IInnerConnection)dtcPool.GetResource();
if (innerConnection != null)
{
innerConnection.OuterConnectionWeakRef = new WeakReference(connection);
return(innerConnection);
}
}
lock (this)
{
if (pool == null)
{
pool = new IInnerConnection[maxSize];
for (int i = 0; i < minSize; i++)
{
innerConnection = connection.CreateInnerConnection(options, false);
innerConnection.TimeStamp = DateTime.Now;
PutConnection(innerConnection);
}
}
if (size > 0)
{
innerConnection = pool[--size];
}
}
if (innerConnection == null)
{
innerConnection = connection.CreateInnerConnection(options, true);
innerConnection.TimeStamp = DateTime.Now;
}
else
{
innerConnection.OuterConnectionWeakRef = new WeakReference(connection);
#if MTS
if (options.Enlist && ContextUtil.IsInTransaction)
{
connection.EnlistInnerConnection(innerConnection);
}
#endif
}
return(innerConnection);
}
private void DistributedTransactionEnd(object resource)
{
Debug.WriteLineIf(CLI.FnTrace.Enabled, "ConnectionPool.DistributedTransactionEnd ()");
IInnerConnection innerConnection = (IInnerConnection)resource;
innerConnection.OuterConnectionWeakRef = null;
if (CanPool(innerConnection))
{
DoPool(innerConnection);
}
else
{
innerConnection.Close();
}
}
private void DoDtcPool(IInnerConnection innerConnection)
{
bool rc;
try
{
rc = dtcPool.PutResource(innerConnection);
}
catch
{
rc = false;
}
if (!rc)
{
DoPool(innerConnection);
}
}
private bool CanPool(IInnerConnection innerConnection)
{
if (!innerConnection.IsValid())
{
return(false);
}
if (lifetime != 0)
{
DateTime endOfLifetime = innerConnection.TimeStamp + new TimeSpan(0, 0, lifetime);
if (endOfLifetime < DateTime.Now)
{
return(false);
}
}
return(true);
}
private void DoPool(IInnerConnection innerConnection)
{
try
{
innerConnection.Pool();
}
catch
{
innerConnection.Close();
throw;
}
lock (this)
{
if (size < maxSize)
{
pool[size++] = innerConnection;
return;
}
}
innerConnection.Close();
}
internal void EnlistInnerConnection (IInnerConnection conn)
{
try
{
object dt = System.EnterpriseServices.ContextUtil.Transaction;
conn.Enlist (dt);
conn.DistributedTransaction = dt;
conn.DistributedTransactionId = System.EnterpriseServices.ContextUtil.TransactionId;
autocommit = false;
}
catch
{
conn.Close ();
throw;
}
}
protected override void Dispose (bool disposing)
{
try
{
if (disposed)
return;
disposed = true;
if (disposing)
{
Close ();
}
innerConnection = null;
options = null;
base.Dispose (disposing);
}
catch (Exception e)
{
Debug.WriteLineIf(CLI.FnTrace.Enabled,
"VirtuosoConnection.Dispose caught exception: " + e.Message);
}
}
public void Open ()
#endif
{
/*
* Open the database connection and set the ConnectionState
* property. If the underlying connection to the server is
* expensive to obtain, the implementation should provide
* implicit pooling of that connection.
*
* If the provider also supports automatic enlistment in
* distributed transactions, it should enlist during Open().
*/
Debug.WriteLineIf (CLI.FnTrace.Enabled, "VirtuosoConnection.Open ()");
if (state != ConnectionState.Closed)
throw new InvalidOperationException ("The connection has already been open.");
permission.Demand ();
if (options.Pooling)
{
if (pool == null)
pool = ConnectionPool.GetPool (options);
innerConnection = pool.GetConnection (options, this);
}
else
{
innerConnection = CreateInnerConnection (options, true);
}
state = ConnectionState.Open;
options.Secure ();
OnOpen ();
}
public void Close ()
#endif
{
/*
* Close the database connection and set the ConnectionState
* property. If the underlying connection to the server is
* being pooled, Close() will release it back to the pool.
*/
Debug.WriteLineIf (CLI.FnTrace.Enabled, "VirtuosoConnection.Close ()");
if (state != ConnectionState.Closed)
{
if (!autocommit && transactionStrongRef != null)
{
VirtuosoTransaction transaction = (VirtuosoTransaction) transactionStrongRef;
if (transaction != null)
transaction.Dispose ();
else
EndTransaction (false);
}
if (pool != null)
pool.PutConnection (innerConnection);
else
innerConnection.Close ();
innerConnection = null;
state = ConnectionState.Closed;
OnClose ();
}
}
private void DoDtcPool (IInnerConnection innerConnection)
{
bool rc;
try
{
rc = dtcPool.PutResource (innerConnection);
}
catch
{
rc = false;
}
if (!rc)
{
DoPool (innerConnection);
}
}
private void DoPool (IInnerConnection innerConnection)
{
try
{
innerConnection.Pool ();
}
catch
{
innerConnection.Close ();
throw;
}
lock (this)
{
if (size < maxSize)
{
pool[size++] = innerConnection;
return;
}
}
innerConnection.Close ();
}
private bool CanPool (IInnerConnection innerConnection)
{
if (!innerConnection.IsValid ())
return false;
if (lifetime != 0)
{
DateTime endOfLifetime = innerConnection.TimeStamp + new TimeSpan (0, 0, lifetime);
if (endOfLifetime < DateTime.Now)
return false;
}
return true;
}
internal void PutConnection (IInnerConnection innerConnection)
{
Debug.WriteLineIf (CLI.FnTrace.Enabled, "ConnectionPool.PutConnection ()");
// Was connection in use when the pool was last cleared?
// If so, don't return it to the pool.
if (innerConnection.TimeStamp < lastCleared)
{
innerConnection.Close ();
return;
}
innerConnection.OuterConnectionWeakRef = null;
if (CanPool (innerConnection))
{
if (innerConnection.DistributedTransaction != null
&& ContextUtil.IsInTransaction
&& ContextUtil.TransactionId == (Guid) innerConnection.DistributedTransactionId)
DoDtcPool (innerConnection);
else
DoPool (innerConnection);
}
else
{
innerConnection.Close ();
}
}
