internal override void EnterState(InternalEnlistment enlistment)
{
// Set the enlistment state
enlistment.State = this;
Monitor.Exit(enlistment.Transaction);
try // Don't hold this lock while calling into the application code.
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
enlistment.EnlistmentTraceId,
NotificationCall.InDoubt
);
}
// Forward the notification to the enlistment
enlistment.EnlistmentNotification.InDoubt(enlistment.PreparingEnlistment);
}
finally
{
#pragma warning disable 0618
//@
Monitor.Enter(enlistment.Transaction);
#pragma warning restore 0618
}
}
internal override void EnterState(InternalEnlistment enlistment)
{
// Set the enlistment state
enlistment.State = this;
Monitor.Exit(enlistment.Transaction);
try
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(SR.TraceSourceLtm,
enlistment.EnlistmentTraceId, NotificationCall.Rollback);
}
// Send the Rollback notification to the enlistment
if (enlistment.SinglePhaseNotification != null)
{
enlistment.SinglePhaseNotification.Rollback(enlistment.SinglePhaseEnlistment);
}
else
{
enlistment.PromotableSinglePhaseNotification.Rollback(enlistment.SinglePhaseEnlistment);
}
}
finally
{
Monitor.Enter(enlistment.Transaction);
}
}
internal override void EnterState(InternalEnlistment enlistment)
{
bool spcCommitted = false;
// Set the enlistment state
enlistment.State = this;
// Send Single Phase Commit to the enlistment
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(SR.TraceSourceLtm,
enlistment.EnlistmentTraceId,
NotificationCall.SinglePhaseCommit
);
}
Monitor.Exit(enlistment.Transaction);
try // Don't hold this lock while calling into the application code.
{
enlistment.SinglePhaseNotification.SinglePhaseCommit(enlistment.SinglePhaseEnlistment);
spcCommitted = true;
}
finally
{
if (!spcCommitted)
{
//If we have an exception thrown in SPC, we don't know the if the enlistment is committed or not
//reply indoubt
enlistment.SinglePhaseEnlistment.InDoubt();
}
Monitor.Enter(enlistment.Transaction);
}
}
internal override void EnterState(InternalEnlistment enlistment)
{
bool flag = false;
enlistment.State = this;
Monitor.Exit(enlistment.Transaction);
try
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), enlistment.EnlistmentTraceId, NotificationCall.SinglePhaseCommit);
}
if (enlistment.SinglePhaseNotification != null)
{
enlistment.SinglePhaseNotification.SinglePhaseCommit(enlistment.SinglePhaseEnlistment);
}
else
{
enlistment.PromotableSinglePhaseNotification.SinglePhaseCommit(enlistment.SinglePhaseEnlistment);
}
flag = true;
}
finally
{
if (!flag)
{
enlistment.SinglePhaseEnlistment.InDoubt();
}
Monitor.Enter(enlistment.Transaction);
}
}
internal void Prepare(OletxVolatileEnlistmentContainer container)
{
OletxVolatileEnlistmentState active = OletxVolatileEnlistmentState.Active;
IEnlistmentNotificationInternal iEnlistmentNotification = null;
lock (this)
{
iEnlistmentNotification = this.iEnlistmentNotification;
if (this.state == OletxVolatileEnlistmentState.Active)
{
active = this.state = OletxVolatileEnlistmentState.Preparing;
}
else
{
active = this.state;
}
this.container = container;
}
if (OletxVolatileEnlistmentState.Preparing == active)
{
if (iEnlistmentNotification != null)
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.Prepare);
}
iEnlistmentNotification.Prepare(this);
return;
}
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
}
if (OletxVolatileEnlistmentState.Done == active)
{
container.DecrementOutstandingNotifications(true);
}
else if ((OletxVolatileEnlistmentState.Prepared == active) && this.enlistDuringPrepareRequired)
{
container.DecrementOutstandingNotifications(true);
}
else if ((OletxVolatileEnlistmentState.Aborting == active) || (OletxVolatileEnlistmentState.Aborted == active))
{
container.DecrementOutstandingNotifications(false);
}
else
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
}
}
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 void InDoubt()
{
OletxVolatileEnlistmentState active = OletxVolatileEnlistmentState.Active;
IEnlistmentNotificationInternal iEnlistmentNotification = null;
lock (this)
{
if (OletxVolatileEnlistmentState.Prepared == this.state)
{
active = this.state = OletxVolatileEnlistmentState.InDoubt;
iEnlistmentNotification = this.iEnlistmentNotification;
}
else
{
if (OletxVolatileEnlistmentState.Preparing == this.state)
{
this.pendingOutcome = TransactionStatus.InDoubt;
}
active = this.state;
}
}
if (OletxVolatileEnlistmentState.InDoubt == active)
{
if (iEnlistmentNotification != null)
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.InDoubt);
}
iEnlistmentNotification.InDoubt(this);
return;
}
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
}
if ((OletxVolatileEnlistmentState.Preparing != active) && (OletxVolatileEnlistmentState.Done != active))
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
}
}
internal override void EnterState(InternalTransaction tx)
{
base.CommonEnterState(tx);
Monitor.Exit(tx);
try
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.durableEnlistment.EnlistmentTraceId, NotificationCall.Rollback);
}
tx.durableEnlistment.PromotableSinglePhaseNotification.Rollback(tx.durableEnlistment.SinglePhaseEnlistment);
}
finally
{
Monitor.Enter(tx);
}
}
internal override void EnterState(InternalEnlistment enlistment)
{
enlistment.State = this;
Monitor.Exit(enlistment.Transaction);
try
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), enlistment.EnlistmentTraceId, NotificationCall.Prepare);
}
enlistment.EnlistmentNotification.Prepare(enlistment.PreparingEnlistment);
}
finally
{
Monitor.Enter(enlistment.Transaction);
}
}
internal override void EnterState(InternalEnlistment enlistment)
{
bool spcCommitted = false;
// Set the enlistment state
enlistment.State = this;
Monitor.Exit(enlistment.Transaction);
try
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
enlistment.EnlistmentTraceId,
NotificationCall.SinglePhaseCommit
);
}
// Send the Commit notification to the enlistment
if (enlistment.SinglePhaseNotification != null)
{
enlistment.SinglePhaseNotification.SinglePhaseCommit(enlistment.SinglePhaseEnlistment);
}
else
{
enlistment.PromotableSinglePhaseNotification.SinglePhaseCommit(enlistment.SinglePhaseEnlistment);
}
spcCommitted = true;
}
finally
{
if (!spcCommitted)
{
enlistment.SinglePhaseEnlistment.InDoubt();
}
#pragma warning disable 0618
//@
Monitor.Enter(enlistment.Transaction);
#pragma warning restore 0618
}
}
internal override void EnterState(InternalEnlistment enlistment)
{
// Set the enlistment state
enlistment.State = this;
Monitor.Exit(enlistment.Transaction);
try // Don't hold this lock while calling into the application code.
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(SR.TraceSourceLtm,
enlistment.EnlistmentTraceId,
NotificationCall.Rollback
);
}
enlistment.EnlistmentNotification.Rollback(enlistment.SinglePhaseEnlistment);
}
finally
{
Monitor.Enter(enlistment.Transaction);
}
}
internal override void EnterState(InternalEnlistment enlistment)
{
enlistment.State = this;
Monitor.Exit(enlistment.Transaction);
try
{
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), enlistment.EnlistmentTraceId, NotificationCall.Rollback);
}
if (enlistment.SinglePhaseNotification != null)
{
enlistment.SinglePhaseNotification.Rollback(enlistment.SinglePhaseEnlistment);
}
else
{
enlistment.PromotableSinglePhaseNotification.Rollback(enlistment.SinglePhaseEnlistment);
}
}
finally
{
Monitor.Enter(enlistment.Transaction);
}
}
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();
}
}
}
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");
}
}
internal OletxEnlistment(IEnlistmentNotificationInternal enlistmentNotification, OletxTransactionStatus xactStatus, byte[] prepareInfoByteArray, OletxResourceManager oletxResourceManager) : base(oletxResourceManager, null)
{
this.transactionGuid = Guid.Empty;
this.phase1Handle = IntPtr.Zero;
this.enlistmentShim = null;
this.phase0Shim = null;
this.canDoSinglePhase = false;
this.iEnlistmentNotification = enlistmentNotification;
this.state = OletxEnlistmentState.Active;
int length = prepareInfoByteArray.Length;
this.proxyPrepareInfoByteArray = new byte[length];
Array.Copy(prepareInfoByteArray, this.proxyPrepareInfoByteArray, length);
byte[] destinationArray = new byte[0x10];
Array.Copy(this.proxyPrepareInfoByteArray, destinationArray, 0x10);
this.transactionGuid = new Guid(destinationArray);
base.transactionGuidString = this.transactionGuid.ToString();
switch (xactStatus)
{
case OletxTransactionStatus.OLETX_TRANSACTION_STATUS_PREPARED:
this.state = OletxEnlistmentState.Prepared;
lock (oletxResourceManager.reenlistList)
{
oletxResourceManager.reenlistList.Add(this);
oletxResourceManager.StartReenlistThread();
goto Label_01CD;
}
break;
case OletxTransactionStatus.OLETX_TRANSACTION_STATUS_ABORTED:
this.state = OletxEnlistmentState.Aborting;
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.Rollback);
}
this.iEnlistmentNotification.Rollback(this);
goto Label_01CD;
case OletxTransactionStatus.OLETX_TRANSACTION_STATUS_COMMITTED:
this.state = OletxEnlistmentState.Committing;
lock (oletxResourceManager.reenlistList)
{
oletxResourceManager.reenlistPendingList.Add(this);
}
if (DiagnosticTrace.Verbose)
{
EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.Commit);
}
this.iEnlistmentNotification.Commit(this);
goto Label_01CD;
}
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("OletxEnlistmentUnexpectedTransactionStatus"));
}
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("OletxEnlistmentUnexpectedTransactionStatus"), null);
Label_01CD:
if (DiagnosticTrace.Information)
{
EnlistmentTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, EnlistmentType.Durable, EnlistmentOptions.None);
}
base.AddToEnlistmentTable();
}
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);
}
