public void Commit(Enlistment enlistment)
{
log.Debug("Commit {0}, Messages: {1}", TransactionId, Messages.Count);
if (_oncommit != null) _oncommit(this);
enlistment.Done();
TransactionOpen = false;
}
void IEnlistmentNotification.Commit(Enlistment enlistment)
{
this.m_Value = new StringBuilder(this.m_TemporaryValue.ToString());
this.m_TemporaryValue = null;
this.enlistedTransaction = null;
enlistment.Done();
}
/// <summary>
/// Performs necessary commit actions, clearing the current <see cref="TransactionContext"/>
/// </summary>
public void Commit(Enlistment enlistment)
{
BeforeCommit();
DoCommit();
TransactionContext.Clear();
enlistment.Done();
}
public void Rollback(Enlistment enlistment)
{
container.Rollback();
container.Ext().Refresh(oldItem, int.MaxValue);
oldItem = null;
container = null;
}
/// <summary>
/// Make the transacted changes permanent.
/// </summary>
void IEnlistmentNotification.Commit(Enlistment enlistment)
{
_value = new StringBuilder(_temporaryValue.ToString());
_temporaryValue = null;
_enlistedTransaction = null;
enlistment.Done();
}
public void Commit(Enlistment enlistment)
{
try
{
assertNotDisposed();
logger.DebugFormat("Committing enlistment with id: {0}", Id);
queueStorage.Global(actions =>
{
actions.RemoveReversalsMoveCompletedMessagesAndFinishSubQueueMove(Id);
actions.MarkAsReadyToSend(Id);
actions.DeleteRecoveryInformation(Id);
actions.Commit();
});
enlistment.Done();
logger.DebugFormat("Commited enlistment with id: {0}", Id);
}
catch (Exception e)
{
logger.Warn("Failed to commit enlistment " + Id, e);
throw;
}
finally
{
onCompelete();
}
}
public void InDoubt(Enlistment enlistment)
{
enlistment.Done();
this.notification.InDoubt();
Marshal.ReleaseComObject(this.notification);
this.notification = null;
}
public void Rollback(Enlistment enlistment)
{
enlistment.Done();
this.notification.Aborted(0, false, 0, 0);
Marshal.ReleaseComObject(this.notification);
this.notification = null;
}
public void Commit(Enlistment enlistment)
{
if (_transaction != null && !_transaction.IsUpdated)
{
_transaction.Commit();
_transaction = null;
if (Completed != null)
{
Completed(this, new EventArgs());
}
if (_connection != null)
{
if (!_connection.Options.Pooling && (_connection.OwningConnection == null || _connection.OwningConnection.IsClosed))
{
_connection.Disconnect();
}
}
_connection = null;
_systemTransaction = null;
// Declare done on the enlistment
enlistment.Done();
}
}
public void Commit(Enlistment enlistment)
{
if (this.transaction != null && !this.transaction.IsUpdated)
{
this.transaction.Commit();
this.transaction = null;
if (this.Completed != null)
{
this.Completed(this, new EventArgs());
}
if (this.connection != null)
{
if (!this.connection.Pooled && (this.connection.OwningConnection == null || this.connection.OwningConnection.IsClosed))
{
this.connection.Disconnect();
}
}
this.connection = null;
this.systemTransaction = null;
// Declare done on the enlistment
enlistment.Done();
}
}
public void Commit(Enlistment enlistment)
{
if (_ThrowIt)
Assert.Fail("commit is never called if prepare failed");
enlistment.Done();
}
public void InDoubt(Enlistment enlistment)
{
log.Warn("transaction in doubt {0}, messages {1}", TransactionId, this.Messages.Count);
if (_onrollback != null) _onrollback(this);
enlistment.Done();
TransactionOpen = false;
}
public override void Rollback(Enlistment enlistment)
{
if (_ThrowOnRollback)
throw new Exception("Simulated rollback error");
base.Rollback(enlistment);
}
public override void Commit(Enlistment enlistment)
{
if (_ThrowOnCommit)
throw new Exception("Simulated commit error");
base.Commit(enlistment);
}
void IEnlistmentNotification.Commit(Enlistment enlistment)
{
if (_ThrowIt && ++_ErrorCount < 2)
throw new ApplicationException("simulating resource failure");
enlistment.Done();
}
public void Commit(Enlistment enlistment)
{
enlistment.Done();
this.notification.Committed(false, 0, 0);
Marshal.ReleaseComObject(this.notification);
this.notification = null;
}
public void Commit(Enlistment enlistment)
{
#if DEBUG
System.Diagnostics.Trace.WriteLine("NuoDbTransaction::IEnlistmentNotification::Commit()");
#endif
Commit();
enlistment.Done();
}
public void Rollback(Enlistment enlistment)
{
foreach (var x in _rollbackCommands)
{
x();
}
enlistment.Done();
}
public void InDoubt( Enlistment enlistment )
{
Status = TxfmStatus.InInDoubt;
enlistment.Done();
Status = TxfmStatus.InTransaction;
}
public void InDoubt(Enlistment enlistment)
{
lock (_sharedLock)
{
if (InDoubtAction != null) InDoubtAction();
}
enlistment.Done();
}
public void Rollback(Enlistment enlistment)
{
lock (_sharedLock)
{
if (RollbackAction != null) RollbackAction();
}
enlistment.Done();
}
/// <summary>
/// Responds to the Commit notification.
/// </summary>
/// <param name="enlistment">An Enlistment that facilitates communication between the enlisted transaction participant and the transaction manager during the final phase of the transaction.</param>
public override void Commit(Enlistment enlistment)
{
if (enlistment != null)
{
// Indicate that the transaction participant has completed its work.
enlistment.Done();
}
}
public void Commit(Enlistment enlistment)
{
lock (_sharedLock)
{
if (CommitAction != null) CommitAction();
}
enlistment.Done();
}
public virtual void InDoubt(Enlistment enlistment)
{
Trace.WriteIf(Tracing.Is.TraceVerbose, string.Empty);
if (null != enlistment)
{
enlistment.Done();
}
}
public void Commit(Enlistment enlistment)
{
foreach (var x in _commands)
{
x();
}
enlistment.Done();
}
public void Commit(Enlistment enlistment)
{
if (_model.IsOpen)
{
_model.TxCommit();
}
enlistment.Done();
}
public void Rollback(Enlistment enlistment)
{
if (_model.IsOpen)
{
_model.TxRollback();
}
enlistment.Done();
}
void IEnlistmentNotification.Rollback(Enlistment enlistment)
{
enlistment.Done();
Fx.Assert(this.currentTransaction.TransactionInformation.Status == TransactionStatus.Aborted, "Transaction state should be Aborted at this point");
TransactionException exception = this.GetAbortedOrInDoubtTransactionException();
Fx.Assert(exception != null, "Need a valid TransactionException at this point");
this.durableInstance.OnTransactionAbortOrInDoubt(exception);
}
public void InDoubt(Enlistment enlistment)
{
AssertEnlisted();
log.Warn("AmbientTxHack in doubt...");
DisposeStuff();
enlistment.Done();
}
public override void Commit(Enlistment enlistment)
{
foreach (var action in Actions)
{
action.Invoke();
}
base.Commit(enlistment);
}
internal DurableInternalEnlistment(Enlistment enlistment, Guid resourceManagerIdentifier, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, Transaction atomicTransaction) : base(enlistment, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction)
{
this.resourceManagerIdentifier = resourceManagerIdentifier;
}
public static Enlistment Reenlist(
Guid resourceManagerIdentifier,
byte[] recoveryInformation,
IEnlistmentNotification enlistmentNotification)
{
if (resourceManagerIdentifier == Guid.Empty)
{
throw new ArgumentException(SR.BadResourceManagerId, nameof(resourceManagerIdentifier));
}
if (null == recoveryInformation)
{
throw new ArgumentNullException(nameof(recoveryInformation));
}
if (null == enlistmentNotification)
{
throw new ArgumentNullException(nameof(enlistmentNotification));
}
TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.MethodEnter(TraceSourceType.TraceSourceBase, "TransactionManager.Reenlist");
etwLog.TransactionManagerReenlist(resourceManagerIdentifier);
}
// Put the recovery information into a stream.
MemoryStream stream = new MemoryStream(recoveryInformation);
int recoveryInformationVersion = 0;
string nodeName = null;
byte[] resourceManagerRecoveryInformation = null;
try
{
BinaryReader reader = new BinaryReader(stream);
recoveryInformationVersion = reader.ReadInt32();
if (recoveryInformationVersion == TransactionManager.RecoveryInformationVersion1)
{
nodeName = reader.ReadString();
resourceManagerRecoveryInformation = reader.ReadBytes(recoveryInformation.Length - checked ((int)stream.Position));
}
else
{
if (etwLog.IsEnabled())
{
etwLog.TransactionExceptionTrace(TraceSourceType.TraceSourceBase, TransactionExceptionType.UnrecognizedRecoveryInformation, nameof(recoveryInformation), string.Empty);
}
throw new ArgumentException(SR.UnrecognizedRecoveryInformation, nameof(recoveryInformation));
}
}
catch (EndOfStreamException e)
{
if (etwLog.IsEnabled())
{
etwLog.TransactionExceptionTrace(TraceSourceType.TraceSourceBase, TransactionExceptionType.UnrecognizedRecoveryInformation, nameof(recoveryInformation), e.ToString());
}
throw new ArgumentException(SR.UnrecognizedRecoveryInformation, nameof(recoveryInformation), e);
}
catch (FormatException e)
{
if (etwLog.IsEnabled())
{
etwLog.TransactionExceptionTrace(TraceSourceType.TraceSourceBase, TransactionExceptionType.UnrecognizedRecoveryInformation, nameof(recoveryInformation), e.ToString());
}
throw new ArgumentException(SR.UnrecognizedRecoveryInformation, nameof(recoveryInformation), e);
}
finally
{
stream.Dispose();
}
DistributedTransactionManager transactionManager = CheckTransactionManager(nodeName);
// Now ask the Transaction Manager to reenlist.
object syncRoot = new object();
Enlistment returnValue = new Enlistment(enlistmentNotification, syncRoot);
EnlistmentState.EnlistmentStatePromoted.EnterState(returnValue.InternalEnlistment);
returnValue.InternalEnlistment.PromotedEnlistment =
transactionManager.ReenlistTransaction(
resourceManagerIdentifier,
resourceManagerRecoveryInformation,
(RecoveringInternalEnlistment)returnValue.InternalEnlistment
);
if (etwLog.IsEnabled())
{
etwLog.MethodExit(TraceSourceType.TraceSourceBase, "TransactionManager.Reenlist");
}
return(returnValue);
}
protected DurableInternalEnlistment(Enlistment enlistment, IEnlistmentNotification twoPhaseNotifications) :
base(enlistment, twoPhaseNotifications)
{
}
internal RecoveringInternalEnlistment(Enlistment enlistment, IEnlistmentNotification twoPhaseNotifications, object syncRoot) :
base(enlistment, twoPhaseNotifications)
{
_syncRoot = syncRoot;
}
static public Enlistment Reenlist(
Guid resourceManagerIdentifier,
byte[] recoveryInformation,
IEnlistmentNotification enlistmentNotification
)
{
if (resourceManagerIdentifier == Guid.Empty)
{
throw new ArgumentException(SR.GetString(SR.BadResourceManagerId), "resourceManagerIdentifier");
}
if (null == recoveryInformation)
{
throw new ArgumentNullException("recoveryInformation");
}
if (null == enlistmentNotification)
{
throw new ArgumentNullException("enlistmentNotification");
}
if (!TransactionManager._platformValidated)
{
TransactionManager.ValidatePlatform();
}
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
"TransactionManager.Reenlist"
);
}
if (DiagnosticTrace.Information)
{
ReenlistTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
resourceManagerIdentifier
);
}
// Put the recovery information into a stream.
MemoryStream stream = new MemoryStream(recoveryInformation);
int recoveryInformationVersion = 0;
string nodeName = null;
byte[] resourceManagerRecoveryInformation = null;
try
{
BinaryReader reader = new BinaryReader(stream);
recoveryInformationVersion = reader.ReadInt32();
if (recoveryInformationVersion == TransactionManager.recoveryInformationVersion1)
{
nodeName = reader.ReadString();
resourceManagerRecoveryInformation = reader.ReadBytes(recoveryInformation.Length - checked ((int)stream.Position));
}
else
{
if (DiagnosticTrace.Error)
{
TransactionExceptionTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
SR.GetString(SR.UnrecognizedRecoveryInformation)
);
}
throw new ArgumentException(SR.GetString(SR.UnrecognizedRecoveryInformation), "recoveryInformation");
}
}
catch (System.IO.EndOfStreamException e)
{
if (DiagnosticTrace.Error)
{
TransactionExceptionTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
SR.GetString(SR.UnrecognizedRecoveryInformation)
);
}
throw new ArgumentException(SR.GetString(SR.UnrecognizedRecoveryInformation), "recoveryInformation", e);
}
catch (System.FormatException e)
{
if (DiagnosticTrace.Error)
{
TransactionExceptionTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
SR.GetString(SR.UnrecognizedRecoveryInformation)
);
}
throw new ArgumentException(SR.GetString(SR.UnrecognizedRecoveryInformation), "recoveryInformation", e);
}
finally
{
stream.Close();
}
Oletx.OletxTransactionManager transactionManager = CheckTransactionManager(nodeName);
// Now ask the Transaction Manager to reenlist.
object syncRoot = new object();
Enlistment returnValue = new Enlistment(enlistmentNotification, syncRoot);
EnlistmentState._EnlistmentStatePromoted.EnterState(returnValue.InternalEnlistment);
returnValue.InternalEnlistment.PromotedEnlistment =
transactionManager.ReenlistTransaction(
resourceManagerIdentifier,
resourceManagerRecoveryInformation,
(RecoveringInternalEnlistment)returnValue.InternalEnlistment
);
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
"TransactionManager.Reenlist"
);
}
return(returnValue);
}