internal override void CompleteAbortingClone(InternalTransaction tx) { if (tx.phase1Volatiles.VolatileDemux != null) { tx.phase1Volatiles.dependentClones--; } else { tx.abortingDependentCloneCount--; if (tx.abortingDependentCloneCount == 0) { OletxDependentTransaction abortingDependentClone = tx.abortingDependentClone; tx.abortingDependentClone = null; Monitor.Exit(tx); try { try { abortingDependentClone.Complete(); } finally { abortingDependentClone.Dispose(); } } finally { Monitor.Enter(tx); } } } }
internal override void EnterState(InternalTransaction tx) { if (tx.needPulse) { Monitor.Pulse(tx); } }
internal bool Add(InternalTransaction tx) { int currentIndex = Interlocked.Increment(ref _index); if (currentIndex < _size) { tx._tableBucket = this; tx._bucketIndex = currentIndex; Interlocked.MemoryBarrier(); // This data must be written before the transaction // could be timed out. _transactions[currentIndex] = tx; if (_timedOut) { lock (tx) { tx.State.Timeout(tx); } } } else { Bucket newBucket = new Bucket(_owningSet); newBucket.nextBucketWeak = new WeakReference(this); Bucket oldBucket = Interlocked.CompareExchange(ref _owningSet.headBucket, newBucket, this); if (oldBucket == this) { // ladies and gentlemen we have a winner. _previous = newBucket; } return false; } return true; }
internal OletxTransaction PSPEPromote(InternalTransaction tx) { TransactionState state = tx.State; base.CommonEnterState(tx); OletxTransaction oletxTransactionFromTransmitterPropigationToken = null; try { byte[] propagationToken = tx.promoter.Promote(); if (propagationToken == null) { throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("PromotedReturnedInvalidValue"), null); } try { oletxTransactionFromTransmitterPropigationToken = TransactionInterop.GetOletxTransactionFromTransmitterPropigationToken(propagationToken); } catch (ArgumentException exception) { throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("PromotedReturnedInvalidValue"), exception); } if (TransactionManager.FindPromotedTransaction(oletxTransactionFromTransmitterPropigationToken.Identifier) != null) { oletxTransactionFromTransmitterPropigationToken.Dispose(); throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("PromotedTransactionExists"), null); } } finally { state.CommonEnterState(tx); } return oletxTransactionFromTransmitterPropigationToken; }
internal bool Add(InternalTransaction tx) { int index = Interlocked.Increment(ref this.index); if (index < this.size) { tx.tableBucket = this; tx.bucketIndex = index; Thread.MemoryBarrier(); this.transactions[index] = tx; if (!this.timedOut) { goto Label_0097; } lock (tx) { tx.State.Timeout(tx); goto Label_0097; } } Bucket bucket = new Bucket(this.owningSet) { nextBucketWeak = new WeakReference(this) }; if (Interlocked.CompareExchange<Bucket>(ref this.owningSet.headBucket, bucket, this) == this) { this.previous = bucket; } return false; Label_0097: return true; }
internal override void BeginCommit(InternalTransaction tx, bool asyncCommit, AsyncCallback asyncCallback, object asyncState) { tx.asyncCommit = asyncCommit; tx.asyncCallback = asyncCallback; tx.asyncState = asyncState; TransactionState._TransactionStateDelegatedCommitting.EnterState(tx); }
internal int Add(InternalTransaction txNew) { Thread.BeginCriticalRegion(); int num = 0; try { num = this.rwLock.AcquireReaderLock(); try { if ((txNew.AbsoluteTimeout != 0x7fffffffffffffffL) && !this.timerEnabled) { if (!this.timer.Change(this.timerInterval, this.timerInterval)) { throw TransactionException.CreateInvalidOperationException(System.Transactions.SR.GetString("TraceSourceLtm"), System.Transactions.SR.GetString("UnexpectedTimerFailure"), null); } this.lastTimerTime = DateTime.UtcNow.Ticks; this.timerEnabled = true; } txNew.CreationTime = this.CurrentTime; this.AddIter(txNew); } finally { this.rwLock.ReleaseReaderLock(); } } finally { Thread.EndCriticalRegion(); } return num; }
internal override void EnterState(InternalTransaction tx) { base.CommonEnterState(tx); tx.committableTransaction.complete = true; if (tx.phase1Volatiles.dependentClones != 0) { TransactionState._TransactionStateAborted.EnterState(tx); } else if (((tx.phase1Volatiles.volatileEnlistmentCount == 1) && (tx.durableEnlistment == null)) && (tx.phase1Volatiles.volatileEnlistments[0].SinglePhaseNotification != null)) { TransactionState._TransactionStateVolatileSPC.EnterState(tx); } else if (tx.phase1Volatiles.volatileEnlistmentCount > 0) { for (int i = 0; i < tx.phase1Volatiles.volatileEnlistmentCount; i++) { tx.phase1Volatiles.volatileEnlistments[i].twoPhaseState.ChangeStatePreparing(tx.phase1Volatiles.volatileEnlistments[i]); if (!tx.State.ContinuePhase1Prepares()) { return; } } } else { TransactionState._TransactionStateSPC.EnterState(tx); } }
internal InternalEnlistment(System.Transactions.Enlistment enlistment, IEnlistmentNotification twoPhaseNotifications, InternalTransaction transaction, System.Transactions.Transaction atomicTransaction) { this.enlistment = enlistment; this.twoPhaseNotifications = twoPhaseNotifications; this.transaction = transaction; this.atomicTransaction = atomicTransaction; }
internal override void EnterState(InternalTransaction tx) { base.EnterState(tx); base.CommonEnterState(tx); for (int i = 0; i < tx.phase0Volatiles.volatileEnlistmentCount; i++) { tx.phase0Volatiles.volatileEnlistments[i].twoPhaseState.InternalAborted(tx.phase0Volatiles.volatileEnlistments[i]); } for (int j = 0; j < tx.phase1Volatiles.volatileEnlistmentCount; j++) { tx.phase1Volatiles.volatileEnlistments[j].twoPhaseState.InternalAborted(tx.phase1Volatiles.volatileEnlistments[j]); } if (tx.durableEnlistment != null) { tx.durableEnlistment.State.InternalAborted(tx.durableEnlistment); } TransactionManager.TransactionTable.Remove(tx); if (DiagnosticTrace.Warning) { TransactionAbortedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId); } tx.FireCompletion(); if (tx.asyncCommit) { tx.SignalAsyncCompletion(); } }
internal override void EnterState(InternalTransaction tx) { base.CommonEnterState(tx); if (tx.committableTransaction != null) { tx.committableTransaction.complete = true; } if (tx.phase1Volatiles.dependentClones != 0) { tx.State.ChangeStateTransactionAborted(tx, null); } else { int volatileEnlistmentCount = tx.phase1Volatiles.volatileEnlistmentCount; if (tx.phase1Volatiles.preparedVolatileEnlistments < volatileEnlistmentCount) { for (int i = 0; i < volatileEnlistmentCount; i++) { tx.phase1Volatiles.volatileEnlistments[i].twoPhaseState.ChangeStatePreparing(tx.phase1Volatiles.volatileEnlistments[i]); if (!tx.State.ContinuePhase1Prepares()) { return; } } } else { this.Phase1VolatilePrepareDone(tx); } } }
protected override void PromotedTransactionOutcome(InternalTransaction tx) { if ((tx.innerException == null) && (tx.PromotedTransaction != null)) { tx.innerException = tx.PromotedTransaction.InnerException; } throw TransactionInDoubtException.Create(System.Transactions.SR.GetString("TraceSourceBase"), tx.innerException); }
internal virtual void ChangeStatePromotedAborted(InternalTransaction tx) { if (DiagnosticTrace.Error) { InvalidOperationExceptionTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), ""); } throw new InvalidOperationException(); }
internal override void CompleteBlockingClone(InternalTransaction tx) { tx.phase0Volatiles.dependentClones--; if (tx.phase0Volatiles.preparedVolatileEnlistments == (tx.phase0VolatileWaveCount + tx.phase0Volatiles.dependentClones)) { tx.State.Phase0VolatilePrepareDone(tx); } }
internal override void Rollback(InternalTransaction tx, Exception e) { if (tx.innerException == null) { tx.innerException = e; } TransactionState._TransactionStateDelegatedAborting.EnterState(tx); }
protected InternalEnlistment(System.Transactions.Enlistment enlistment, InternalTransaction transaction, System.Transactions.Transaction atomicTransaction) { this.enlistment = enlistment; this.transaction = transaction; this.atomicTransaction = atomicTransaction; this.enlistmentId = transaction.enlistmentCount++; this.traceIdentifier = EnlistmentTraceIdentifier.Empty; }
internal override void ChangeStateTransactionAborted(InternalTransaction tx, Exception e) { if (tx.innerException == null) { tx.innerException = e; } TransactionState._TransactionStatePromotedP1Aborting.EnterState(tx); }
internal override void Rollback(InternalTransaction tx, Exception e) { if (tx.innerException == null) { tx.innerException = e; } ((ISimpleTransactionSuperior) tx.promoter).Rollback(); TransactionState._TransactionStateAborted.EnterState(tx); }
internal override void CompleteAbortingClone(InternalTransaction tx) { // A blocking clone simulates a phase 1 volatile // // Unlike a blocking clone however the aborting clones need to be accounted // for specifically. So when one is complete remove it from the list. tx._phase1Volatiles._dependentClones--; Debug.Assert(tx._phase1Volatiles._dependentClones >= 0); }
internal override void Rollback(InternalTransaction tx, Exception e) { if (tx.innerException == null) { tx.innerException = e; } tx.PromotedTransaction.Rollback(); TransactionState._TransactionStatePromotedAborted.EnterState(tx); }
internal override void Timeout(InternalTransaction tx) { if (DiagnosticTrace.Warning) { TransactionTimeoutTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId); } TimeoutException e = new TimeoutException(System.Transactions.SR.GetString("TraceTransactionTimeout")); this.Rollback(tx, e); }
internal PromotableInternalEnlistment( Enlistment enlistment, InternalTransaction transaction, IPromotableSinglePhaseNotification promotableSinglePhaseNotification, Transaction atomicTransaction ) : base(enlistment, transaction, atomicTransaction) { this.promotableNotificationInterface = promotableSinglePhaseNotification; }
public Phase1VolatileEnlistment( Enlistment enlistment, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, Transaction atomicTransaction ) : base(enlistment, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction) { }
internal virtual bool PromoteDurable(InternalTransaction tx) { if (tx.durableEnlistment != null) { InternalEnlistment durableEnlistment = tx.durableEnlistment; IPromotedEnlistment promotedEnlistment = tx.PromotedTransaction.EnlistDurable(durableEnlistment.ResourceManagerIdentifier, (DurableInternalEnlistment)durableEnlistment, durableEnlistment.SinglePhaseNotification != null, EnlistmentOptions.None); tx.durableEnlistment.State.ChangeStatePromoted(tx.durableEnlistment, promotedEnlistment); } return(true); }
private static void SignalCallback(object state) { InternalTransaction tx = (InternalTransaction)state; lock (tx) { tx.SignalAsyncCompletion(); TransactionManager.TransactionTable.Remove(tx); } }
internal InternalEnlistment(System.Transactions.Enlistment enlistment, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, System.Transactions.Transaction atomicTransaction) { this.enlistment = enlistment; this.transaction = transaction; this.twoPhaseNotifications = twoPhaseNotifications; this.singlePhaseNotifications = singlePhaseNotifications; this.atomicTransaction = atomicTransaction; this.enlistmentId = transaction.enlistmentCount++; this.traceIdentifier = EnlistmentTraceIdentifier.Empty; }
internal override void Timeout(InternalTransaction tx) { if (DiagnosticTrace.Warning) { TransactionTimeoutTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId); } TimeoutException e = new TimeoutException(System.Transactions.SR.GetString("TraceTransactionTimeout")); this.Rollback(tx, e); }
internal InternalEnlistment(System.Transactions.Enlistment enlistment, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, System.Transactions.Transaction atomicTransaction) { this.enlistment = enlistment; this.transaction = transaction; this.twoPhaseNotifications = twoPhaseNotifications; this.singlePhaseNotifications = singlePhaseNotifications; this.atomicTransaction = atomicTransaction; this.enlistmentId = transaction.enlistmentCount++; this.traceIdentifier = EnlistmentTraceIdentifier.Empty; }
internal override void AddOutcomeRegistrant(InternalTransaction tx, TransactionCompletedEventHandler transactionCompletedDelegate) { if (transactionCompletedDelegate != null) { TransactionEventArgs e = new TransactionEventArgs { transaction = tx.outcomeSource.InternalClone() }; transactionCompletedDelegate(e.transaction, e); } }
internal override void AddOutcomeRegistrant(InternalTransaction tx, TransactionCompletedEventHandler transactionCompletedDelegate) { if (transactionCompletedDelegate != null) { TransactionEventArgs e = new TransactionEventArgs { transaction = tx.outcomeSource.InternalClone() }; transactionCompletedDelegate(e.transaction, e); } }
private void AddIter(InternalTransaction txNew) { BucketSet headBucketSet = this.headBucketSet; while (headBucketSet.AbsoluteTimeout != txNew.AbsoluteTimeout) { BucketSet set3 = null; do { WeakReference nextSetWeak = (WeakReference) headBucketSet.nextSetWeak; BucketSet target = null; if (nextSetWeak != null) { target = (BucketSet) nextSetWeak.Target; } if (target == null) { BucketSet set6 = new BucketSet(this, txNew.AbsoluteTimeout); WeakReference reference5 = new WeakReference(set6); WeakReference reference4 = (WeakReference) Interlocked.CompareExchange(ref headBucketSet.nextSetWeak, reference5, nextSetWeak); if (reference4 == nextSetWeak) { set6.prevSet = headBucketSet; } } else { set3 = headBucketSet; headBucketSet = target; } } while (headBucketSet.AbsoluteTimeout > txNew.AbsoluteTimeout); if (headBucketSet.AbsoluteTimeout != txNew.AbsoluteTimeout) { BucketSet set2 = new BucketSet(this, txNew.AbsoluteTimeout); WeakReference reference3 = new WeakReference(set2); set2.nextSetWeak = set3.nextSetWeak; WeakReference reference2 = (WeakReference) Interlocked.CompareExchange(ref set3.nextSetWeak, reference3, set2.nextSetWeak); if (reference2 == set2.nextSetWeak) { if (reference2 != null) { BucketSet set5 = (BucketSet) reference2.Target; if (set5 != null) { set5.prevSet = set2; } } set2.prevSet = headBucketSet; } headBucketSet = set3; set3 = null; } } headBucketSet.Add(txNew); }
private void AddIter(InternalTransaction txNew) { BucketSet headBucketSet = this.headBucketSet; while (headBucketSet.AbsoluteTimeout != txNew.AbsoluteTimeout) { BucketSet set3 = null; do { WeakReference nextSetWeak = (WeakReference)headBucketSet.nextSetWeak; BucketSet target = null; if (nextSetWeak != null) { target = (BucketSet)nextSetWeak.Target; } if (target == null) { BucketSet set6 = new BucketSet(this, txNew.AbsoluteTimeout); WeakReference reference5 = new WeakReference(set6); WeakReference reference4 = (WeakReference)Interlocked.CompareExchange(ref headBucketSet.nextSetWeak, reference5, nextSetWeak); if (reference4 == nextSetWeak) { set6.prevSet = headBucketSet; } } else { set3 = headBucketSet; headBucketSet = target; } }while (headBucketSet.AbsoluteTimeout > txNew.AbsoluteTimeout); if (headBucketSet.AbsoluteTimeout != txNew.AbsoluteTimeout) { BucketSet set2 = new BucketSet(this, txNew.AbsoluteTimeout); WeakReference reference3 = new WeakReference(set2); set2.nextSetWeak = set3.nextSetWeak; WeakReference reference2 = (WeakReference)Interlocked.CompareExchange(ref set3.nextSetWeak, reference3, set2.nextSetWeak); if (reference2 == set2.nextSetWeak) { if (reference2 != null) { BucketSet set5 = (BucketSet)reference2.Target; if (set5 != null) { set5.prevSet = set2; } } set2.prevSet = headBucketSet; } headBucketSet = set3; set3 = null; } } headBucketSet.Add(txNew); }
internal InternalEnlistment( Enlistment enlistment, IEnlistmentNotification twoPhaseNotifications, InternalTransaction transaction, Transaction atomicTransaction) { _enlistment = enlistment; _twoPhaseNotifications = twoPhaseNotifications; _transaction = transaction; _atomicTransaction = atomicTransaction; }
internal Enlistment(InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, Transaction atomicTransaction, EnlistmentOptions enlistmentOptions) { if ((enlistmentOptions & EnlistmentOptions.EnlistDuringPrepareRequired) != EnlistmentOptions.None) { this.internalEnlistment = new System.Transactions.InternalEnlistment(this, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction); } else { this.internalEnlistment = new Phase1VolatileEnlistment(this, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction); } }
internal override void GetObjectData(InternalTransaction tx, SerializationInfo serializationInfo, StreamingContext context) { ISerializable promotedTransaction = tx.PromotedTransaction; if (promotedTransaction == null) { throw new NotSupportedException(); } serializationInfo.FullTypeName = tx.PromotedTransaction.GetType().FullName; promotedTransaction.GetObjectData(serializationInfo, context); }
internal Enlistment(InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, Transaction atomicTransaction, EnlistmentOptions enlistmentOptions) { if ((enlistmentOptions & EnlistmentOptions.EnlistDuringPrepareRequired) != EnlistmentOptions.None) { this.internalEnlistment = new System.Transactions.InternalEnlistment(this, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction); } else { this.internalEnlistment = new Phase1VolatileEnlistment(this, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction); } }
internal DurableInternalEnlistment( Enlistment enlistment, Guid resourceManagerIdentifier, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, Transaction atomicTransaction) : base(enlistment, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction) { _resourceManagerIdentifier = resourceManagerIdentifier; }
internal override void Phase0VolatilePrepareDone(InternalTransaction tx) { Monitor.Exit(tx); try { tx.phase0Volatiles.VolatileDemux.oletxEnlistment.Prepared(); } finally { Monitor.Enter(tx); } }
internal override void EnterState(InternalTransaction tx) { base.CommonEnterState(tx); if (tx.durableEnlistment != null) { tx.durableEnlistment.State.ChangeStateCommitting(tx.durableEnlistment); } else { TransactionState._TransactionStateCommitted.EnterState(tx); } }
internal void PSPEInitialize(InternalTransaction tx, IPromotableSinglePhaseNotification promotableSinglePhaseNotification) { base.CommonEnterState(tx); try { promotableSinglePhaseNotification.Initialize(); } finally { TransactionState._TransactionStateActive.CommonEnterState(tx); } }
internal void PSPEInitialize(InternalTransaction tx, IPromotableSinglePhaseNotification promotableSinglePhaseNotification) { base.CommonEnterState(tx); try { promotableSinglePhaseNotification.Initialize(); } finally { TransactionState._TransactionStateActive.CommonEnterState(tx); } }
internal InternalEnlistment( Enlistment enlistment, IEnlistmentNotification twoPhaseNotifications, InternalTransaction transaction, Transaction atomicTransaction ) { this.enlistment = enlistment; this.twoPhaseNotifications = twoPhaseNotifications; this.transaction = transaction; this.atomicTransaction = atomicTransaction; }
internal override void Phase1VolatilePrepareDone(InternalTransaction tx) { Monitor.Exit(tx); try { tx.phase1Volatiles.VolatileDemux.oletxEnlistment.Prepared(); } finally { Monitor.Enter(tx); } }
internal Enlistment( IEnlistmentNotification twoPhaseNotifications, InternalTransaction transaction, Transaction atomicTransaction) { _internalEnlistment = new InternalEnlistment( this, twoPhaseNotifications, transaction, atomicTransaction ); }
internal static void DistributedTransactionOutcome(InternalTransaction tx, TransactionStatus status) { FinalizedObject?fo = null; lock (tx) { if (null == tx._innerException) { Debug.Assert(tx.PromotedTransaction != null); tx._innerException = tx.PromotedTransaction.InnerException; } Debug.Assert(tx.State ! != null); switch (status) { case TransactionStatus.Committed: { tx.State.ChangeStatePromotedCommitted(tx); break; } case TransactionStatus.Aborted: { tx.State.ChangeStatePromotedAborted(tx); break; } case TransactionStatus.InDoubt: { tx.State.InDoubtFromDtc(tx); break; } default: { Debug.Fail("InternalTransaction.DistributedTransactionOutcome - Unexpected TransactionStatus"); TransactionException.CreateInvalidOperationException(TraceSourceType.TraceSourceLtm, "", null, tx.DistributedTxId ); break; } } fo = tx._finalizedObject; } if (null != fo) { fo.Dispose(); } }
// This constructor is for a promotable single phase enlistment. internal Enlistment( InternalTransaction transaction, IPromotableSinglePhaseNotification promotableSinglePhaseNotification, Transaction atomicTransaction) { _internalEnlistment = new PromotableInternalEnlistment( this, transaction, promotableSinglePhaseNotification, atomicTransaction ); }
// For Promotable Enlistments protected InternalEnlistment( Enlistment enlistment, InternalTransaction transaction, Transaction atomicTransaction ) { Debug.Assert(this is PromotableInternalEnlistment, "this is PromotableInternalEnlistment"); this.enlistment = enlistment; this.transaction = transaction; this.atomicTransaction = atomicTransaction; this.enlistmentId = transaction.enlistmentCount++; this.traceIdentifier = EnlistmentTraceIdentifier.Empty; }
internal override void EnterState(InternalTransaction tx) { base.CommonEnterState(tx); this.ChangeStatePromotedAborted(tx); Monitor.Exit(tx); try { tx.phase1Volatiles.VolatileDemux.oletxEnlistment.ForceRollback(); } finally { Monitor.Enter(tx); } }
internal CommittableTransaction(IsolationLevel isoLevel, TimeSpan timeout) : base(isoLevel, (InternalTransaction)null) { // object to use for synchronization rather than locking on a public object _internalTransaction = new InternalTransaction(timeout, this); // Because we passed null for the internal transaction to the base class, we need to // fill in the traceIdentifier field here. _internalTransaction._cloneCount = 1; _cloneId = 1; if (DiagnosticTrace.Information) { TransactionCreatedTraceRecord.Trace(SR.TraceSourceLtm, TransactionTraceId); } }
internal Transaction(System.Transactions.IsolationLevel isoLevel, InternalTransaction internalTransaction) { TransactionManager.ValidateIsolationLevel(isoLevel); this.isoLevel = isoLevel; if (System.Transactions.IsolationLevel.Unspecified == this.isoLevel) { this.isoLevel = TransactionManager.DefaultIsolationLevel; } if (internalTransaction != null) { this.internalTransaction = internalTransaction; this.cloneId = Interlocked.Increment(ref this.internalTransaction.cloneCount); } }
internal Transaction(System.Transactions.IsolationLevel isoLevel, InternalTransaction internalTransaction) { TransactionManager.ValidateIsolationLevel(isoLevel); this.isoLevel = isoLevel; if (System.Transactions.IsolationLevel.Unspecified == this.isoLevel) { this.isoLevel = TransactionManager.DefaultIsolationLevel; } if (internalTransaction != null) { this.internalTransaction = internalTransaction; this.cloneId = Interlocked.Increment(ref this.internalTransaction.cloneCount); } }
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 void DistributedTransactionOutcome(InternalTransaction tx, TransactionStatus status) { FinalizedObject fo = null; lock ( tx ) { if (null == tx.innerException) { tx.innerException = tx.PromotedTransaction.InnerException; } switch (status) { case TransactionStatus.Committed: { tx.State.ChangeStatePromotedCommitted(tx); break; } case TransactionStatus.Aborted: { tx.State.ChangeStatePromotedAborted(tx); break; } case TransactionStatus.InDoubt: { tx.State.InDoubtFromDtc(tx); break; } default: { Debug.Assert(false, "InternalTransaction.DistributedTransactionOutcome - Unexpected TransactionStatus"); TransactionException.CreateInvalidOperationException(SR.GetString(SR.TraceSourceLtm), "", null ); break; } } fo = tx.finalizedObject; } if (null != fo) { fo.Dispose(); } }
internal Transaction(System.Transactions.IsolationLevel isoLevel, ISimpleTransactionSuperior superior) { TransactionManager.ValidateIsolationLevel(isoLevel); if (superior == null) { throw new ArgumentNullException("superior"); } this.isoLevel = isoLevel; if (System.Transactions.IsolationLevel.Unspecified == this.isoLevel) { this.isoLevel = TransactionManager.DefaultIsolationLevel; } this.internalTransaction = new InternalTransaction(this, superior); this.cloneId = 1; }
internal override void CreateAbortingClone(InternalTransaction tx) { if (tx.phase1Volatiles.VolatileDemux != null) { tx.phase1Volatiles.dependentClones++; } else { if (tx.abortingDependentClone == null) { tx.abortingDependentClone = tx.PromotedTransaction.DependentClone(false); } tx.abortingDependentCloneCount++; } }
internal DependentTransaction(IsolationLevel isoLevel, InternalTransaction internalTransaction, bool blocking) : base(isoLevel, internalTransaction) { this.blocking = blocking; lock (base.internalTransaction) { if (blocking) { base.internalTransaction.State.CreateBlockingClone(base.internalTransaction); } else { base.internalTransaction.State.CreateAbortingClone(base.internalTransaction); } } }
internal InternalEnlistment( Enlistment enlistment, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, Transaction atomicTransaction) { _enlistment = enlistment; _transaction = transaction; _twoPhaseNotifications = twoPhaseNotifications; _singlePhaseNotifications = singlePhaseNotifications; _atomicTransaction = atomicTransaction; _enlistmentId = transaction._enlistmentCount++; _traceIdentifier = EnlistmentTraceIdentifier.Empty; }
internal Enlistment( Guid resourceManagerIdentifier, InternalTransaction transaction, IEnlistmentNotification twoPhaseNotifications, ISinglePhaseNotification singlePhaseNotifications, Transaction atomicTransaction) { _internalEnlistment = new DurableInternalEnlistment( this, resourceManagerIdentifier, transaction, twoPhaseNotifications, singlePhaseNotifications, atomicTransaction ); }