public FileTransaction(string name) { _Name = name; InnerBegin(); _State = TransactionState.Active; }
public FileTransaction(string name) { Contract.Requires(!string.IsNullOrEmpty(name)); _Name = name; InnerBegin(); _State = TransactionState.Active; }
public Transaction(DependentTransaction dependent, uint stackDepth, ITransactionOptions creationOptions, Action onDispose) { Contract.Requires(creationOptions != null); Contract.Requires(dependent != null); Contract.Ensures(_State == TransactionState.Active); Contract.Ensures(((ITransaction)this).State == TransactionState.Active); _Dependent = dependent; _CreationOptions = creationOptions; _OnDispose = onDispose; _State = TransactionState.Active; _LocalIdentifier = dependent.TransactionInformation.LocalIdentifier + ":" + stackDepth; }
internal InternalTransaction(Transaction outcomeSource, ITransactionPromoter promoter) { if (!TransactionManager._platformValidated) { TransactionManager.ValidatePlatform(); } this.absoluteTimeout = 0x7fffffffffffffffL; this.outcomeSource = outcomeSource; this.transactionHash = TransactionManager.TransactionTable.Add(this); this.promoter = promoter; TransactionState._TransactionStateSubordinateActive.EnterState(this); this.promoteState = TransactionState._TransactionStateDelegatedSubordinate; }
internal InternalTransaction(Transaction outcomeSource, OletxTransaction distributedTx) { if (!TransactionManager._platformValidated) { TransactionManager.ValidatePlatform(); } this.promotedTransaction = distributedTx; this.absoluteTimeout = 0x7fffffffffffffffL; this.outcomeSource = outcomeSource; this.transactionHash = TransactionManager.TransactionTable.Add(this); TransactionState._TransactionStateNonCommittablePromoted.EnterState(this); this.promoteState = TransactionState._TransactionStateNonCommittablePromoted; }
internal InternalTransaction(TimeSpan timeout, CommittableTransaction committableTransaction) { if (!TransactionManager._platformValidated) { TransactionManager.ValidatePlatform(); } this.absoluteTimeout = TransactionManager.TransactionTable.TimeoutTicks(timeout); TransactionState._TransactionStateActive.EnterState(this); this.promoteState = TransactionState._TransactionStatePromoted; this.committableTransaction = committableTransaction; this.outcomeSource = committableTransaction; this.transactionHash = TransactionManager.TransactionTable.Add(this); }
public Transaction(CommittableTransaction inner, uint stackDepth, ITransactionOptions creationOptions, Action onDispose) { Contract.Requires(creationOptions != null); Contract.Requires(inner != null); Contract.Ensures(_Inner != null); Contract.Ensures(_State == TransactionState.Active); Contract.Ensures(((ITransaction) this).State == TransactionState.Active); _Inner = inner; _StackDepth = stackDepth; _CreationOptions = creationOptions; _OnDispose = onDispose; _State = TransactionState.Active; }
public Transaction(CommittableTransaction committable, uint stackDepth, ITransactionOptions creationOptions, Action onDispose) { Contract.Requires(creationOptions != null); Contract.Requires(committable != null); Contract.Ensures(_State == TransactionState.Active); Contract.Ensures(((ITransaction)this).State == TransactionState.Active); _Committable = committable; _CreationOptions = creationOptions; _OnDispose = onDispose; _State = TransactionState.Active; _LocalIdentifier = committable.TransactionInformation.LocalIdentifier + ":" + stackDepth; }
// Construct an internal transaction internal InternalTransaction(Transaction outcomeSource, Oletx.OletxTransaction distributedTx) { if (!TransactionManager._platformValidated) { TransactionManager.ValidatePlatform(); } this.promotedTransaction = distributedTx; this.absoluteTimeout = long.MaxValue; // Store the initial creater as it will be the source of outcome events this.outcomeSource = outcomeSource; // Initialize the hash this.transactionHash = TransactionManager.TransactionTable.Add(this); // Start the transaction off as active TransactionState._TransactionStateNonCommittablePromoted.EnterState(this); // Until otherwise noted this transaction uses normal promotion. this.promoteState = TransactionState._TransactionStateNonCommittablePromoted; }
// Construct an internal transaction internal InternalTransaction(TimeSpan timeout, CommittableTransaction committableTransaction) { if (!TransactionManager._platformValidated) { TransactionManager.ValidatePlatform(); } // Calculate the absolute timeout for this transaction this.absoluteTimeout = TransactionManager.TransactionTable.TimeoutTicks(timeout); // Start the transaction off as active TransactionState._TransactionStateActive.EnterState(this); // Until otherwise noted this transaction uses normal promotion. this.promoteState = TransactionState._TransactionStatePromoted; // Keep a reference to the commitable transaction this.committableTransaction = committableTransaction; this.outcomeSource = committableTransaction; // Initialize the hash this.transactionHash = TransactionManager.TransactionTable.Add(this); }
// Construct an internal transaction internal InternalTransaction(Transaction outcomeSource, ITransactionPromoter promoter) { if (!TransactionManager._platformValidated) { TransactionManager.ValidatePlatform(); } this.absoluteTimeout = long.MaxValue; // Store the initial creater as it will be the source of outcome events this.outcomeSource = outcomeSource; // Initialize the hash this.transactionHash = TransactionManager.TransactionTable.Add(this); // Save the transaction promoter. this.promoter = promoter; // This transaction starts in a special state. TransactionState._TransactionStateSubordinateActive.EnterState(this); // This transaction promotes through delegation this.promoteState = TransactionState._TransactionStateDelegatedSubordinate; }
/** * Possible state changes * * Default -> Constructed * Constructed -> Disposed * Constructed -> Active * Active -> CommittedOrCompleted (depends on whether we are committable or not) * Active -> InDoubt * Active -> Aborted * Aborted -> Disposed # an active transaction may be disposed and then dispose must take take of aborting */ void ITransaction.Dispose() { try { try { if (_State == TransactionState.Active) InnerRollback(); } finally { if (_OnDispose != null) _OnDispose(); ((IDisposable) this).Dispose(); } } finally { _State = TransactionState.Disposed; } }
private void InnerBegin() { Contract.Ensures(_State == TransactionState.Active); // we have a ongoing current transaction, join it! if (System.Transactions.Transaction.Current != null) { var ktx = (IKernelTransaction) TransactionInterop.GetDtcTransaction(System.Transactions.Transaction.Current); SafeKernelTransactionHandle handle; ktx.GetHandle(out handle); // even though _TransactionHandle can already contain a handle if this thread // had been yielded just before setting this reference, the "safe"-ness of the wrapper should // not dispose the other handle which is now removed _TransactionHandle = handle; //IsAmbient = true; // TODO: Perhaps we created this item and we need to notify the transaction manager... } else _TransactionHandle = NativeMethods.createTransaction(string.Format("{0} Transaction", _Name)); if (!_TransactionHandle.IsInvalid) { _State = TransactionState.Active; return; } throw new TransactionException( "Cannot begin file transaction. CreateTransaction failed and there's no ambient transaction.", LastEx()); }
private void AssertState(TransactionState status, string msg) { if (status != _State) { if (!string.IsNullOrEmpty(msg)) throw new TransactionException(msg); throw new TransactionException(string.Format("State failure; should have been {0} but was {1}", status, _State)); } }
private void TransactionEnded(long transactionId, TransactionState transactionState) { // When we get notification of a completed transaction // we null out the current transaction. if (null != _currentTransaction) { #if DEBUG // Check null for case where Begin and Rollback obtained in the same message. if (0 != _currentTransaction.TransactionId) { Debug.Assert(_currentTransaction.TransactionId == transactionId, "transaction id's are not equal!"); } #endif _currentTransaction.Completed(transactionState); _currentTransaction = null; } }
private void Dispose(bool isManaged) { if (!isManaged) return; _Logger.Debug("disposing"); if (_DependentTasks != null) _DependentTasks.Clear(); try { if (_OnDispose != null) _OnDispose(); Inner.Dispose(); } finally { _State = TransactionState.Disposed; } }
private void InnerRollback() { Contract.Ensures(_State == TransactionState.Aborted); try { _Logger.Info(() => string.Format("rolling back tx#{0}", _LocalIdentifier)); Inner.Rollback(); } finally { _State = TransactionState.Aborted; } }
private void Dispose(bool isManaged) { if (!isManaged) return; try { Inner.Dispose(); } finally { _State = TransactionState.Disposed; } }
// Construct an internal transaction internal InternalTransaction(Transaction outcomeSource, DistributedTransaction distributedTx) { _promotedTransaction = distributedTx; _absoluteTimeout = long.MaxValue; // Store the initial creater as it will be the source of outcome events _outcomeSource = outcomeSource; // Initialize the hash _transactionHash = TransactionManager.TransactionTable.Add(this); // Start the transaction off as active TransactionState.TransactionStateNonCommittablePromoted.EnterState(this); // Until otherwise noted this transaction uses normal promotion. _promoteState = TransactionState.TransactionStateNonCommittablePromoted; }
private void Dispose(bool disposing) { // no unmanaged code here, just return. if (!disposing) return; if (_State == TransactionState.Disposed) return; // called via the Dispose() method on IDisposable, // can use private object references. try { if (_State == TransactionState.Active) ((ITransaction) this).Rollback(); if (_TransactionHandle != null) _TransactionHandle.Dispose(); if (_Inner != null) _Inner.Dispose(); } finally { _State = TransactionState.Disposed; } }
// Construct an internal transaction internal InternalTransaction( TimeSpan timeout, CommittableTransaction committableTransaction ) { if ( !TransactionManager._platformValidated ) TransactionManager.ValidatePlatform(); // Calculate the absolute timeout for this transaction this.absoluteTimeout = TransactionManager.TransactionTable.TimeoutTicks( timeout ); // Start the transaction off as active TransactionState._TransactionStateActive.EnterState( this ); // Until otherwise noted this transaction uses normal promotion. this.promoteState = TransactionState._TransactionStatePromoted; // Keep a reference to the commitable transaction this.committableTransaction = committableTransaction; this.outcomeSource = committableTransaction; // Initialize the hash this.transactionHash = TransactionManager.TransactionTable.Add( this ); }
// Construct an internal transaction internal InternalTransaction( Transaction outcomeSource, Oletx.OletxTransaction distributedTx ) { if ( !TransactionManager._platformValidated ) TransactionManager.ValidatePlatform(); this.promotedTransaction = distributedTx; this.absoluteTimeout = long.MaxValue; // Store the initial creater as it will be the source of outcome events this.outcomeSource = outcomeSource; // Initialize the hash this.transactionHash = TransactionManager.TransactionTable.Add( this ); // Start the transaction off as active TransactionState._TransactionStateNonCommittablePromoted.EnterState( this ); // Until otherwise noted this transaction uses normal promotion. this.promoteState = TransactionState._TransactionStateNonCommittablePromoted; }
// Construct an internal transaction internal InternalTransaction( Transaction outcomeSource, ITransactionPromoter promoter ) { if ( !TransactionManager._platformValidated ) TransactionManager.ValidatePlatform(); this.absoluteTimeout = long.MaxValue; // Store the initial creater as it will be the source of outcome events this.outcomeSource = outcomeSource; // Initialize the hash this.transactionHash = TransactionManager.TransactionTable.Add( this ); // Save the transaction promoter. this.promoter = promoter; // This transaction starts in a special state. TransactionState._TransactionStateSubordinateActive.EnterState( this ); // This transaction promotes through delegation this.promoteState = TransactionState._TransactionStateDelegatedSubordinate; }
private void InnerRollback() { Contract.Ensures(_State == TransactionState.Aborted); try { Inner.Rollback(); } finally { _State = TransactionState.Aborted; } }
void ITransaction.Complete() { try { if (_Inner != null) _Inner.Commit(); if (_Inner2 != null) _Inner2.Complete(); _State = TransactionState.CommittedOrCompleted; } catch (TransactionInDoubtException e) { _State = TransactionState.InDoubt; throw new TransactionException("Transaction in doubt. See inner exception and help link for details", e, new Uri("http://support.microsoft.com/kb/899115/EN-US/")); } catch (TransactionAbortedException) { _State = TransactionState.Aborted; throw; } catch (Exception e) { InnerRollback(); // we might have lost connection to the database // or any other myriad of problems might have occurred throw new TransactionException("unknown transaction problem, see inner exception", e, new Uri("http://stackoverflow.com/questions/224689/transactions-in-net")); } }
void ITransaction.Rollback() { try { if (!NativeMethods.RollbackTransaction(_TransactionHandle)) throw new TransactionException("Rollback failed.", LastEx()); if (_Inner != null) _Inner.Rollback(); } finally { _State = TransactionState.Aborted; } }
private void InnerRollback() { Contract.Ensures(_State == TransactionState.Aborted); try { if (_Logger.IsInfoEnabled) _Logger.InfoFormat("rolling back tx#{0}", _LocalIdentifier); Inner.Rollback(); } finally { _State = TransactionState.Aborted; } }
void ITransaction.Complete() { try { if (_Inner != null && _Inner.State == TransactionState.Active) _Inner.Complete(); if (!NativeMethods.CommitTransaction(_TransactionHandle)) throw new TransactionException("Commit failed.", LastEx()); _State = TransactionState.CommittedOrCompleted; } finally { _State = _State != TransactionState.CommittedOrCompleted ? TransactionState.Aborted : TransactionState.CommittedOrCompleted; } }
void ITransaction.Complete() { try { if (_Committable != null) { _Logger.Debug(() => string.Format("committing committable tx#{0}", _LocalIdentifier)); if (beforeTopComplete != null) beforeTopComplete(); if (_DependentTasks != null && _CreationOptions.DependentOption == DependentCloneOption.BlockCommitUntilComplete) Task.WaitAll(_DependentTasks.ToArray()); // this might throw, and then we don't set the state to completed else if (_DependentTasks != null && _CreationOptions.DependentOption == DependentCloneOption.RollbackIfNotComplete) _DependentTasks.Do(x => x.IgnoreExceptions()).Run(); _Committable.Commit(); } else { _Logger.Debug(string.Format("completing dependent tx#{0}", _LocalIdentifier)); _Dependent.Complete(); } _State = TransactionState.CommittedOrCompleted; } catch (TransactionInDoubtException e) { _State = TransactionState.InDoubt; throw new TransactionException("Transaction in doubt. See inner exception and help link for details", e, new Uri("http://support.microsoft.com/kb/899115/EN-US/")); } catch (TimeoutException e) { _State = TransactionState.Aborted; _Logger.Warn("transaction timed out", e); } catch (TransactionAbortedException e) { _State = TransactionState.Aborted; _Logger.Warn("transaction aborted", e); throw; } catch (AggregateException e) { _State = TransactionState.Aborted; _Logger.Warn("dependent transactions failed, so we are not performing the rollback (as they will have notified their parent!)", e); throw; } catch (Exception e) { InnerRollback(); // we might have lost connection to the database // or any other myriad of problems might have occurred throw new TransactionException("Unknown Transaction Problem. Read the Inner Exception", e, new Uri("http://stackoverflow.com/questions/224689/transactions-in-net")); } }
private void AssertState(TransactionState state) { AssertState(state, null); }
/** * Possible state changes * * Default -> Constructed * Constructed -> Disposed * Constructed -> Active * Active -> CommittedOrCompleted (depends on whether we are committable or not) * Active -> InDoubt * Active -> Aborted * Aborted -> Disposed # an active transaction may be disposed and then dispose must take take of aborting */ void ITransaction.Dispose() { try { try { if (_State == TransactionState.Active) InnerRollback(); } finally { // the question is; does committable transaction object to being disposed on exceptions? ((IDisposable) this).Dispose(); } } finally { _State = TransactionState.Disposed; } }
private void TransactionEndedByServer(long transactionId, TransactionState transactionState) { // Some extra steps required when the server initiates the ending of a transaction unilaterally // as opposed to the client initiating it. // Basically, we have to make the delegated transaction (if there is one) aware of the situation. SqlDelegatedTransaction delegatedTransaction = DelegatedTransaction; if (null != delegatedTransaction) { delegatedTransaction.Transaction.Rollback(); // just to make sure... DelegatedTransaction = null; // He's dead, Jim. } // Now handle the standard transaction-ended stuff. TransactionEnded(transactionId, transactionState); }