public void CreateSaveAndHoldValidSavepoint() { ISavepointManager saveMgr = MockRepository.GenerateMock<ISavepointManager>(); DefaultTransactionStatus status = new DefaultTransactionStatus(saveMgr, true, false, false, true, new object()); status.CreateAndHoldSavepoint("savepoint"); Assert.IsTrue(status.HasSavepoint); Assert.AreEqual("savepoint", status.Savepoint); }
public void CreateSaveAndHoldValidSavepoint() { MyMockTxnObjectSavepointMgr saveMgr = new MyMockTxnObjectSavepointMgr(); saveMgr.SetSavepointToReturn( "savepoint" ); DefaultTransactionStatus status = new DefaultTransactionStatus( saveMgr , true, false, false, true, new object()); status.CreateAndHoldSavepoint( "savepoint" ); Assert.IsTrue( status.HasSavepoint ); Assert.AreEqual( "savepoint", status.Savepoint ); }
public void RollbackHeldSavepointSuccess() { ISavepointManager saveMgr = MockRepository.GenerateMock<ISavepointManager>(); string savepoint = "savepoint"; DefaultTransactionStatus status = new DefaultTransactionStatus(saveMgr, true, false, false, true, new object()); status.CreateAndHoldSavepoint(savepoint); Assert.IsTrue(status.HasSavepoint); Assert.AreEqual(savepoint, status.Savepoint); status.RollbackToHeldSavepoint(); saveMgr.AssertWasCalled(x => x.RollbackToSavepoint(savepoint)); }
public void ReleaseHeldSavepointSuccess() { ISavepointManager saveMgr = MockRepository.GenerateMock <ISavepointManager>(); string savepoint = "savepoint"; DefaultTransactionStatus status = new DefaultTransactionStatus(saveMgr, true, false, false, true, new object()); status.CreateAndHoldSavepoint(savepoint); Assert.IsTrue(status.HasSavepoint); Assert.AreEqual(savepoint, status.Savepoint); status.ReleaseHeldSavepoint(); saveMgr.AssertWasCalled(x => x.CreateSavepoint(savepoint)); saveMgr.AssertWasCalled(x => x.ReleaseSavepoint(savepoint)); }
public void ReleaseHeldSavepointSuccess() { ISavepointManager saveMgr = A.Fake <ISavepointManager>(); string savepoint = "savepoint"; DefaultTransactionStatus status = new DefaultTransactionStatus(saveMgr, true, false, false, true, new object()); status.CreateAndHoldSavepoint(savepoint); Assert.IsTrue(status.HasSavepoint); Assert.AreEqual(savepoint, status.Savepoint); status.ReleaseHeldSavepoint(); A.CallTo(() => saveMgr.CreateSavepoint(savepoint)).MustHaveHappened(); A.CallTo(() => saveMgr.ReleaseSavepoint(savepoint)).MustHaveHappened(); }
public void RollbackHeldSavepointSuccess() { MyMockTxnObjectSavepointMgr saveMgr = new MyMockTxnObjectSavepointMgr(); string savepoint = "savepoint"; saveMgr.SetExpectedSavepoint( savepoint ); saveMgr.SetSavepointToReturn( savepoint ); DefaultTransactionStatus status = new DefaultTransactionStatus( saveMgr , true, false, false, true, new object()); status.CreateAndHoldSavepoint( savepoint ); Assert.IsTrue( status.HasSavepoint ); Assert.AreEqual( savepoint, status.Savepoint ); status.RollbackToHeldSavepoint(); saveMgr.Verify(); }
public void DefaultConstructorTests() { ISmartTransactionObject txn = A.Fake <ISmartTransactionObject>(); DefaultTransactionStatus stat = new DefaultTransactionStatus(txn, true, false, false, true, new object()); Assert.IsNotNull(stat.Transaction); Assert.IsTrue(!stat.ReadOnly); Assert.IsTrue(!stat.NewSynchronization); Assert.IsNotNull(stat.SuspendedResources); Assert.IsTrue(stat.IsNewTransaction); Assert.IsTrue(!stat.RollbackOnly); stat.SetRollbackOnly(); Assert.IsTrue(stat.RollbackOnly); }
public void DefaultPropagationBehavior() { MockTxnDefinition def = new MockTxnDefinition(); def.PropagationBehavior = TransactionPropagation.Required; def.ReadOnly = true; setGeneralGetTransactionExpectations(); DefaultTransactionStatus status = (DefaultTransactionStatus)_mockTxnMgr.GetTransaction(def); Assert.AreEqual(_mockTxnMgr.Transaction, status.Transaction); Assert.IsTrue(!status.IsNewTransaction); Assert.IsTrue(status.NewSynchronization); Assert.IsTrue(status.ReadOnly); Assert.IsNull(status.SuspendedResources); }
public void TransactionSuspendedSuccessfully() { MockTxnDefinition def = new MockTxnDefinition(); def.PropagationBehavior = TransactionPropagation.NotSupported; def.ReadOnly = false; setGeneralGetTransactionExpectations(); DefaultTransactionStatus status = (DefaultTransactionStatus)_mockTxnMgr.GetTransaction(def); Assert.IsNull(status.Transaction); Assert.IsTrue(!status.IsNewTransaction); Assert.IsTrue(status.NewSynchronization); Assert.IsTrue(!status.ReadOnly); Assert.IsNotNull(status.SuspendedResources); }
public void DefaultConstructorTests() { ISmartTransactionObject txn = MockRepository.GenerateMock<ISmartTransactionObject>(); DefaultTransactionStatus stat = new DefaultTransactionStatus(txn, true, false, false, true, new object()); Assert.IsNotNull(stat.Transaction); Assert.IsTrue(!stat.ReadOnly); Assert.IsTrue(!stat.NewSynchronization); Assert.IsNotNull(stat.SuspendedResources); Assert.IsTrue(stat.IsNewTransaction); Assert.IsTrue(! stat.RollbackOnly); stat.SetRollbackOnly(); Assert.IsTrue(stat.RollbackOnly); txn.AssertWasCalled(x => x.RollbackOnly, constraints => constraints.Repeat.Once()); }
public void RollbackHeldSavepointSuccess() { MyMockTxnObjectSavepointMgr saveMgr = new MyMockTxnObjectSavepointMgr(); string savepoint = "savepoint"; saveMgr.SetExpectedSavepoint(savepoint); saveMgr.SetSavepointToReturn(savepoint); DefaultTransactionStatus status = new DefaultTransactionStatus(saveMgr, true, false, false, true, new object()); status.CreateAndHoldSavepoint(savepoint); Assert.IsTrue(status.HasSavepoint); Assert.AreEqual(savepoint, status.Savepoint); status.RollbackToHeldSavepoint(); saveMgr.Verify(); }
public void DefaultConstructorTests() { ISmartTransactionObject txn = MockRepository.GenerateMock <ISmartTransactionObject>(); DefaultTransactionStatus stat = new DefaultTransactionStatus(txn, true, false, false, true, new object()); Assert.IsNotNull(stat.Transaction); Assert.IsTrue(!stat.ReadOnly); Assert.IsTrue(!stat.NewSynchronization); Assert.IsNotNull(stat.SuspendedResources); Assert.IsTrue(stat.IsNewTransaction); Assert.IsTrue(!stat.RollbackOnly); stat.SetRollbackOnly(); Assert.IsTrue(stat.RollbackOnly); txn.AssertWasCalled(x => x.RollbackOnly, constraints => constraints.Repeat.Once()); }
public void DefaultConstructorTests() { MyMockTxnObject txn = new MyMockTxnObject(); txn.SetExpectedIsRollBackOnlyValue( false ); txn.SetExpectedRollbackOnlyCalls( 1 ); DefaultTransactionStatus stat = new DefaultTransactionStatus( txn, true, false, false, true, new object() ); Assert.IsNotNull( stat.Transaction ); Assert.IsTrue( !stat.ReadOnly ); Assert.IsTrue( !stat.NewSynchronization ); Assert.IsNotNull( stat.SuspendedResources ); Assert.IsTrue( stat.IsNewTransaction ); Assert.IsTrue( ! stat.RollbackOnly ); stat.SetRollbackOnly(); Assert.IsTrue( stat.RollbackOnly ); txn.Verify(); }
public void DefaultBehaviorDefaultPropagationNoExistingTransaction() { MockTxnDefinition def = new MockTxnDefinition(); def.PropagationBehavior = TransactionPropagation.Never; def.ReadOnly = true; DefaultTransactionStatus status = (DefaultTransactionStatus)_mockTxnMgr.GetTransaction(def); Assert.IsNull(status.Transaction); Assert.IsTrue(!status.IsNewTransaction); Assert.IsTrue(status.NewSynchronization); Assert.IsTrue(status.ReadOnly); Assert.IsNull(status.SuspendedResources); Assert.AreEqual(0, _mockTxnMgr.DoBeginCallCount); AssertVanillaGetTransactionExpectations(); }
public void TransactionCreatedSuccessfully() { MockTxnDefinition def = new MockTxnDefinition(); def.PropagationBehavior = TransactionPropagation.RequiresNew; def.ReadOnly = false; SetGeneralGetTransactionExpectations(); DefaultTransactionStatus status = (DefaultTransactionStatus)_mockTxnMgr.GetTransaction(def); Assert.AreEqual(_mockTxnMgr.Transaction, status.Transaction); Assert.IsTrue(status.IsNewTransaction); Assert.IsTrue(status.NewSynchronization); Assert.IsTrue(!status.ReadOnly); Assert.IsNotNull(status.SuspendedResources); AssertVanillaGetTransactionExpectations(); }
public void DefaultConstructorTests() { MyMockTxnObject txn = new MyMockTxnObject(); txn.SetExpectedIsRollBackOnlyValue(false); txn.SetExpectedRollbackOnlyCalls(1); DefaultTransactionStatus stat = new DefaultTransactionStatus(txn, true, false, false, true, new object()); Assert.IsNotNull(stat.Transaction); Assert.IsTrue(!stat.ReadOnly); Assert.IsTrue(!stat.NewSynchronization); Assert.IsNotNull(stat.SuspendedResources); Assert.IsTrue(stat.IsNewTransaction); Assert.IsTrue(!stat.RollbackOnly); stat.SetRollbackOnly(); Assert.IsTrue(stat.RollbackOnly); txn.Verify(); }
public void NestedTransactionSuccessfully() { MockTxnDefinition def = new MockTxnDefinition(); def.PropagationBehavior = TransactionPropagation.Nested; def.ReadOnly = false; setGeneralGetTransactionExpectations(); _mockTxnMgr.SetExpectedCalls("DoBegin", 1); _mockTxnMgr.Savepoints = false; _mockTxnMgr.NestedTransactionsAllowed = true; DefaultTransactionStatus status = (DefaultTransactionStatus)_mockTxnMgr.GetTransaction(def); Assert.AreEqual(_mockTxnMgr.Transaction, status.Transaction); Assert.IsTrue(status.IsNewTransaction); Assert.AreEqual(true, status.NewSynchronization); Assert.IsTrue(!status.ReadOnly); Assert.IsNull(status.SuspendedResources); }
public void NestedTransactionWithSavepoint() { MockTxnDefinition def = new MockTxnDefinition(); def.PropagationBehavior = TransactionPropagation.Nested; def.ReadOnly = false; setVanillaGetTransactionExpectations(); _mockTxnMgr.SetTransaction(new MyMockTxnObjectSavepointMgr()); _mockTxnMgr.SetExpectedCalls("DoBegin", 0); _mockTxnMgr.Savepoints = true; _mockTxnMgr.NestedTransactionsAllowed = true; DefaultTransactionStatus status = (DefaultTransactionStatus)_mockTxnMgr.GetTransaction(def); Assert.AreEqual(_mockTxnMgr.Transaction, status.Transaction); Assert.IsFalse(status.IsNewTransaction); Assert.IsFalse(status.NewSynchronization); Assert.IsTrue(!status.ReadOnly); Assert.IsNull(status.SuspendedResources); }
public void NestedTransactionWithSavepoint() { MockTxnDefinition def = new MockTxnDefinition(); def.PropagationBehavior = TransactionPropagation.Nested; def.ReadOnly = false; ISavepointManager saveMgr = MockRepository.GenerateMock <ISavepointManager>(); _mockTxnMgr.SetTransaction(saveMgr); _mockTxnMgr.Savepoints = true; _mockTxnMgr.NestedTransactionsAllowed = true; DefaultTransactionStatus status = (DefaultTransactionStatus)_mockTxnMgr.GetTransaction(def); Assert.AreEqual(_mockTxnMgr.Transaction, status.Transaction); Assert.IsFalse(status.IsNewTransaction); Assert.IsFalse(status.NewSynchronization); Assert.IsTrue(!status.ReadOnly); Assert.IsNull(status.SuspendedResources); AssertVanillaGetTransactionExpectations(); Assert.AreEqual(0, _mockTxnMgr.DoBeginCallCount); }
/// <summary>The do commit.</summary> /// <param name="status">The status.</param> protected override void DoCommit(DefaultTransactionStatus status) { this.log.Debug("Committing resourceless transaction on [" + status.Transaction + "]"); }
/// <summary>The do rollback.</summary> /// <param name="status">The status.</param> protected override void DoRollback(DefaultTransactionStatus status) { this.log.Debug("Rolling back resourceless transaction on [" + status.Transaction + "]"); }
/// <summary>The do rollback.</summary> /// <param name="status">The status.</param> protected override void DoRollback(DefaultTransactionStatus status) { }
/// <summary> /// Set the given transaction rollback-only. Only called on rollback /// if the current transaction takes part in an existing one. /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <remarks>Default implementation throws an IllegalTransactionStateException, /// assuming that participating in existing transactions is generally not /// supported. Subclasses are of course encouraged to provide such support. /// </remarks> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of system errors. /// </exception> protected override void DoSetRollbackOnly(DefaultTransactionStatus status) { MessageQueueTransactionObject txObject = (MessageQueueTransactionObject) status.Transaction; txObject.ResourceHolder.RollbackOnly = true; }
public void ReleaseHeldSavepointException() { ISmartTransactionObject transaction = MockRepository.GenerateMock<ISmartTransactionObject>(); DefaultTransactionStatus stat = new DefaultTransactionStatus(transaction, true, false, false, true, new object()); stat.ReleaseHeldSavepoint(); }
public void CreateSavepointException() { DefaultTransactionStatus stat = new DefaultTransactionStatus(new MyMockTxnObject(), true, false, false, true, new object()); stat.CreateSavepoint("mySavePoint"); }
/// <summary> /// Perform an actual rollback on the given transaction. /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <remarks> /// An implementation does not need to check the new transaction flag. /// </remarks> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of system errors. /// </exception> protected override void DoRollback(DefaultTransactionStatus status) { HibernateTransactionObject txObject = (HibernateTransactionObject)status.Transaction; if (status.Debug) { log.Debug("Rolling back Hibernate transaction on Session [" + txObject.SessionHolder.Session + "]"); } try { IDbTransaction adoTx = GetIDbTransaction(txObject.SessionHolder.Transaction); if (adoTx != null && adoTx.Connection != null) { txObject.SessionHolder.Transaction.Rollback(); } } catch (HibernateTransactionException ex) { throw new TransactionSystemException("Could not roll back Hibernate transaction", ex); } catch (HibernateException ex) { // Shouldn't really happen, as a rollback doesn't cause a flush. throw ConvertHibernateAccessException(ex); } finally { if (!txObject.NewSessionHolder) { // Clear all pending inserts/updates/deletes in the Session. // Necessary for pre-bound Sessions, to avoid inconsistent state. txObject.SessionHolder.Session.Clear(); } } }
private void ProcessCommit(DefaultTransactionStatus status) { try { bool beforeCompletionInvoked = false; try { TriggerBeforeCommit(status); TriggerBeforeCompletion(status); beforeCompletionInvoked = true; bool globalRollbackOnly = false; if (status.IsNewTransaction || FailEarlyOnGlobalRollbackOnly) { globalRollbackOnly = status.GlobalRollbackOnly; } if (status.HasSavepoint) { status.ReleaseHeldSavepoint(); } else if (status.IsNewTransaction) { DoCommit(status); } // Throw UnexpectedRollbackException if we have a global rollback-only // marker but still didn't get a corresponding exception from commit. if (globalRollbackOnly) { throw new UnexpectedRollbackException( "Transaction silently rolled back because it has been marked as rollback-only"); } } catch (UnexpectedRollbackException) { TriggerAfterCompletion(status, TransactionSynchronizationStatus.Rolledback); throw; } catch (TransactionException ex) { if (RollbackOnCommitFailure) { DoRollbackOnCommitException(status, ex); } else { TriggerAfterCompletion(status, TransactionSynchronizationStatus.Unknown); } throw; } catch (Exception ex) { if (!beforeCompletionInvoked) { TriggerBeforeCompletion(status); } DoRollbackOnCommitException(status, ex); throw; } // Trigger AfterCommit callbacks, with an exception thrown there // propagated to callers but the transaction still considered as commited. try { TriggerAfterCommit(status); } finally { TriggerAfterCompletion(status, TransactionSynchronizationStatus.Committed); } } finally { CleanupAfterCompletion(status); } }
private void TriggerAfterCommit(DefaultTransactionStatus status) { if (status.NewSynchronization) { if (status.Debug) { log.Debug("Trigger AfterCommit Synchronization"); } IList synchronizations = TransactionSynchronizationManager.Synchronizations; foreach (ITransactionSynchronization currentTxnSynchronization in synchronizations) { try { currentTxnSynchronization.AfterCommit(); } catch (Exception e) { log.Error("TransactionSynchronization.AfterCommit thew exception", e); } } } }
/// <summary> /// Perform an actual commit on the given transaction. /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <remarks> /// <p> /// An implementation does not need to check the rollback-only flag. /// </p> /// </remarks> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of system errors. /// </exception> protected override void DoCommit(DefaultTransactionStatus status) { HibernateTransactionObject txObject = (HibernateTransactionObject)status.Transaction; if (status.Debug) { log.Debug("Committing Hibernate transaction on Session [" + txObject.SessionHolder.Session + "]"); } try { txObject.SessionHolder.Transaction.Commit(); } // Note, unfortunate collision of namespaces/classname for NHibernate.TransactionException // and Spring.Data.NHibernate requires this wierd construct. catch (Exception ex) { Type nhibTxExceptiontype = TypeResolutionUtils.ResolveType("NHibernate.TransactionException, NHibernate"); if (ex.GetType().Equals(nhibTxExceptiontype)) { // assumably from commit call to the underlying ADO.NET connection throw new TransactionSystemException("Could not commit Hibernate transaction", ex); } HibernateException hibEx = ex as HibernateException; if (hibEx != null) { // assumably failed to flush changes to database throw ConvertHibernateAccessException(hibEx); } throw; } }
private void ProcessRollback(DefaultTransactionStatus status) { try { try { TriggerBeforeCompletion(status); if (status.HasSavepoint) { if (status.Debug) { log.Debug("Rolling back transaction to savepoint."); } status.RollbackToHeldSavepoint(); } else if (status.IsNewTransaction) { if (status.Debug) { log.Debug("Initiating transaction rollback"); } DoRollback(status); } else if (status.HasTransaction()) { if (status.LocalRollbackOnly) { if (status.Debug) { log.Debug("Participating transaction failed - marking existing transaction as rollback-only"); } } DoSetRollbackOnly(status); } else { log.Debug("Should roll back transaction but cannot - no transaction available."); } } catch (Exception) { TriggerAfterCompletion(status, TransactionSynchronizationStatus.Unknown); throw; } TriggerAfterCompletion(status, TransactionSynchronizationStatus.Rolledback); } finally { CleanupAfterCompletion(status); } }
protected override void DoRollback(DefaultTransactionStatus status) { PromotableTxScopeTransactionObject txObject = (PromotableTxScopeTransactionObject)status.Transaction; try { txObject.TxScopeAdapter.Dispose(); } catch (Exception e) { throw new Spring.Transaction.TransactionSystemException("Failure on Transaction Scope rollback.", e); } }
/// <summary>The do commit.</summary> /// <param name="status">The status.</param> protected override void DoCommit(DefaultTransactionStatus status) { }
/// <summary>The do set rollback only.</summary> /// <param name="status">The status.</param> protected override void DoSetRollbackOnly(DefaultTransactionStatus status) { }
/// <summary> /// Set the given transaction rollback-only. Only called on rollback /// if the current transaction takes part in an existing one. /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of system errors. /// </exception> protected override void DoSetRollbackOnly(DefaultTransactionStatus status) { HibernateTransactionObject txObject = (HibernateTransactionObject)status.Transaction; if (status.Debug) { log.Debug("Setting Hibernate transaction on Session [" + txObject.SessionHolder.Session + "] rollback-only"); } txObject.SetRollbackOnly(); }
public void CreateSavepointException() { ISmartTransactionObject transaction = MockRepository.GenerateMock<ISmartTransactionObject>(); DefaultTransactionStatus stat = new DefaultTransactionStatus(transaction, true, false, false, true, new object()); stat.CreateSavepoint("mySavePoint"); }
/// <summary>Do rollback.</summary> /// <param name="status">The status.</param> protected override void DoRollback(DefaultTransactionStatus status) { var transactionObject = (RabbitTransactionObject)status.Transaction; var resourceHolder = transactionObject.ResourceHolder; resourceHolder.RollbackAll(); }
public void ReleaseHeldSavepointException() { DefaultTransactionStatus stat = new DefaultTransactionStatus(new MyMockTxnObject(), true, false, false, true, new object()); stat.ReleaseHeldSavepoint(); }
/// <summary>Do set rollback only.</summary> /// <param name="status">The status.</param> protected override void DoSetRollbackOnly(DefaultTransactionStatus status) { var transactionObject = (RabbitTransactionObject)status.Transaction; transactionObject.ResourceHolder.RollbackOnly = true; }
public void RollbackSavepointException() { DefaultTransactionStatus stat = new DefaultTransactionStatus(new MyMockTxnObject(), true, false, false, true, new object()); stat.RollbackToSavepoint(null); }
/// <summary> /// Perform an actual rollback on the given transaction, calls Transaction.Abort(). /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <remarks> /// An implementation does not need to check the new transaction flag. /// </remarks> protected override void DoRollback(DefaultTransactionStatus status) { MessageQueueTransactionObject txObject = (MessageQueueTransactionObject) status.Transaction; MessageQueueTransaction transaction = txObject.ResourceHolder.MessageQueueTransaction; try { if (LOG.IsDebugEnabled) { LOG.Debug("Committing MessageQueueTransaction"); } transaction.Abort(); } catch (MessageQueueException ex) { throw new TransactionSystemException("Could not roll back DefaultMessageQueue transaction", ex); } }
/// <summary> /// Perform an actual commit on the given transaction. /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of system errors. /// </exception> protected override void DoCommit(DefaultTransactionStatus status) { MessageTransactionObject txObject = (MessageTransactionObject)status.Transaction; ISession session = txObject.ResourceHolder.GetSession(); try { if (status.Debug) { LOG.Debug("Committing NMS transaction on Session [" + session + "]"); } session.Commit(); //Note that NMS does not have, TransactionRolledBackException //See https://issues.apache.org/activemq/browse/AMQNET-93 } catch (NMSException ex) { throw new TransactionSystemException("Could not commit NMS transaction.", ex); } }
/// <summary> /// Perform an actual commit on the given transaction. /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of system errors. /// </exception> protected override void DoCommit(DefaultTransactionStatus status) { EmsTransactionObject txObject = (EmsTransactionObject)status.Transaction; ISession session = txObject.ResourceHolder.GetSession(); try { if (status.Debug) { LOG.Debug("Committing EMS transaction on Session [" + session + "]"); } session.Commit(); } catch (TransactionRolledBackException ex) { throw new UnexpectedRollbackException("EMS transaction rolled back", ex); } catch (EMSException ex) { throw new TransactionSystemException("Could not commit EMS transaction.", ex); } }
protected override void DoCommit(DefaultTransactionStatus status) { PromotableTxScopeTransactionObject txObject = (PromotableTxScopeTransactionObject)status.Transaction; try { txObject.TxScopeAdapter.Complete(); txObject.TxScopeAdapter.Dispose(); } catch (TransactionAbortedException ex) { throw new UnexpectedRollbackException("Transaction unexpectedly rolled back (maybe due to a timeout)", ex); } catch (TransactionInDoubtException ex) { throw new HeuristicCompletionException(TransactionOutcomeState.Unknown, ex); } catch (Exception ex) { throw new TransactionSystemException("Failure on Transaction Scope Commit", ex); } }
/// <summary> /// Perform an actual rollback on the given transaction. /// </summary> /// <param name="status">The status representation of the transaction.</param> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of system errors. /// </exception> protected override void DoRollback(DefaultTransactionStatus status) { MessageTransactionObject txObject = (MessageTransactionObject)status.Transaction; ISession session = txObject.ResourceHolder.GetSession(); try { if (status.Debug) { LOG.Debug("Rolling back NMS transaction on Session [" + session + "]"); } session.Rollback(); } catch (NMSException ex) { throw new TransactionSystemException("Could not roll back NMS transaction.", ex); } }
protected override void DoSetRollbackOnly(DefaultTransactionStatus status) { if (status.Debug) { log.Debug("Setting transaction rollback-only"); } try { System.Transactions.Transaction.Current.Rollback(); } catch (Exception ex) { throw new TransactionSystemException("Failure on System.Transactions.Transaction.Current.Rollback", ex); } }
/// <summary> /// Does the tx scope rollback. /// </summary> /// <param name="status">The status.</param> protected void DoTxScopeRollback(DefaultTransactionStatus status) { TxScopeTransactionManager.PromotableTxScopeTransactionObject txObject = ((HibernateTransactionObject)status.Transaction).PromotableTxScopeTransactionObject; try { txObject.TxScopeAdapter.Dispose(); } catch (Exception e) { throw new Spring.Transaction.TransactionSystemException("Failure on Transaction Scope rollback.", e); } }