internal InternalEnlistment(System.Transactions.Enlistment enlistment, IEnlistmentNotification twoPhaseNotifications, InternalTransaction transaction, System.Transactions.Transaction atomicTransaction)
{
this.enlistment = enlistment;
this.twoPhaseNotifications = twoPhaseNotifications;
this.transaction = transaction;
this.atomicTransaction = atomicTransaction;
}
protected InternalEnlistment(System.Transactions.Enlistment enlistment, InternalTransaction transaction, System.Transactions.Transaction atomicTransaction)
{
this.enlistment = enlistment;
this.transaction = transaction;
this.atomicTransaction = atomicTransaction;
this.enlistmentId = transaction.enlistmentCount++;
this.traceIdentifier = EnlistmentTraceIdentifier.Empty;
}
internal InternalEnlistment(System.Transactions.Enlistment enlistment, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, System.Transactions.Transaction atomicTransaction)
{
this.enlistment = enlistment;
this.transaction = transaction;
this.twoPhaseNotifications = twoPhaseNotifications;
this.singlePhaseNotifications = singlePhaseNotifications;
this.atomicTransaction = atomicTransaction;
this.enlistmentId = transaction.enlistmentCount++;
this.traceIdentifier = EnlistmentTraceIdentifier.Empty;
}
internal Transaction(System.Transactions.Transaction transaction, bool isAmbient)
{
this.internalTransaction = transaction;
this.isAmbient = isAmbient;
this.transactionId = Interlocked.Increment(ref transactionCounter);
this.atomicSectionLock = new LightweightSpinLock();
this.isolationLevel = this.MapIsolationLevel(transaction.IsolationLevel);
this.aborted = false;
this.registeredHandlers = new HashSet<ITransactionHandler>();
this.internalTransaction.EnlistVolatile(this, System.Transactions.EnlistmentOptions.EnlistDuringPrepareRequired);
}
public static byte[] GetExportCookie(System.Transactions.Transaction transaction, byte[] whereabouts)
{
throw null;
}
/// <include file='docs/mysqlcommand.xml' path='docs/ExecuteReader1/*'/>
public new MySqlDataReader ExecuteReader(CommandBehavior behavior)
{
// give our interceptors a shot at it first
MySqlDataReader interceptedReader = null;
if (connection?.commandInterceptor != null && connection.commandInterceptor.ExecuteReader(CommandText, behavior, ref interceptedReader))
{
return(interceptedReader);
}
// interceptors didn't handle this so we fall through
bool success = false;
CheckState();
Driver driver = connection.driver;
cmdText = cmdText.Trim();
if (String.IsNullOrEmpty(cmdText))
{
Throw(new InvalidOperationException(Resources.CommandTextNotInitialized));
}
string sql = cmdText.Trim(';');
#if !NETSTANDARD1_6
// Load balancing getting a new connection
if (connection.hasBeenOpen && !driver.HasStatus(ServerStatusFlags.InTransaction))
{
ReplicationManager.GetNewConnection(connection.Settings.Server, !IsReadOnlyCommand(sql), connection);
}
#endif
lock (driver)
{
// We have to recheck that there is no reader, after we got the lock
if (connection.Reader != null)
{
Throw(new MySqlException(Resources.DataReaderOpen));
}
#if !NETSTANDARD1_6
System.Transactions.Transaction curTrans = System.Transactions.Transaction.Current;
if (curTrans != null)
{
bool inRollback = false;
//TODO: ADD support for 452 and 46X
if (driver.currentTransaction != null)
{
inRollback = driver.currentTransaction.InRollback;
}
if (!inRollback)
{
System.Transactions.TransactionStatus status = System.Transactions.TransactionStatus.InDoubt;
try
{
// in some cases (during state transitions) this throws
// an exception. Ignore exceptions, we're only interested
// whether transaction was aborted or not.
status = curTrans.TransactionInformation.Status;
}
catch (System.Transactions.TransactionException)
{
}
if (status == System.Transactions.TransactionStatus.Aborted)
{
Throw(new System.Transactions.TransactionAbortedException());
}
}
}
#endif
commandTimer = new CommandTimer(connection, CommandTimeout);
LastInsertedId = -1;
if (CommandType == CommandType.TableDirect)
{
sql = "SELECT * FROM " + sql;
}
else if (CommandType == CommandType.Text)
{
// validates single word statetment (maybe is a stored procedure call)
if (sql.IndexOf(" ") == -1)
{
if (AddCallStatement(sql))
{
sql = "call " + sql;
}
}
}
// if we are on a replicated connection, we are only allow readonly statements
if (connection.Settings.Replication && !InternallyCreated)
{
EnsureCommandIsReadOnly(sql);
}
if (statement == null || !statement.IsPrepared)
{
if (CommandType == CommandType.StoredProcedure)
{
statement = new StoredProcedure(this, sql);
}
else
{
statement = new PreparableStatement(this, sql);
}
}
// stored procs are the only statement type that need do anything during resolve
statement.Resolve(false);
// Now that we have completed our resolve step, we can handle our
// command behaviors
HandleCommandBehaviors(behavior);
try
{
MySqlDataReader reader = new MySqlDataReader(this, statement, behavior);
connection.Reader = reader;
Canceled = false;
// execute the statement
statement.Execute();
// wait for data to return
reader.NextResult();
success = true;
return(reader);
}
catch (TimeoutException tex)
{
connection.HandleTimeoutOrThreadAbort(tex);
throw; //unreached
}
#if !NETSTANDARD1_6
catch (ThreadAbortException taex)
{
connection.HandleTimeoutOrThreadAbort(taex);
throw;
}
#endif
catch (IOException ioex)
{
connection.Abort(); // Closes connection without returning it to the pool
throw new MySqlException(Resources.FatalErrorDuringExecute, ioex);
}
catch (MySqlException ex)
{
if (ex.InnerException is TimeoutException)
{
throw; // already handled
}
try
{
ResetReader();
ResetSqlSelectLimit();
}
catch (Exception)
{
// Reset SqlLimit did not work, connection is hosed.
Connection.Abort();
throw new MySqlException(ex.Message, true, ex);
}
// if we caught an exception because of a cancel, then just return null
if (ex.IsQueryAborted)
{
return(null);
}
if (ex.IsFatal)
{
Connection.Close();
}
if (ex.Number == 0)
{
throw new MySqlException(Resources.FatalErrorDuringExecute, ex);
}
throw;
}
finally
{
if (connection != null)
{
if (connection.Reader == null)
{
// Something went seriously wrong, and reader would not
// be able to clear timeout on closing.
// So we clear timeout here.
ClearCommandTimer();
}
if (!success)
{
// ExecuteReader failed.Close Reader and set to null to
// prevent subsequent errors with DataReaderOpen
ResetReader();
}
}
}
}
}
public virtual void EnlistTransaction(System.Transactions.Transaction transaction)
{
throw ADP.NotSupported();
}
internal bool TryGetConnection(DbConnection owningConnection, TaskCompletionSource <DbConnectionInternal> retry, DbConnectionOptions userOptions, DbConnectionInternal oldConnection, out DbConnectionInternal connection)
{
Debug.Assert(null != owningConnection, "null owningConnection?");
DbConnectionPoolGroup poolGroup;
DbConnectionPool connectionPool;
connection = null;
// SQLBU 431251:
// Work around race condition with clearing the pool between GetConnectionPool obtaining pool
// and GetConnection on the pool checking the pool state. Clearing the pool in this window
// will switch the pool into the ShuttingDown state, and GetConnection will return null.
// There is probably a better solution involving locking the pool/group, but that entails a major
// re-design of the connection pooling synchronization, so is post-poned for now.
// VSDD 674236: use retriesLeft to prevent CPU spikes with incremental sleep
// start with one msec, double the time every retry
// max time is: 1 + 2 + 4 + ... + 2^(retries-1) == 2^retries -1 == 1023ms (for 10 retries)
int retriesLeft = 10;
int timeBetweenRetriesMilliseconds = 1;
do
{
poolGroup = GetConnectionPoolGroup(owningConnection);
// Doing this on the callers thread is important because it looks up the WindowsIdentity from the thread.
connectionPool = GetConnectionPool(owningConnection, poolGroup);
if (null == connectionPool)
{
// If GetConnectionPool returns null, we can be certain that
// this connection should not be pooled via DbConnectionPool
// or have a disabled pool entry.
poolGroup = GetConnectionPoolGroup(owningConnection); // previous entry have been disabled
if (retry != null)
{
Task <DbConnectionInternal> newTask;
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
lock (s_pendingOpenNonPooled)
{
// look for an available task slot (completed or empty)
int idx;
for (idx = 0; idx < s_pendingOpenNonPooled.Length; idx++)
{
Task task = s_pendingOpenNonPooled[idx];
if (task == null)
{
s_pendingOpenNonPooled[idx] = GetCompletedTask();
break;
}
else if (task.IsCompleted)
{
break;
}
}
// if didn't find one, pick the next one in round-robbin fashion
if (idx == s_pendingOpenNonPooled.Length)
{
idx = s_pendingOpenNonPooledNext++ % s_pendingOpenNonPooled.Length;
}
// now that we have an antecedent task, schedule our work when it is completed.
// If it is a new slot or a compelted task, this continuation will start right away.
// BUG? : If we have timed out task on top of running task, then new task could be started
// on top of that, since we are only checking the top task. This will lead to starting more threads
// than intended.
newTask = s_pendingOpenNonPooled[idx].ContinueWith((_) =>
{
System.Transactions.Transaction originalTransaction = ADP.GetCurrentTransaction();
try
{
ADP.SetCurrentTransaction(retry.Task.AsyncState as System.Transactions.Transaction);
var newConnection = CreateNonPooledConnection(owningConnection, poolGroup, userOptions);
if ((oldConnection != null) && (oldConnection.State == ConnectionState.Open))
{
oldConnection.PrepareForReplaceConnection();
oldConnection.Dispose();
}
return(newConnection);
}
finally
{
ADP.SetCurrentTransaction(originalTransaction);
}
}, cancellationTokenSource.Token, TaskContinuationOptions.LongRunning, TaskScheduler.Default);
// Place this new task in the slot so any future work will be queued behind it
s_pendingOpenNonPooled[idx] = newTask;
}
// Set up the timeout (if needed)
if (owningConnection.ConnectionTimeout > 0)
{
int connectionTimeoutMilliseconds = owningConnection.ConnectionTimeout * 1000;
cancellationTokenSource.CancelAfter(connectionTimeoutMilliseconds);
}
// once the task is done, propagate the final results to the original caller
newTask.ContinueWith((task) =>
{
cancellationTokenSource.Dispose();
if (task.IsCanceled)
{
retry.TrySetException(ADP.ExceptionWithStackTrace(ADP.NonPooledOpenTimeout()));
}
else if (task.IsFaulted)
{
retry.TrySetException(task.Exception.InnerException);
}
else
{
if (retry.TrySetResult(task.Result))
{
PerformanceCounters.NumberOfNonPooledConnections.Increment();
}
else
{
// The outer TaskCompletionSource was already completed
// Which means that we don't know if someone has messed with the outer connection in the middle of creation
// So the best thing to do now is to destroy the newly created connection
task.Result.DoomThisConnection();
task.Result.Dispose();
}
}
}, TaskScheduler.Default);
return(false);
}
connection = CreateNonPooledConnection(owningConnection, poolGroup, userOptions);
PerformanceCounters.NumberOfNonPooledConnections.Increment();
}
else
{
if (((SqlClient.SqlConnection)owningConnection).ForceNewConnection)
{
Debug.Assert(!(oldConnection is DbConnectionClosed), "Force new connection, but there is no old connection");
connection = connectionPool.ReplaceConnection(owningConnection, userOptions, oldConnection);
}
else
{
if (!connectionPool.TryGetConnection(owningConnection, retry, userOptions, out connection))
{
return(false);
}
}
if (connection == null)
{
// connection creation failed on semaphore waiting or if max pool reached
if (connectionPool.IsRunning)
{
// If GetConnection failed while the pool is running, the pool timeout occurred.
Bid.Trace("<prov.DbConnectionFactory.GetConnection|RES|CPOOL> %d#, GetConnection failed because a pool timeout occurred.\n", ObjectID);
throw ADP.PooledOpenTimeout();
}
else
{
// We've hit the race condition, where the pool was shut down after we got it from the group.
// Yield time slice to allow shut down activities to complete and a new, running pool to be instantiated
// before retrying.
System.Threading.Thread.Sleep(timeBetweenRetriesMilliseconds);
timeBetweenRetriesMilliseconds *= 2; // double the wait time for next iteration
}
}
}
} while (connection == null && retriesLeft-- > 0);
if (connection == null)
{
// exhausted all retries or timed out - give up
Bid.Trace("<prov.DbConnectionFactory.GetConnection|RES|CPOOL> %d#, GetConnection failed because a pool timeout occurred and all retries were exhausted.\n", ObjectID);
throw ADP.PooledOpenTimeout();
}
return(true);
}
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
CheckClosed();
_innerConnection.EnlistTransaction(transaction);
}
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
CheckConnection();
_internalConnection.EnlistTransaction(transaction);
}
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
throw new NotSupportedException("System.Transactions.Transaction is not supported. Use BeginTransaction instead.");
}
public TransactionScope(System.Transactions.Transaction transaction, System.TimeSpan timeout)
{
}
public TransactionScope(System.Transactions.Transaction transaction, System.TimeSpan timeout, System.Transactions.EnterpriseServicesInteropOption opt)
{
}
public static byte[] GetExportCookie(System.Transactions.Transaction transaction, byte[] exportCookie)
{
throw null;
}
public TransactionScope(System.Transactions.Transaction transactionToUse, System.Transactions.TransactionScopeAsyncFlowOption asyncFlowOption)
{
}
private static Transaction CreateTransaction(System.Transactions.Transaction ambient)
{
ambient.TransactionCompleted += OnAmbientTransactionCompleted;
return(new Transaction(ambient, true));
}
public static void RemoveTransaction(System.Transactions.Transaction ambient)
{
Transaction removedTransaction;
transactions.TryRemove(ambient.TransactionInformation.LocalIdentifier, out removedTransaction);
}
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
}
/// <summary>
/// enlist the transaction.
/// </summary>
/// <param name="transaction">The transaction.</param>
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
_connection.EnlistTransaction(transaction);
}
public static System.Transactions.IDtcTransaction GetDtcTransaction(System.Transactions.Transaction transaction)
{
return(default(System.Transactions.IDtcTransaction));
}
public virtual void Execute(BpmnStackTrace stackTrace)
{
if ((operation != PvmAtomicOperationFields.ActivityStartCancelScope) &&
(operation != PvmAtomicOperationFields.ActivityStartInterruptScope) &&
(operation != PvmAtomicOperationFields.ActivityStartConcurrent))
{
// execution might be replaced in the meantime:
ExecutionEntity replacedBy = (ExecutionEntity)execution.ReplacedBy;
if (replacedBy != null)
{
execution = replacedBy;
}
}
//execution was canceled for example via terminate end event
if (execution.Canceled &&
(operation == PvmAtomicOperationFields.TransitionNotifyListenerEnd ||
operation == PvmAtomicOperationFields.ActivityNotifyListenerEnd))
{
return;
}
//// execution might have ended in the meanwhile
if (execution.IsEnded &&
(operation == PvmAtomicOperationFields.TransitionNotifyListenerTake ||
operation == PvmAtomicOperationFields.ActivityStartCreateScope))
{
return;
}
//TODO Context.CurrentProcessApplication
var currentPa = context.Impl.Context.CurrentProcessApplication;
if (currentPa != null)
{
applicationContextName = currentPa.Name;
}
activityId = execution.ActivityId;
stackTrace.Add(this);
try
{
Context.SetExecutionContext(execution);
if (!performAsync)//同步
{
Log.DebugExecutingAtomicOperation(operation, execution);
operation.Execute(execution);
}
else//异步
{
execution.ScheduleAtomicOperationAsync(this);
}
}
catch (ClassMethodDelegateException ex)
{
if (execution.IsInTransaction)
{
System.Transactions.Transaction tr = Context.CommandContext.CurrentTransaction;
Log.LogDebug("外部代码异常，事务Id:", tr.TransactionInformation.LocalIdentifier);
if (context.Impl.Context.CommandContext.CurrentTransaction != null)
{
Log.LogDebug("移除当前外部事务，添加到待回滚中。", context.Impl.Context.CommandContext.CurrentTransaction.TransactionInformation.LocalIdentifier);
context.Impl.Context.CommandContext.MoveToRollBack();
}
}
else
{
Log.LogDebug("外部代码不在事务范围内,ActivityId:" + execution.ActivityId, ex.Message);
}
}
//debug抛异常
catch (System.Exception e)
{
throw e;
}
finally
{
context.Impl.Context.RemoveExecutionContext();
}
}
public static byte[] GetExportCookie(System.Transactions.Transaction transaction, byte[] whereabouts)
{
return(default(byte[]));
}
internal void UnenlistTransaction(ImplicitTransactionBase implicitTransaction, System.Transactions.Transaction transaction)
{
if (!object.ReferenceEquals(implicitTransaction, m_implicitTransaction))
{
throw new InvalidOperationException("Active transaction is not the one being unenlisted from.");
}
m_implicitTransaction = null;
if (m_shouldCloseWhenUnenlisted)
{
m_shouldCloseWhenUnenlisted = false;
Close();
}
// NOTE: may try to remove the same Transaction multiple times (if it spans multiple connections), which is a safe no-op
lock (s_lock)
s_transactionConnections.Remove(transaction);
}
public static byte[] GetTransmitterPropagationToken(System.Transactions.Transaction transaction)
{
return(default(byte[]));
}
public void EnlistTransaction(System.Transactions.Transaction transaction) => throw new NotImplementedException();
public TransactionScope(System.Transactions.Transaction transactionToUse)
{
}
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
this._WrappedConnection.EnlistTransaction(transaction);
}
public TransactionScope(System.Transactions.Transaction transactionToUse, System.TimeSpan scopeTimeout)
{
}
public static System.Transactions.IDtcTransaction GetDtcTransaction(System.Transactions.Transaction transaction)
{
throw null;
}
public void EnlistTransaction(System.Transactions.Transaction transaction)
{
}
public static byte[] GetTransmitterPropagationToken(System.Transactions.Transaction transaction)
{
throw null;
}
public TransactionScope(System.Transactions.Transaction curr)
{
prev = System.Transactions.Transaction.Current;
System.Transactions.Transaction.Current = curr;
}
public TransactionScope(System.Transactions.Transaction transactionToUse, System.TimeSpan scopeTimeout, System.Transactions.EnterpriseServicesInteropOption interopOption)
{
}
public static Transaction GetAmbientEnlistedTransaction(System.Transactions.Transaction ambient)
{
return(transactions.GetOrAdd(ambient.TransactionInformation.LocalIdentifier, x => CreateTransaction(ambient)));
}
public TransactionScope(System.Transactions.Transaction transactionToUse, System.TimeSpan scopeTimeout, System.Transactions.TransactionScopeAsyncFlowOption asyncFlowOption)
{
}
/// <summary>
/// Manual distributed transaction enlistment support
/// </summary>
/// <param name="transaction">The distributed transaction to enlist in</param>
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
if (_transactionLevel > 0 && transaction != null)
throw new ArgumentException("Unable to enlist in transaction, a local transaction already exists");
if (_enlistment != null && transaction != _enlistment)
throw new ArgumentException("Already enlisted in a transaction");
transaction.EnlistVolatile(new SQLiteEnlistment(this), System.Transactions.EnlistmentOptions.None);
_enlistment = transaction;
}