void ISinglePhaseNotificationInternal.SinglePhaseCommit(IPromotedEnlistment singlePhaseEnlistment)
{
bool spcCommitted = false;
_promotedEnlistment = singlePhaseEnlistment;
try
{
_singlePhaseNotifications.SinglePhaseCommit(SinglePhaseEnlistment);
spcCommitted = true;
}
finally
{
if (!spcCommitted)
{
SinglePhaseEnlistment.InDoubt();
}
}
}
/// <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();
}
// 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;
}
}
/// <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();
}
/// <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();
}
public void SinglePhaseCommit(SinglePhaseEnlistment enlistment)
{
SqlInternalConnection validConnection = this.GetValidConnection();
SqlConnection connection = validConnection.Connection;
Bid.Trace("<sc.SqlDelegatedTransaction.SinglePhaseCommit|RES|CPOOL> %d#, Connection %d#, committing transaction.\n", this.ObjectID, validConnection.ObjectID);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (validConnection.IsConnectionDoomed)
{
lock (validConnection)
{
this._active = false;
this._connection = null;
}
enlistment.Aborted(SQL.ConnectionDoomed());
}
else
{
Exception exception;
lock (validConnection)
{
try
{
this.ValidateActiveOnConnection(validConnection);
this._active = false;
this._connection = null;
validConnection.ExecuteTransaction(SqlInternalConnection.TransactionRequest.Commit, null, System.Data.IsolationLevel.Unspecified, this._internalTransaction, true);
exception = null;
}
catch (SqlException exception3)
{
exception = exception3;
ADP.TraceExceptionWithoutRethrow(exception3);
validConnection.DoomThisConnection();
}
catch (InvalidOperationException exception2)
{
exception = exception2;
ADP.TraceExceptionWithoutRethrow(exception2);
validConnection.DoomThisConnection();
}
}
if (exception != null)
{
if (this._internalTransaction.IsCommitted)
{
enlistment.Committed();
}
else if (this._internalTransaction.IsAborted)
{
enlistment.Aborted(exception);
}
else
{
enlistment.InDoubt(exception);
}
}
validConnection.CleanupConnectionOnTransactionCompletion(this._atomicTransaction);
if (exception == null)
{
enlistment.Committed();
}
}
}
catch (OutOfMemoryException exception6)
{
connection.Abort(exception6);
throw;
}
catch (StackOverflowException exception5)
{
connection.Abort(exception5);
throw;
}
catch (ThreadAbortException exception4)
{
connection.Abort(exception4);
throw;
}
}