public void SinglePhaseCommit(SinglePhaseEnlistment en)
{
if (en == null)
{
throw new ArgumentNullException("en");
}
try
{
this.handle.WaitOne();
}
catch (ObjectDisposedException)
{
}
lock (this.syncRoot)
{
try
{
this.transaction.Commit();
en.Committed();
}
catch (Exception exception)
{
en.Aborted(exception);
}
finally
{
if ((this.connection != null) && (this.connection.State != ConnectionState.Closed))
{
this.connection.Close();
this.connection = null;
}
}
}
}
public void Rollback(SinglePhaseEnlistment en)
{
if (en == null)
{
throw new ArgumentNullException("en");
}
try
{
this.handle.WaitOne();
}
catch (ObjectDisposedException)
{
}
lock (this.syncRoot)
{
if (this.transaction != null)
{
this.transaction.Dispose();
}
if ((this.connection != null) && (this.connection.State != ConnectionState.Closed))
{
this.connection.Close();
this.connection = null;
}
en.Aborted();
}
}
/// <summary>
/// Notifies an enlisted object that the transaction is being committed.
/// </summary>
/// <param name="singlePhaseEnlistment">A <see cref="T:System.Transactions.SinglePhaseEnlistment"/> interface used to send a response to the transaction manager.</param>
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
onTxComplete();
session.Commit(GetLocalOrDistributedTransactionId(transaction));
singlePhaseEnlistment.Committed();
}
void IPromotableSinglePhaseNotification.SinglePhaseCommit( SinglePhaseEnlistment singlePhaseEnlistment ) {
this.simpleTransaction.Commit();
singlePhaseEnlistment.Committed();
DriverTransactionManager.RemoveDriverInTransaction( this.baseTransaction );
this.connection.driver.CurrentTransaction = null;
if( this.connection.State == ConnectionState.Closed ) {
this.connection.CloseFully();
}
}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
simpleTransaction.Commit();
singlePhaseEnlistment.Committed();
DriverTransactionManager.RemoveDriverInTransaction(baseTransaction);
if (connection.State == ConnectionState.Closed)
connection.CloseFully();
}
void IPromotableSinglePhaseNotification.Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
simpleTransaction.Rollback();
singlePhaseEnlistment.Aborted();
DriverTransactionManager.RemoveDriverInTransaction(baseTransaction);
connection.driver.CurrentTransaction = null;
if (connection.State == ConnectionState.Closed)
connection.CloseFully();
}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
try
{
Neo4jTransaction.DoCommit(_transactionExecutionEnvironment);
singlePhaseEnlistment.Committed();
}
finally
{
singlePhaseEnlistment.Aborted();
}
}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
try
{
Commit();
singlePhaseEnlistment.Done();
}
catch (Exception)
{
//on a callback thread, can't throw
}
}
public void SinglePhaseCommit(SinglePhaseEnlistment en)
{
if (en == null)
throw new ArgumentNullException("en");
//
// Wait until IPendingWork members have completed (WinOE bugs 17580 and 13395)
try
{
handle.WaitOne();
}
catch (ObjectDisposedException)
{
// If an ObjectDisposedException is thrown because
// the WaitHandle has already closed, nothing to worry
// about. Move on.
}
lock (syncRoot)
{
try
{
this.transaction.Commit();
en.Committed();
}
catch (Exception e)
{
en.Aborted(e);
}
finally
{
if ((null != connection) && (ConnectionState.Closed != connection.State))
{
connection.Close();
connection = null;
}
}
}
}
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
// prevent commands in main thread to run concurrently
Driver driver = connection.driver;
lock (driver)
{
rollbackThreadId = Thread.CurrentThread.ManagedThreadId;
while (connection.Reader != null)
{
// wait for reader to finish. Maybe we should not wait
// forever and cancel it after some time?
System.Threading.Thread.Sleep(100);
}
simpleTransaction.Rollback();
singlePhaseEnlistment.Aborted();
DriverTransactionManager.RemoveDriverInTransaction(baseTransaction);
if (connection.State == ConnectionState.Closed)
connection.CloseFully();
rollbackThreadId = 0;
}
}
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) {}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) {}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
_log.Debug("Single Phase Commit");
if (_npgsqlTx != null)
{
_npgsqlTx.Commit();
_npgsqlTx.Dispose();
_npgsqlTx = null;
singlePhaseEnlistment.Committed();
_connection.PromotableLocalTransactionEnded();
}
else if (_callbacks != null)
{
if (_rm != null)
{
_rm.CommitWork(_callbacks.GetName());
singlePhaseEnlistment.Committed();
}
else
{
_callbacks.CommitTransaction();
singlePhaseEnlistment.Committed();
}
_callbacks = null;
}
_inTransaction = false;
}
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Rollback");
// try to rollback the transaction with either the
// ADO.NET transaction or the callbacks that managed the
// two phase commit transaction.
if (_npgsqlTx != null)
{
_npgsqlTx.Rollback();
_npgsqlTx.Dispose();
_npgsqlTx = null;
singlePhaseEnlistment.Aborted();
_connection.PromotableLocalTransactionEnded();
}
else if (_callbacks != null)
{
if (_rm != null)
{
_rm.RollbackWork(_callbacks.GetName());
singlePhaseEnlistment.Aborted();
}
else
{
_callbacks.RollbackTransaction();
singlePhaseEnlistment.Aborted();
}
_callbacks = null;
}
_inTransaction = false;
}
/// <summary>
/// Rollbacks the specified single phase enlistment.
/// </summary>
/// <param name="singlePhaseEnlistment">The single phase enlistment.</param>
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
onTxComplete();
try
{
session.Rollback(PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction));
using (var machineStoreForApplication = IsolatedStorageFile.GetMachineStoreForDomain())
{
machineStoreForApplication.DeleteFile(TransactionRecoveryInformationFileName);
}
}
catch (Exception e)
{
logger.ErrorException("Could not rollback distributed transaction", e);
singlePhaseEnlistment.InDoubt(e);
return;
}
singlePhaseEnlistment.Aborted();
}
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
singlePhaseEnlistment.Done();
}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
_callbacks.CommitTransaction();
singlePhaseEnlistment.Committed();
_callbacks.Dispose();
}
///<summary>
/// Attempt to rollback the internal transaction.
///</summary>
void IPromotableSinglePhaseNotification.Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
try
{
// attempt to rollback the transaction
this.dbTransaction.Rollback();
singlePhaseEnlistment.Done();
}
finally
{
// clean-up our resources
Dispose();
}
}
/// <summary>
/// Rollbacks the specified single phase enlistment.
/// </summary>
/// <param name="singlePhaseEnlistment">The single phase enlistment.</param>
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
onTxComplete();
try
{
session.Rollback(transaction.LocalIdentifier);
DeleteFile();
}
catch (Exception e)
{
logger.ErrorException("Could not rollback distributed transaction", e);
singlePhaseEnlistment.InDoubt(e);
return;
}
singlePhaseEnlistment.Aborted();
ctx.Dispose();
}
///<summary>
/// Attempt to commit the internal transaction.
///</summary>
void IPromotableSinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
try
{
// attempt to commit the enlistment
this.dbTransaction.Commit();
singlePhaseEnlistment.Committed();
}
catch (Exception e)
{
// something went wrong, make sure the transaction aborts
singlePhaseEnlistment.Aborted(e);
throw;
}
finally
{
// clean-up our resources
Dispose();
}
}
void IPromotableSinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
lock (this.syncRoot)
{
if (this.txnid != null)
{
this.controller.DischargeAsync(this.txnid, false).ContinueWith(
(t, o) =>
{
var spe = (SinglePhaseEnlistment)o;
if (t.IsFaulted)
{
spe.Aborted(t.Exception.InnerException);
}
else
{
spe.Done();
}
},
singlePhaseEnlistment);
}
}
}
void DoSingleCommit (ISinglePhaseNotification single)
{
if (single == null)
return;
SinglePhaseEnlistment enlistment = new SinglePhaseEnlistment (this, single);
single.SinglePhaseCommit (enlistment);
CheckAborted ();
}
// Called by transaction to initiate abort sequence
public void Rollback(SysTx.SinglePhaseEnlistment enlistment)
{
Debug.Assert(null != enlistment, "null enlistment?");
SqlInternalConnection connection = GetValidConnection();
SqlConnection usersConnection = connection.Connection;
Bid.Trace("<sc.SqlDelegatedTransaction.Rollback|RES|CPOOL> %d#, Connection %d#, aborting transaction.\n", ObjectID, connection.ObjectID);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
#if DEBUG
TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection();
RuntimeHelpers.PrepareConstrainedRegions();
try {
tdsReliabilitySection.Start();
#else
{
#endif //DEBUG
lock (connection)
{
try
{
// Now that we've acquired the lock, make sure we still have valid state for this operation.
ValidateActiveOnConnection(connection);
_active = false; // set to inactive first, doesn't matter how the execute completes, this transaction is done.
_connection = null; // Set prior to ExecuteTransaction call in case this initiates a TransactionEnd event
// If we haven't already rolled back (or aborted) then tell the SQL Server to roll back
if (!_internalTransaction.IsAborted)
{
connection.ExecuteTransaction(SqlInternalConnection.TransactionRequest.Rollback, null, IsolationLevel.Unspecified, _internalTransaction, true);
}
}
catch (SqlException e)
{
ADP.TraceExceptionWithoutRethrow(e);
// Doom the connection, to make sure that the transaction is
// eventually rolled back.
// VSTS 144562: doom the connection while having the lock on it to prevent race condition with "Transaction Ended" Event
connection.DoomThisConnection();
// Unlike SinglePhaseCommit, a rollback is a rollback, regardless
// of how it happens, so SysTx won't throw an exception, and we
// don't want to throw an exception either, because SysTx isn't
// handling it and it may create a fail fast scenario. In the end,
// there is no way for us to communicate to the consumer that this
// failed for more serious reasons than usual.
//
// This is a bit like "should you throw if Close fails", however,
// it only matters when you really need to know. In that case,
// we have the tracing that we're doing to fallback on for the
// investigation.
}
catch (InvalidOperationException e)
{
ADP.TraceExceptionWithoutRethrow(e);
connection.DoomThisConnection();
}
}
// it doesn't matter whether the rollback succeeded or not, we presume
// that the transaction is aborted, because it will be eventually.
connection.CleanupConnectionOnTransactionCompletion(_atomicTransaction);
enlistment.Aborted();
}
#if DEBUG
finally {
tdsReliabilitySection.Stop();
}
#endif //DEBUG
}
catch (System.OutOfMemoryException e)
{
usersConnection.Abort(e);
throw;
}
catch (System.StackOverflowException e)
{
usersConnection.Abort(e);
throw;
}
catch (System.Threading.ThreadAbortException e)
{
usersConnection.Abort(e);
throw;
}
}
/// <summary>
/// Rollbacks the specified single phase enlistment.
/// </summary>
/// <param name="singlePhaseEnlistment">The single phase enlistment.</param>
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
onTxComplete();
try
{
session.Rollback(PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction));
DeleteFile();
}
catch (Exception e)
{
logger.ErrorException("Could not rollback distributed transaction", e);
singlePhaseEnlistment.InDoubt(e);
return;
}
singlePhaseEnlistment.Aborted();
}
// Called by the transaction to initiate commit sequence
public void SinglePhaseCommit(SysTx.SinglePhaseEnlistment enlistment)
{
Debug.Assert(null != enlistment, "null enlistment?");
SqlInternalConnection connection = GetValidConnection();
SqlConnection usersConnection = connection.Connection;
Bid.Trace("<sc.SqlDelegatedTransaction.SinglePhaseCommit|RES|CPOOL> %d#, Connection %d#, committing transaction.\n", ObjectID, connection.ObjectID);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
#if DEBUG
TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection();
RuntimeHelpers.PrepareConstrainedRegions();
try {
tdsReliabilitySection.Start();
#else
{
#endif //DEBUG
// If the connection is dooomed, we can be certain that the
// transaction will eventually be rolled back, and we shouldn't
// attempt to commit it.
if (connection.IsConnectionDoomed)
{
lock (connection)
{
_active = false; // set to inactive first, doesn't matter how the rest completes, this transaction is done.
_connection = null;
}
enlistment.Aborted(SQL.ConnectionDoomed());
}
else
{
Exception commitException;
lock (connection)
{
try
{
// Now that we've acquired the lock, make sure we still have valid state for this operation.
ValidateActiveOnConnection(connection);
_active = false; // set to inactive first, doesn't matter how the rest completes, this transaction is done.
_connection = null; // Set prior to ExecuteTransaction call in case this initiates a TransactionEnd event
connection.ExecuteTransaction(SqlInternalConnection.TransactionRequest.Commit, null, IsolationLevel.Unspecified, _internalTransaction, true);
commitException = null;
}
catch (SqlException e)
{
commitException = e;
ADP.TraceExceptionWithoutRethrow(e);
// Doom the connection, to make sure that the transaction is
// eventually rolled back.
// VSTS 144562: doom the connection while having the lock on it to prevent race condition with "Transaction Ended" Event
connection.DoomThisConnection();
}
catch (InvalidOperationException e)
{
commitException = e;
ADP.TraceExceptionWithoutRethrow(e);
connection.DoomThisConnection();
}
}
if (commitException != null)
{
// connection.ExecuteTransaction failed with exception
if (_internalTransaction.IsCommitted)
{
// Even though we got an exception, the transaction
// was committed by the server.
enlistment.Committed();
}
else if (_internalTransaction.IsAborted)
{
// The transaction was aborted, report that to
// SysTx.
enlistment.Aborted(commitException);
}
else
{
// The transaction is still active, we cannot
// know the state of the transaction.
enlistment.InDoubt(commitException);
}
// We eat the exception. This is called on the SysTx
// thread, not the applications thread. If we don't
// eat the exception an UnhandledException will occur,
// causing the process to FailFast.
}
connection.CleanupConnectionOnTransactionCompletion(_atomicTransaction);
if (commitException == null)
{
// connection.ExecuteTransaction succeeded
enlistment.Committed();
}
}
}
#if DEBUG
finally {
tdsReliabilitySection.Stop();
}
#endif //DEBUG
}
catch (System.OutOfMemoryException e)
{
usersConnection.Abort(e);
throw;
}
catch (System.StackOverflowException e)
{
usersConnection.Abort(e);
throw;
}
catch (System.Threading.ThreadAbortException e)
{
usersConnection.Abort(e);
throw;
}
}
void IPromotableSinglePhaseNotification.Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
MySqlTransactionScope current = scopeStack.Peek();
current.Rollback(singlePhaseEnlistment);
scopeStack.Pop();
}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "SinglePhaseCommit");
if (_npgsqlTx != null)
{
_npgsqlTx.Commit();
_npgsqlTx.Dispose();
_npgsqlTx = null;
singlePhaseEnlistment.Committed();
_connection.PromotableLocalTransactionEnded();
}
else if (_callbacks != null)
{
if (_rm != null)
{
_rm.CommitWork(_callbacks.GetName());
singlePhaseEnlistment.Committed();
}
else
{
_callbacks.CommitTransaction();
singlePhaseEnlistment.Committed();
}
_callbacks = null;
}
_inTransaction = false;
}
void IPromotableSinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
scopeStack.Pop().SinglePhaseCommit(singlePhaseEnlistment);
}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
singlePhaseEnlistment.Committed();
}
void ISinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
{
}
internal void Rollback (Exception ex, object abortingEnlisted)
{
if (aborted)
{
FireCompleted ();
return;
}
/* See test ExplicitTransaction7 */
if (info.Status == TransactionStatus.Committed)
throw new TransactionException ("Transaction has already been committed. Cannot accept any new work.");
// Save thrown exception as 'reason' of transaction's abort.
innerException = ex;
SinglePhaseEnlistment e = new SinglePhaseEnlistment();
foreach (IEnlistmentNotification prep in Volatiles)
if (prep != abortingEnlisted)
prep.Rollback (e);
var durables = Durables;
if (durables.Count > 0 && durables [0] != abortingEnlisted)
durables [0].Rollback (e);
if (pspe != null && pspe != abortingEnlisted)
pspe.Rollback (e);
Aborted = true;
FireCompleted ();
}
/// <summary>
/// Notifies an enlisted object that the transaction is being rolled back.
/// </summary>
/// <param name="singlePhaseEnlistment">A <see cref="T:System.Transactions.SinglePhaseEnlistment"/> object used to send a response to the transaction manager.</param>
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
{
onTxComplete();
session.Rollback(GetLocalOrDistributedTransactionId(transaction));
singlePhaseEnlistment.Aborted();
}