private void Timeout()
{
if (!this.complete && (null != this.expectedCurrent))
{
if (DiagnosticTrace.Warning)
{
TransactionScopeTimeoutTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceBase"), this.expectedCurrent.TransactionTraceId);
}
try
{
this.expectedCurrent.Rollback();
}
catch (ObjectDisposedException exception2)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceBase"), exception2);
}
}
catch (TransactionException exception)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceBase"), exception);
}
}
}
}
internal void Commit()
{
try
{
this.transactionShim.Commit();
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_ABORTED == exception.ErrorCode) || (System.Transactions.Oletx.NativeMethods.XACT_E_INDOUBT == exception.ErrorCode))
{
Interlocked.CompareExchange <Exception>(ref this.innerException, exception, null);
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
else
{
if (System.Transactions.Oletx.NativeMethods.XACT_E_ALREADYINPROGRESS == exception.ErrorCode)
{
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("TransactionAlreadyOver"), exception);
}
OletxTransactionManager.ProxyException(exception);
throw;
}
}
}
internal override void DecrementOutstandingNotifications(bool voteYes)
{
bool flag = false;
IPhase0EnlistmentShim shim = null;
lock (this)
{
if (DiagnosticTrace.Verbose)
{
string methodName = "OletxPhase0VolatileEnlistmentContainer.DecrementOutstandingNotifications, outstandingNotifications = " + this.outstandingNotifications.ToString(CultureInfo.CurrentCulture) + ", incompleteDependentClones = " + this.incompleteDependentClones.ToString(CultureInfo.CurrentCulture);
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), methodName);
}
base.outstandingNotifications--;
base.collectedVoteYes = base.collectedVoteYes && voteYes;
if ((base.outstandingNotifications == 0) && (base.incompleteDependentClones == 0))
{
if ((base.phase == 0) && !base.alreadyVoted)
{
flag = true;
base.alreadyVoted = true;
shim = this.phase0EnlistmentShim;
}
base.realOletxTransaction.DecrementUndecidedEnlistments();
}
}
try
{
if (flag && (shim != null))
{
shim.Phase0Done(base.collectedVoteYes && !base.realOletxTransaction.Doomed);
}
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN == exception.ErrorCode) || (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE == exception.ErrorCode))
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
else
{
if (System.Transactions.Oletx.NativeMethods.XACT_E_PROTOCOL != exception.ErrorCode)
{
throw;
}
this.phase0EnlistmentShim = null;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
}
if (DiagnosticTrace.Verbose)
{
string str = "OletxPhase0VolatileEnlistmentContainer.DecrementOutstandingNotifications";
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), str);
}
}
protected override void InternalPrepare()
{
try
{
_transaction.State.ChangeStatePromotedPhase1(_transaction);
}
catch (TransactionAbortedException e)
{
_promotedEnlistment.ForceRollback(e);
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(SR.TraceSourceLtm,
e);
}
}
catch (TransactionInDoubtException e)
{
_promotedEnlistment.EnlistmentDone();
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(SR.TraceSourceLtm,
e);
}
}
}
internal override void RollbackFromTransaction()
{
bool flag = false;
IVoterBallotShim voterBallotShim = null;
lock (this)
{
if (DiagnosticTrace.Verbose)
{
string methodName = "OletxPhase1VolatileEnlistmentContainer.RollbackFromTransaction, outstandingNotifications = " + this.outstandingNotifications.ToString(CultureInfo.CurrentCulture) + ", incompleteDependentClones = " + this.incompleteDependentClones.ToString(CultureInfo.CurrentCulture);
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), methodName);
}
if ((1 == base.phase) && (0 < base.outstandingNotifications))
{
base.alreadyVoted = true;
flag = true;
voterBallotShim = this.voterBallotShim;
}
}
if (flag)
{
try
{
if (voterBallotShim != null)
{
voterBallotShim.Vote(false);
}
this.Aborted();
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN != exception.ErrorCode) && (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE != exception.ErrorCode))
{
throw;
}
lock (this)
{
if (1 == base.phase)
{
this.InDoubt();
}
}
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
finally
{
HandleTable.FreeHandle(this.voterHandle);
}
}
if (DiagnosticTrace.Verbose)
{
string str = "OletxPhase1VolatileEnlistmentContainer.RollbackFromTransaction";
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), str);
}
}
internal void Rollback()
{
lock (this)
{
if ((TransactionStatus.Aborted != this.status) && (this.status != TransactionStatus.Active))
{
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("TransactionAlreadyOver"), null);
}
if (TransactionStatus.Aborted == this.status)
{
return;
}
if (0 < this.undecidedEnlistmentCount)
{
this.doomed = true;
}
else if (this.tooLateForEnlistments)
{
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("TransactionAlreadyOver"), null);
}
if (this.phase0EnlistVolatilementContainerList != null)
{
foreach (OletxPhase0VolatileEnlistmentContainer container in this.phase0EnlistVolatilementContainerList)
{
container.RollbackFromTransaction();
}
}
if (this.phase1EnlistVolatilementContainer != null)
{
this.phase1EnlistVolatilementContainer.RollbackFromTransaction();
}
}
try
{
this.transactionShim.Abort();
}
catch (COMException exception)
{
if (System.Transactions.Oletx.NativeMethods.XACT_E_ALREADYINPROGRESS == exception.ErrorCode)
{
if (!this.doomed)
{
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("TransactionAlreadyOver"), exception);
}
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
else
{
OletxTransactionManager.ProxyException(exception);
throw;
}
}
}
public void InDoubt(Exception e)
{
IEnlistmentShim enlistmentShim = null;
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxSinglePhaseEnlistment.InDoubt");
}
if (DiagnosticTrace.Warning)
{
EnlistmentCallbackNegativeTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, EnlistmentCallback.InDoubt);
}
lock (this)
{
if (!this.isSinglePhase || (OletxEnlistmentState.SinglePhaseCommitting != this.state))
{
throw TransactionException.CreateEnlistmentStateException(System.Transactions.SR.GetString("TraceSourceOletx"), null);
}
this.state = OletxEnlistmentState.InDoubt;
enlistmentShim = this.EnlistmentShim;
}
lock (base.oletxTransaction.realOletxTransaction)
{
if (base.oletxTransaction.realOletxTransaction.innerException == null)
{
base.oletxTransaction.realOletxTransaction.innerException = e;
}
}
try
{
if (enlistmentShim != null)
{
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.InDoubt);
}
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN != exception.ErrorCode) && (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE != exception.ErrorCode))
{
throw;
}
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
finally
{
this.FinishEnlistment();
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxSinglePhaseEnlistment.InDoubt");
}
}
public void CommitRequest()
{
IEnlistmentShim enlistmentShim = null;
IEnlistmentNotificationInternal iEnlistmentNotification = null;
bool flag = false;
lock (this)
{
if (OletxEnlistmentState.Prepared == this.state)
{
this.state = OletxEnlistmentState.Committing;
iEnlistmentNotification = this.iEnlistmentNotification;
}
else
{
enlistmentShim = this.EnlistmentShim;
flag = true;
}
}
if (iEnlistmentNotification != null)
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.Commit);
}
iEnlistmentNotification.Commit(this);
}
else if (enlistmentShim != null)
{
try
{
enlistmentShim.CommitRequestDone();
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN != exception.ErrorCode) && (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE != exception.ErrorCode))
{
throw;
}
flag = true;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
finally
{
if (flag)
{
this.FinishEnlistment();
}
}
}
}
internal override void EnterState(InternalTransaction tx)
{
if (tx.outcomeSource.isoLevel == IsolationLevel.Snapshot)
{
throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("CannotPromoteSnapshot"), null);
}
base.CommonEnterState(tx);
OletxTransaction transaction = null;
try
{
if (DiagnosticTrace.Verbose && (tx.durableEnlistment != null))
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.durableEnlistment.EnlistmentTraceId, NotificationCall.Promote);
}
transaction = TransactionState._TransactionStatePSPEOperation.PSPEPromote(tx);
}
catch (TransactionPromotionException exception)
{
tx.innerException = exception;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception);
}
}
finally
{
if (transaction == null)
{
tx.State.ChangeStateAbortedDuringPromotion(tx);
}
}
if (transaction != null)
{
tx.PromotedTransaction = transaction;
Hashtable promotedTransactionTable = TransactionManager.PromotedTransactionTable;
lock (promotedTransactionTable)
{
tx.finalizedObject = new FinalizedObject(tx, tx.PromotedTransaction.Identifier);
WeakReference reference = new WeakReference(tx.outcomeSource, false);
promotedTransactionTable[tx.PromotedTransaction.Identifier] = reference;
}
TransactionManager.FireDistributedTransactionStarted(tx.outcomeSource);
if (DiagnosticTrace.Information)
{
TransactionPromotedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId, transaction.TransactionTraceId);
}
this.PromoteEnlistmentsAndOutcome(tx);
}
}
internal static uint AdjustTimeout(TimeSpan timeout)
{
try
{
return(Convert.ToUInt32(timeout.TotalMilliseconds, CultureInfo.CurrentCulture));
}
catch (OverflowException exception)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
return(uint.MaxValue);
}
}
internal bool CallProxyReenlistComplete()
{
bool flag = false;
if (this.RecoveryCompleteCalledByApplication)
{
IResourceManagerShim resourceManagerShim = null;
try
{
try
{
resourceManagerShim = this.ResourceManagerShim;
if (resourceManagerShim != null)
{
resourceManagerShim.ReenlistComplete();
flag = true;
}
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN == exception.ErrorCode) || (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE == exception.ErrorCode))
{
flag = false;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
return(flag);
}
if (System.Transactions.Oletx.NativeMethods.XACT_E_RECOVERYALREADYDONE != exception.ErrorCode)
{
OletxTransactionManager.ProxyException(exception);
throw;
}
return(true);
}
return(flag);
}
finally
{
resourceManagerShim = null;
}
}
return(true);
}
internal override void Phase0VolatilePrepareDone(InternalTransaction tx)
{
try
{
TransactionState._TransactionStatePromotedCommitting.EnterState(tx);
}
catch (TransactionException exception)
{
if (tx.innerException == null)
{
tx.innerException = exception;
}
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception);
}
}
}
private static Transaction JitSafeGetContextTransaction(ContextData contextData)
{
SafeIUnknown safeUnknown = null;
if (contextData.WeakDefaultComContext != null)
{
safeUnknown = (SafeIUnknown)contextData.WeakDefaultComContext.Target;
}
if ((contextData.DefaultComContextState == DefaultComContextState.Unknown) || ((contextData.DefaultComContextState == DefaultComContextState.Available) && (safeUnknown == null)))
{
try
{
System.Transactions.NativeMethods.CoGetDefaultContext(-1, ref IID_IObjContext, out safeUnknown);
contextData.WeakDefaultComContext = new WeakReference(safeUnknown);
contextData.DefaultComContextState = DefaultComContextState.Available;
}
catch (EntryPointNotFoundException exception)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceBase"), exception);
}
contextData.DefaultComContextState = DefaultComContextState.Unavailable;
}
}
if (contextData.DefaultComContextState == DefaultComContextState.Available)
{
IntPtr zero = IntPtr.Zero;
System.Transactions.NativeMethods.CoGetContextToken(out zero);
if (safeUnknown.DangerousGetHandle() == zero)
{
return(null);
}
}
if (!ContextUtil.IsInTransaction)
{
return(null);
}
return(ContextUtil.SystemTransaction);
}
internal static UInt32 AdjustTimeout(
TimeSpan timeout
)
{
UInt32 returnTimeout = 0;
try
{
returnTimeout = (Convert.ToUInt32(timeout.TotalMilliseconds, CultureInfo.CurrentCulture));
}
// timeout.TotalMilliseconds might be negative, so let's catch overflow exceptions, just in case.
catch (OverflowException caughtEx)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
caughtEx);
}
returnTimeout = UInt32.MaxValue;
}
return(returnTimeout);
}
internal override void Timeout(InternalTransaction tx)
{
try
{
if (tx.innerException == null)
{
tx.innerException = new TimeoutException(System.Transactions.SR.GetString("TraceTransactionTimeout"));
}
tx.PromotedTransaction.Rollback();
if (DiagnosticTrace.Warning)
{
TransactionTimeoutTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId);
}
}
catch (TransactionException exception)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception);
}
}
}
protected override void InternalPrepare()
{
try
{
base.transaction.State.ChangeStatePromotedPhase1(base.transaction);
}
catch (TransactionAbortedException exception)
{
base.oletxEnlistment.ForceRollback(exception);
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception);
}
}
catch (TransactionInDoubtException exception2)
{
base.oletxEnlistment.EnlistmentDone();
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception2);
}
}
}
public void EnlistmentDone()
{
bool flag;
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxEnlistment.EnlistmentDone");
EnlistmentCallbackPositiveTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, EnlistmentCallback.Done);
}
IEnlistmentShim enlistmentShim = null;
IPhase0EnlistmentShim shim2 = null;
OletxEnlistmentState active = OletxEnlistmentState.Active;
bool fabricateRollback = false;
lock (this)
{
active = this.state;
if (this.state == OletxEnlistmentState.Active)
{
shim2 = this.Phase0EnlistmentShim;
if (shim2 != null)
{
base.oletxTransaction.realOletxTransaction.DecrementUndecidedEnlistments();
}
flag = false;
}
else if (OletxEnlistmentState.Preparing == this.state)
{
enlistmentShim = this.EnlistmentShim;
flag = true;
}
else if (OletxEnlistmentState.Phase0Preparing == this.state)
{
shim2 = this.Phase0EnlistmentShim;
base.oletxTransaction.realOletxTransaction.DecrementUndecidedEnlistments();
if (this.fabricateRollback)
{
flag = true;
}
else
{
flag = false;
}
}
else
{
if (((OletxEnlistmentState.Committing != this.state) && (OletxEnlistmentState.Aborting != this.state)) && (OletxEnlistmentState.SinglePhaseCommitting != this.state))
{
throw TransactionException.CreateEnlistmentStateException(System.Transactions.SR.GetString("TraceSourceOletx"), null);
}
enlistmentShim = this.EnlistmentShim;
flag = true;
}
fabricateRollback = this.fabricateRollback;
this.state = OletxEnlistmentState.Done;
}
try
{
if (enlistmentShim != null)
{
if (OletxEnlistmentState.Preparing == active)
{
try
{
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.ReadOnly);
goto Label_01C1;
}
finally
{
HandleTable.FreeHandle(this.phase1Handle);
}
}
if (OletxEnlistmentState.Committing != active)
{
if (OletxEnlistmentState.Aborting != active)
{
if (OletxEnlistmentState.SinglePhaseCommitting != active)
{
throw TransactionException.CreateEnlistmentStateException(System.Transactions.SR.GetString("TraceSourceOletx"), null);
}
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.SinglePhase);
}
else if (!fabricateRollback)
{
enlistmentShim.AbortRequestDone();
}
}
else
{
enlistmentShim.CommitRequestDone();
}
}
else if (shim2 != null)
{
if (active != OletxEnlistmentState.Active)
{
if (OletxEnlistmentState.Phase0Preparing != active)
{
throw TransactionException.CreateEnlistmentStateException(System.Transactions.SR.GetString("TraceSourceOletx"), null);
}
shim2.Phase0Done(true);
}
else
{
shim2.Unenlist();
}
}
}
catch (COMException exception)
{
flag = true;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
finally
{
if (flag)
{
this.FinishEnlistment();
}
}
Label_01C1:
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxEnlistment.EnlistmentDone");
}
}
internal void Phase0Request(bool abortHint)
{
OletxVolatileEnlistment enlistment = null;
int count = 0;
OletxCommittableTransaction committableTransaction = null;
bool flag = false;
lock (this)
{
if (DiagnosticTrace.Verbose)
{
string methodName = "OletxPhase0VolatileEnlistmentContainer.Phase0Request, abortHint = " + abortHint.ToString(CultureInfo.CurrentCulture) + ", phase = " + this.phase.ToString(CultureInfo.CurrentCulture);
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), methodName);
}
this.aborting = abortHint;
committableTransaction = base.realOletxTransaction.committableTransaction;
if ((committableTransaction != null) && !committableTransaction.CommitCalled)
{
flag = true;
this.aborting = true;
}
if ((2 == base.phase) || (-1 == base.phase))
{
if (-1 == base.phase)
{
base.phase = 0;
}
if ((this.aborting || this.tmWentDown) || (flag || (2 == base.phase)))
{
if (this.phase0EnlistmentShim != null)
{
try
{
this.phase0EnlistmentShim.Phase0Done(false);
base.alreadyVoted = true;
}
catch (COMException exception)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
}
return;
}
base.outstandingNotifications = base.enlistmentList.Count;
count = base.enlistmentList.Count;
if (count == 0)
{
base.outstandingNotifications = 1;
}
}
else
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxPhase0VolatileEnlistmentContainer.Phase0Request, phase != -1");
}
throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
}
}
if (count == 0)
{
this.DecrementOutstandingNotifications(true);
}
else
{
for (int i = 0; i < count; i++)
{
enlistment = base.enlistmentList[i] as OletxVolatileEnlistment;
if (enlistment == null)
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
}
enlistment.Prepare(this);
}
}
if (DiagnosticTrace.Verbose)
{
string str = "OletxPhase0VolatileEnlistmentContainer.Phase0Request, abortHint = " + abortHint.ToString(CultureInfo.CurrentCulture);
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), str);
}
}
internal OletxEnlistment Reenlist(int prepareInfoLength, byte[] prepareInfo, IEnlistmentNotificationInternal enlistmentNotification)
{
OletxRecoveryInformation information;
OletxTransactionOutcome notKnownYet = OletxTransactionOutcome.NotKnownYet;
OletxTransactionStatus xactStatus = OletxTransactionStatus.OLETX_TRANSACTION_STATUS_NONE;
MemoryStream serializationStream = new MemoryStream(prepareInfo);
IFormatter formatter = new BinaryFormatter();
try
{
information = formatter.Deserialize(serializationStream) as OletxRecoveryInformation;
}
catch (SerializationException exception2)
{
throw new ArgumentException(System.Transactions.SR.GetString("InvalidArgument"), "prepareInfo", exception2);
}
if (information == null)
{
throw new ArgumentException(System.Transactions.SR.GetString("InvalidArgument"), "prepareInfo");
}
byte[] b = new byte[0x10];
for (int i = 0; i < 0x10; i++)
{
b[i] = information.proxyRecoveryInformation[i + 0x10];
}
Guid guid = new Guid(b);
if (guid != this.resourceManagerIdentifier)
{
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("ResourceManagerIdDoesNotMatchRecoveryInformation"), null);
}
IResourceManagerShim resourceManagerShim = null;
try
{
resourceManagerShim = this.ResourceManagerShim;
if (resourceManagerShim == null)
{
throw new COMException(System.Transactions.SR.GetString("DtcTransactionManagerUnavailable"), System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN);
}
resourceManagerShim.Reenlist(Convert.ToUInt32(information.proxyRecoveryInformation.Length, CultureInfo.InvariantCulture), information.proxyRecoveryInformation, out notKnownYet);
if (OletxTransactionOutcome.Committed == notKnownYet)
{
xactStatus = OletxTransactionStatus.OLETX_TRANSACTION_STATUS_COMMITTED;
}
else if (OletxTransactionOutcome.Aborted == notKnownYet)
{
xactStatus = OletxTransactionStatus.OLETX_TRANSACTION_STATUS_ABORTED;
}
else
{
xactStatus = OletxTransactionStatus.OLETX_TRANSACTION_STATUS_PREPARED;
this.StartReenlistThread();
}
}
catch (COMException exception)
{
if (System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN != exception.ErrorCode)
{
throw;
}
xactStatus = OletxTransactionStatus.OLETX_TRANSACTION_STATUS_PREPARED;
this.ResourceManagerShim = null;
this.StartReenlistThread();
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
finally
{
resourceManagerShim = null;
}
return(new OletxEnlistment(enlistmentNotification, xactStatus, information.proxyRecoveryInformation, this));
}
internal override void EnterState(InternalTransaction tx)
{
if (tx.outcomeSource.isoLevel == IsolationLevel.Snapshot)
{
throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("CannotPromoteSnapshot"), null);
}
base.CommonEnterState(tx);
OletxCommittableTransaction transaction = null;
try
{
TimeSpan zero;
if (tx.AbsoluteTimeout == 0x7fffffffffffffffL)
{
zero = TimeSpan.Zero;
}
else
{
zero = TransactionManager.TransactionTable.RecalcTimeout(tx);
if (zero <= TimeSpan.Zero)
{
return;
}
}
TransactionOptions properties = new TransactionOptions {
IsolationLevel = tx.outcomeSource.isoLevel,
Timeout = zero
};
transaction = TransactionManager.DistributedTransactionManager.CreateTransaction(properties);
transaction.savedLtmPromotedTransaction = tx.outcomeSource;
if (DiagnosticTrace.Information)
{
TransactionPromotedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId, transaction.TransactionTraceId);
}
}
catch (TransactionException exception)
{
tx.innerException = exception;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception);
}
return;
}
finally
{
if (transaction == null)
{
tx.State.ChangeStateAbortedDuringPromotion(tx);
}
}
tx.PromotedTransaction = transaction;
Hashtable promotedTransactionTable = TransactionManager.PromotedTransactionTable;
lock (promotedTransactionTable)
{
tx.finalizedObject = new FinalizedObject(tx, transaction.Identifier);
WeakReference reference = new WeakReference(tx.outcomeSource, false);
promotedTransactionTable[transaction.Identifier] = reference;
}
TransactionManager.FireDistributedTransactionStarted(tx.outcomeSource);
this.PromoteEnlistmentsAndOutcome(tx);
}
internal void ReenlistThread(object state)
{
int count = 0;
bool flag = false;
OletxEnlistment enlistment = null;
IResourceManagerShim resourceManagerShim = null;
Timer reenlistThreadTimer = null;
bool flag2 = false;
OletxResourceManager manager = (OletxResourceManager)state;
try
{
if (DiagnosticTrace.Information)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxResourceManager.ReenlistThread");
}
lock (manager)
{
resourceManagerShim = manager.ResourceManagerShim;
reenlistThreadTimer = manager.reenlistThreadTimer;
manager.reenlistThreadTimer = null;
manager.reenlistThread = Thread.CurrentThread;
}
if (resourceManagerShim != null)
{
lock (manager.reenlistList)
{
count = manager.reenlistList.Count;
}
flag = false;
while ((!flag && (count > 0)) && (resourceManagerShim != null))
{
lock (manager.reenlistList)
{
enlistment = null;
count--;
if (manager.reenlistList.Count == 0)
{
flag = true;
}
else
{
enlistment = manager.reenlistList[0] as OletxEnlistment;
if (enlistment == null)
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("InternalError"), null);
}
manager.reenlistList.RemoveAt(0);
object obj7 = enlistment;
lock (obj7)
{
if (OletxEnlistment.OletxEnlistmentState.Done == enlistment.State)
{
enlistment = null;
}
else if (OletxEnlistment.OletxEnlistmentState.Prepared != enlistment.State)
{
manager.reenlistList.Add(enlistment);
enlistment = null;
}
}
}
}
if (enlistment != null)
{
OletxTransactionOutcome notKnownYet = OletxTransactionOutcome.NotKnownYet;
try
{
if (enlistment.ProxyPrepareInfoByteArray == null)
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("InternalError"), null);
}
resourceManagerShim.Reenlist((uint)enlistment.ProxyPrepareInfoByteArray.Length, enlistment.ProxyPrepareInfoByteArray, out notKnownYet);
if (notKnownYet == OletxTransactionOutcome.NotKnownYet)
{
object obj5 = enlistment;
lock (obj5)
{
if (OletxEnlistment.OletxEnlistmentState.Done == enlistment.State)
{
enlistment = null;
}
else
{
lock (manager.reenlistList)
{
manager.reenlistList.Add(enlistment);
enlistment = null;
}
}
}
}
}
catch (COMException exception)
{
if (System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN != exception.ErrorCode)
{
throw;
}
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
if (System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN == exception.ErrorCode)
{
manager.ResourceManagerShim = null;
resourceManagerShim = manager.ResourceManagerShim;
}
}
if (enlistment != null)
{
object obj3 = enlistment;
lock (obj3)
{
if (OletxEnlistment.OletxEnlistmentState.Done != enlistment.State)
{
lock (manager.reenlistList)
{
manager.reenlistPendingList.Add(enlistment);
}
if (OletxTransactionOutcome.Committed != notKnownYet)
{
if (OletxTransactionOutcome.Aborted != notKnownYet)
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("InternalError"), null);
}
enlistment.State = OletxEnlistment.OletxEnlistmentState.Aborting;
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), enlistment.EnlistmentTraceId, NotificationCall.Rollback);
}
enlistment.EnlistmentNotification.Rollback(enlistment);
}
else
{
enlistment.State = OletxEnlistment.OletxEnlistmentState.Committing;
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), enlistment.EnlistmentTraceId, NotificationCall.Commit);
}
enlistment.EnlistmentNotification.Commit(enlistment);
}
}
else
{
enlistment = null;
}
continue;
}
}
}
}
}
resourceManagerShim = null;
lock (manager.reenlistList)
{
lock (manager)
{
count = manager.reenlistList.Count;
if ((0 >= count) && (0 >= manager.reenlistPendingList.Count))
{
if (!manager.CallProxyReenlistComplete())
{
manager.reenlistThreadTimer = reenlistThreadTimer;
if (!reenlistThreadTimer.Change(0x2710, -1))
{
throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("UnexpectedTimerFailure"), null);
}
}
else
{
flag2 = true;
}
}
else
{
manager.reenlistThreadTimer = reenlistThreadTimer;
if (!reenlistThreadTimer.Change(0x2710, -1))
{
throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("UnexpectedTimerFailure"), null);
}
}
manager.reenlistThread = null;
}
if (DiagnosticTrace.Information)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxResourceManager.ReenlistThread");
}
}
}
finally
{
resourceManagerShim = null;
if (flag2 && (reenlistThreadTimer != null))
{
reenlistThreadTimer.Dispose();
}
}
}
internal virtual void PromoteEnlistmentsAndOutcome(InternalTransaction tx)
{
bool flag = false;
tx.PromotedTransaction.RealTransaction.InternalTransaction = tx;
try
{
flag = this.PromotePhaseVolatiles(tx, ref tx.phase0Volatiles, true);
}
catch (TransactionException exception3)
{
tx.innerException = exception3;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception3);
}
return;
}
finally
{
if (!flag)
{
tx.PromotedTransaction.Rollback();
tx.State.ChangeStateAbortedDuringPromotion(tx);
}
}
flag = false;
try
{
flag = this.PromotePhaseVolatiles(tx, ref tx.phase1Volatiles, false);
}
catch (TransactionException exception2)
{
tx.innerException = exception2;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception2);
}
return;
}
finally
{
if (!flag)
{
tx.PromotedTransaction.Rollback();
tx.State.ChangeStateAbortedDuringPromotion(tx);
}
}
flag = false;
try
{
flag = this.PromoteDurable(tx);
}
catch (TransactionException exception)
{
tx.innerException = exception;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), exception);
}
}
finally
{
if (!flag)
{
tx.PromotedTransaction.Rollback();
tx.State.ChangeStateAbortedDuringPromotion(tx);
}
}
}
public bool PrepareRequest(bool singlePhase, byte[] prepareInfo)
{
IEnlistmentShim enlistmentShim = null;
OletxEnlistmentState active = OletxEnlistmentState.Active;
IEnlistmentNotificationInternal iEnlistmentNotification = null;
OletxRecoveryInformation thingToConvert = null;
lock (this)
{
if (this.state == OletxEnlistmentState.Active)
{
active = this.state = OletxEnlistmentState.Preparing;
}
else
{
active = this.state;
}
iEnlistmentNotification = this.iEnlistmentNotification;
enlistmentShim = this.EnlistmentShim;
base.oletxTransaction.realOletxTransaction.TooLateForEnlistments = true;
}
if (OletxEnlistmentState.Preparing == active)
{
thingToConvert = new OletxRecoveryInformation(prepareInfo);
this.isSinglePhase = singlePhase;
long length = prepareInfo.Length;
this.proxyPrepareInfoByteArray = new byte[length];
Array.Copy(prepareInfo, this.proxyPrepareInfoByteArray, length);
if (this.isSinglePhase && this.canDoSinglePhase)
{
ISinglePhaseNotificationInternal internal3 = (ISinglePhaseNotificationInternal)iEnlistmentNotification;
this.state = OletxEnlistmentState.SinglePhaseCommitting;
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.SinglePhaseCommit);
}
internal3.SinglePhaseCommit(this);
return(true);
}
byte[] resourceManagerRecoveryInformation = TransactionManager.ConvertToByteArray(thingToConvert);
this.state = OletxEnlistmentState.Preparing;
this.prepareInfoByteArray = TransactionManager.GetRecoveryInformation(base.oletxResourceManager.oletxTransactionManager.CreationNodeName, resourceManagerRecoveryInformation);
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.Prepare);
}
iEnlistmentNotification.Prepare(this);
return(false);
}
if (OletxEnlistmentState.Prepared == active)
{
try
{
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.Prepared);
return(false);
}
catch (COMException exception3)
{
OletxTransactionManager.ProxyException(exception3);
throw;
}
}
if (OletxEnlistmentState.Done == active)
{
try
{
bool flag;
try
{
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.ReadOnly);
flag = true;
}
finally
{
this.FinishEnlistment();
}
return(flag);
}
catch (COMException exception2)
{
OletxTransactionManager.ProxyException(exception2);
throw;
}
}
try
{
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.Failed);
}
catch (COMException exception)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
return(true);
}
public void Prepared()
{
int num1 = System.Transactions.Oletx.NativeMethods.S_OK;
IEnlistmentShim enlistmentShim = null;
IPhase0EnlistmentShim shim = null;
bool fabricateRollback = false;
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxPreparingEnlistment.Prepared");
EnlistmentCallbackPositiveTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, EnlistmentCallback.Prepared);
}
lock (this)
{
if (OletxEnlistmentState.Preparing == this.state)
{
enlistmentShim = this.EnlistmentShim;
}
else
{
if (OletxEnlistmentState.Phase0Preparing != this.state)
{
throw TransactionException.CreateEnlistmentStateException(System.Transactions.SR.GetString("TraceSourceOletx"), null);
}
shim = this.Phase0EnlistmentShim;
if (base.oletxTransaction.realOletxTransaction.Doomed || this.fabricateRollback)
{
this.fabricateRollback = true;
fabricateRollback = this.fabricateRollback;
}
}
this.state = OletxEnlistmentState.Prepared;
}
try
{
if (enlistmentShim != null)
{
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.Prepared);
}
else if (shim != null)
{
base.oletxTransaction.realOletxTransaction.DecrementUndecidedEnlistments();
shim.Phase0Done(!fabricateRollback);
}
else
{
fabricateRollback = true;
}
if (fabricateRollback)
{
this.AbortRequest();
}
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN == exception.ErrorCode) || (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE == exception.ErrorCode))
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
else
{
if (System.Transactions.Oletx.NativeMethods.XACT_E_PROTOCOL != exception.ErrorCode)
{
throw;
}
this.Phase0EnlistmentShim = null;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxPreparingEnlistment.Prepared");
}
}
public void Phase0Request(bool abortingHint)
{
IEnlistmentNotificationInternal iEnlistmentNotification = null;
OletxEnlistmentState active = OletxEnlistmentState.Active;
OletxCommittableTransaction committableTransaction = null;
bool flag = false;
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxEnlistment.Phase0Request");
}
committableTransaction = base.oletxTransaction.realOletxTransaction.committableTransaction;
if ((committableTransaction != null) && !committableTransaction.CommitCalled)
{
flag = true;
}
lock (this)
{
this.aborting = abortingHint;
if (this.state == OletxEnlistmentState.Active)
{
if ((this.aborting || flag) || this.tmWentDown)
{
if (this.phase0Shim != null)
{
try
{
this.phase0Shim.Phase0Done(false);
}
catch (COMException exception)
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
}
}
else
{
active = this.state = OletxEnlistmentState.Phase0Preparing;
iEnlistmentNotification = this.iEnlistmentNotification;
}
}
}
if (iEnlistmentNotification != null)
{
if (OletxEnlistmentState.Phase0Preparing != active)
{
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxEnlistment.Phase0Request");
}
return;
}
byte[] buffer = this.transactionGuid.ToByteArray();
byte[] buffer2 = base.oletxResourceManager.resourceManagerIdentifier.ToByteArray();
byte[] buffer4 = new byte[buffer.Length + buffer2.Length];
Thread.MemoryBarrier();
this.proxyPrepareInfoByteArray = buffer4;
int index = 0;
for (index = 0; index < buffer.Length; index++)
{
this.proxyPrepareInfoByteArray[index] = buffer[index];
}
for (index = 0; index < buffer2.Length; index++)
{
this.proxyPrepareInfoByteArray[buffer.Length + index] = buffer2[index];
}
OletxRecoveryInformation thingToConvert = new OletxRecoveryInformation(this.proxyPrepareInfoByteArray);
byte[] resourceManagerRecoveryInformation = TransactionManager.ConvertToByteArray(thingToConvert);
this.prepareInfoByteArray = TransactionManager.GetRecoveryInformation(base.oletxResourceManager.oletxTransactionManager.CreationNodeName, resourceManagerRecoveryInformation);
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.Prepare);
}
iEnlistmentNotification.Prepare(this);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxEnlistment.Phase0Request");
}
}
public void ForceRollback(Exception e)
{
IPhase0EnlistmentShim shim = null;
IEnlistmentShim enlistmentShim = null;
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxPreparingEnlistment.ForceRollback");
}
if (DiagnosticTrace.Warning)
{
EnlistmentCallbackNegativeTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, EnlistmentCallback.ForceRollback);
}
lock (this)
{
if (OletxEnlistmentState.Preparing == this.state)
{
enlistmentShim = this.EnlistmentShim;
}
else
{
if (OletxEnlistmentState.Phase0Preparing != this.state)
{
throw TransactionException.CreateEnlistmentStateException(System.Transactions.SR.GetString("TraceSourceOletx"), null);
}
shim = this.Phase0EnlistmentShim;
if (shim != null)
{
base.oletxTransaction.realOletxTransaction.DecrementUndecidedEnlistments();
}
}
this.state = OletxEnlistmentState.Aborted;
}
Interlocked.CompareExchange <Exception>(ref base.oletxTransaction.realOletxTransaction.innerException, e, null);
try
{
if (enlistmentShim != null)
{
try
{
enlistmentShim.PrepareRequestDone(OletxPrepareVoteType.Failed);
}
finally
{
HandleTable.FreeHandle(this.phase1Handle);
}
}
if (shim != null)
{
shim.Phase0Done(false);
}
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN != exception.ErrorCode) && (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE != exception.ErrorCode))
{
throw;
}
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
finally
{
this.FinishEnlistment();
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxPreparingEnlistment.ForceRollback");
}
}
