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.EnterState(tx); if (tx.phase1Volatiles.VolatileDemux != null) { tx.phase1Volatiles.VolatileDemux.BroadcastCommitted(ref tx.phase1Volatiles); } if (tx.phase0Volatiles.VolatileDemux != null) { tx.phase0Volatiles.VolatileDemux.BroadcastCommitted(ref tx.phase0Volatiles); } tx.FireCompletion(); if (DiagnosticTrace.Verbose) { TransactionCommittedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId); } }
internal override void EnterState(InternalTransaction tx) { base.EnterState(tx); if (tx.phase1Volatiles.VolatileDemux != null) { tx.phase1Volatiles.VolatileDemux.BroadcastInDoubt(ref tx.phase1Volatiles); } if (tx.phase0Volatiles.VolatileDemux != null) { tx.phase0Volatiles.VolatileDemux.BroadcastInDoubt(ref tx.phase0Volatiles); } tx.FireCompletion(); if (DiagnosticTrace.Warning) { TransactionInDoubtTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId); } }
internal override void EnterState(InternalTransaction tx) { base.EnterState(tx); // Notify the phase 0 enlistments that the transaction is indoubt for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++) { tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase0Volatiles._volatileEnlistments[i]); } // Notify the phase 1 enlistments that the transaction is indoubt for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++) { tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase1Volatiles._volatileEnlistments[i]); } // Fire Completion for anyone listening tx.FireCompletion(); // We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback. TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log; if (etwLog.IsEnabled()) { etwLog.TransactionInDoubt(tx.TransactionTraceId); } }
internal override void EnterState(InternalTransaction tx) { base.EnterState(tx); // Tell all the enlistments the outcome. if (tx._phase1Volatiles.VolatileDemux != null) { tx._phase1Volatiles.VolatileDemux.BroadcastInDoubt(ref tx._phase1Volatiles); } if (tx._phase0Volatiles.VolatileDemux != null) { tx._phase0Volatiles.VolatileDemux.BroadcastInDoubt(ref tx._phase0Volatiles); } // Fire Completion for anyone listening tx.FireCompletion(); // We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback. TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log; if (etwLog.IsEnabled()) { etwLog.TransactionInDoubt(tx.TransactionTraceId); } }
internal override void EnterState(InternalTransaction tx) { base.EnterState(tx); // Set the transaction state CommonEnterState(tx); // Notify the phase 0 enlistments that the transaction has aborted for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++) { tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase0Volatiles._volatileEnlistments[i]); } // Notify the phase 1 enlistments that the transaction has aborted for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++) { tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase1Volatiles._volatileEnlistments[i]); } // Remove this from the timeout list TransactionManager.TransactionTable.Remove(tx); TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log; if (etwLog.IsEnabled()) { etwLog.TransactionInDoubt(tx.TransactionTraceId); } // Fire Completion for anyone listening tx.FireCompletion(); // Check to see if we need to release some waiter. if (tx._asyncCommit) { tx.SignalAsyncCompletion(); } }
internal override void EnterState( InternalTransaction tx ) { base.EnterState( tx ); // Tell all the enlistments the outcome. if ( tx.phase1Volatiles.VolatileDemux != null ) { tx.phase1Volatiles.VolatileDemux.BroadcastInDoubt( ref tx.phase1Volatiles ); } if ( tx.phase0Volatiles.VolatileDemux != null ) { tx.phase0Volatiles.VolatileDemux.BroadcastInDoubt( ref tx.phase0Volatiles ); } // Fire Completion for anyone listening tx.FireCompletion( ); // We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback. if ( DiagnosticTrace.Warning ) { TransactionInDoubtTraceRecord.Trace( SR.GetString( SR.TraceSourceLtm ), tx.TransactionTraceId ); } }
internal override void EnterState( InternalTransaction tx ) { base.EnterState( tx ); // Set the transaction state CommonEnterState( tx ); // Notify the phase 0 enlistments that the transaction has aborted for ( int i = 0; i < tx.phase0Volatiles.volatileEnlistmentCount; i++ ) { tx.phase0Volatiles.volatileEnlistments[i].twoPhaseState.InternalIndoubt(tx.phase0Volatiles.volatileEnlistments[i]); } // Notify the phase 1 enlistments that the transaction has aborted for ( int i = 0; i < tx.phase1Volatiles.volatileEnlistmentCount; i++ ) { tx.phase1Volatiles.volatileEnlistments[i].twoPhaseState.InternalIndoubt(tx.phase1Volatiles.volatileEnlistments[i]); } // Remove this from the timeout list TransactionManager.TransactionTable.Remove( tx ); if ( DiagnosticTrace.Warning ) { TransactionInDoubtTraceRecord.Trace( SR.GetString( SR.TraceSourceLtm ), tx.TransactionTraceId ); } // Fire Completion for anyone listening tx.FireCompletion( ); // Check to see if we need to release some waiter. if ( tx.asyncCommit ) { tx.SignalAsyncCompletion(); } }
internal override void EnterState(InternalTransaction tx) { base.EnterState(tx); // Notify the phase 0 enlistments that the transaction is indoubt for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++) { tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase0Volatiles._volatileEnlistments[i]); } // Notify the phase 1 enlistments that the transaction is indoubt for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++) { tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase1Volatiles._volatileEnlistments[i]); } // Fire Completion for anyone listening tx.FireCompletion(); // We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback. if (DiagnosticTrace.Warning) { TransactionInDoubtTraceRecord.Trace(SR.TraceSourceLtm, tx.TransactionTraceId ); } }
internal override void EnterState(InternalTransaction tx) { base.EnterState(tx); // Set the transaction state CommonEnterState(tx); // Do NOT mark the committable transaction as complete because it is aborting. // Notify the enlistments that the transaction has aborted for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++) { tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalAborted(tx._phase0Volatiles._volatileEnlistments[i]); } for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++) { tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalAborted(tx._phase1Volatiles._volatileEnlistments[i]); } // Notify the durable enlistment if (tx._durableEnlistment != null) { tx._durableEnlistment.State.InternalAborted(tx._durableEnlistment); } // Remove this from the timeout list TransactionManager.TransactionTable.Remove(tx); if (DiagnosticTrace.Warning) { TransactionAbortedTraceRecord.Trace(SR.TraceSourceLtm, tx.TransactionTraceId ); } // Fire Completion for anyone listening tx.FireCompletion(); // Check to see if we need to release some waiter. if (tx._asyncCommit) { tx.SignalAsyncCompletion(); } }