public void TransactionSuspension() { IConnectionFactory connectionFactory = A.Fake <IConnectionFactory>(); IConnection connection = A.Fake <IConnection>(); ISession session = A.Fake <ISession>(); ISession session2 = A.Fake <ISession>(); A.CallTo(() => connectionFactory.CreateConnection()).Returns(connection).Twice(); A.CallTo(() => connection.CreateSession(AcknowledgementMode.Transactional)) .Returns(session).Once() .Then.Returns(session2).Once(); NmsTransactionManager tm = new NmsTransactionManager(connectionFactory); ITransactionStatus ts = tm.GetTransaction(new DefaultTransactionDefinition()); NmsTemplate nt = new NmsTemplate(connectionFactory); TransactionTemplate tt = new TransactionTemplate(tm); tt.PropagationBehavior = TransactionPropagation.RequiresNew; tt.Execute(status => { nt.Execute(new AssertNotSameSessionCallback(session)); return(null); }); nt.Execute(new AssertSessionCallback(session)); tm.Commit(ts); A.CallTo(() => session.Commit()).MustHaveHappenedOnceExactly(); A.CallTo(() => session2.Commit()).MustHaveHappenedOnceExactly(); A.CallTo(() => session.Close()).MustHaveHappenedOnceExactly(); A.CallTo(() => session2.Close()).MustHaveHappenedOnceExactly(); A.CallTo(() => connection.Close()).MustHaveHappenedTwiceExactly(); }
public void ParticipatingTransactionWithCommit() { IConnectionFactory connectionFactory = A.Fake <IConnectionFactory>(); IConnection connection = A.Fake <IConnection>(); ISession session = A.Fake <ISession>(); SetupCreateSession(connection, connectionFactory, session); NmsTransactionManager tm = new NmsTransactionManager(connectionFactory); ITransactionStatus ts = tm.GetTransaction(new DefaultTransactionDefinition()); NmsTemplate nt = new NmsTemplate(connectionFactory); nt.Execute(new AssertSessionCallback(session)); TransactionTemplate tt = new TransactionTemplate(tm); tt.Execute(status => { nt.Execute(new AssertSessionCallback(session)); return(null); }); tm.Commit(ts); AssertCommitExpectations(connection, connectionFactory, session); }
public void ParticipatingTransactionWithRollback() { IConnectionFactory connectionFactory = A.Fake <IConnectionFactory>(); IConnection connection = A.Fake <IConnection>(); ISession session = A.Fake <ISession>(); SetupCreateSession(connection, connectionFactory, session); NmsTransactionManager tm = new NmsTransactionManager(connectionFactory); ITransactionStatus ts = tm.GetTransaction(new DefaultTransactionDefinition()); NmsTemplate nt = new NmsTemplate(connectionFactory); nt.Execute(new AssertSessionCallback(session)); TransactionTemplate tt = new TransactionTemplate(tm); tt.Execute(status => { nt.Execute(new AssertSessionCallback(session)); status.SetRollbackOnly(); return(null); }); try { tm.Commit(ts); Assert.Fail("Should have thrown UnexpectedRollbackException"); } catch (UnexpectedRollbackException) { } AssertRollbackExpectations(connection, connectionFactory, session); }
public void CannotCommitTransaction() { ITransactionAttribute txatt = new DefaultTransactionAttribute(); MethodInfo m = typeof(ITestObject).GetMethod("GetDescription"); MethodMapTransactionAttributeSource tas = new MethodMapTransactionAttributeSource(); tas.AddTransactionalMethod(m, txatt); IPlatformTransactionManager ptm = A.Fake <IPlatformTransactionManager>(); ITransactionStatus status = A.Fake <ITransactionStatus>(); A.CallTo(() => ptm.GetTransaction(txatt)).Returns(status); UnexpectedRollbackException ex = new UnexpectedRollbackException("foobar", null); A.CallTo(() => ptm.Commit(status)).Throws(ex); TestObject to = new TestObject(); ITestObject ito = (ITestObject)Advised(to, ptm, tas); try { ito.GetDescription(); Assert.Fail("Shouldn't have succeeded"); } catch (UnexpectedRollbackException thrown) { Assert.IsTrue(thrown == ex); } }
public object CommitTxDelegate(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); return(null); }
public void ExecuteTransactionManager() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.PropagationBehavior = TransactionPropagation.Required; ITransactionStatus status = transactionManager.GetTransaction(def); int iCount = 0; try { iCount = (int)adoOperations.ExecuteScalar(CommandType.Text, "SELECT COUNT(*) FROM TestObjects"); /* * IAdoCommand cmd = new AdoCommand(dbProvider, CommandType.Text); * cmd.CommandText = "SELECT COUNT(*) FROM TestObjects"; * iCount = (int)cmd.ExecuteScalar(); */ //other AdoCommands can be executed within same tx. } catch (Exception e) { transactionManager.Rollback(status); throw e; } transactionManager.Commit(status); Assert.AreEqual(2, iCount); }
public object CommitTxDelegate(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); return null; }
public void ParticipatingTransactionWithCommit() { IConnectionFactory connectionFactory = (IConnectionFactory)mocks.CreateMock(typeof(IConnectionFactory)); IConnection connection = (IConnection)mocks.CreateMock(typeof(IConnection)); ISession session = (ISession)mocks.CreateMock(typeof(ISession)); using (mocks.Ordered()) { SetupCommitExpectations(connection, connectionFactory, session); } mocks.ReplayAll(); EmsTransactionManager tm = new EmsTransactionManager(connectionFactory); ITransactionStatus ts = tm.GetTransaction(new DefaultTransactionDefinition()); EmsTemplate nt = new EmsTemplate(connectionFactory); nt.Execute(new AssertSessionCallback(session)); TransactionTemplate tt = new TransactionTemplate(tm); tt.Execute(delegate(ITransactionStatus status) { nt.Execute(new AssertSessionCallback(session)); return(null); }); tm.Commit(ts); mocks.VerifyAll(); }
public object DoInTransaction(ITransactionStatus status) { HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; return(ht.ExecuteFind(new RequiresNewTxCallbackInner(holder))); }
public virtual void Commit(ITransactionStatus status) { if (status.IsCompleted) { throw new IllegalTransactionStateException( "Transaction is already completed - do not call commit or rollback more than once per transaction"); } var defStatus = (DefaultTransactionStatus)status; if (defStatus.IsLocalRollbackOnly) { _logger?.LogDebug("Transactional code has requested rollback"); ProcessRollback(defStatus, false); return; } if (!ShouldCommitOnGlobalRollbackOnly && defStatus.IsGlobalRollbackOnly) { _logger?.LogDebug("Global transaction is marked as rollback-only but transactional code requested commit"); ProcessRollback(defStatus, true); return; } ProcessCommit(defStatus); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); throw exception; }
/// <summary> /// TBD /// </summary> public static IPlatformTransaction CreateTransaction(IDbProvider dbProvider, ITransactionDefinition txDefinition) { AdoPlatformTransactionManager txMgr = new AdoPlatformTransactionManager(dbProvider); ITransactionStatus txStatus = txMgr.GetTransaction(txDefinition); return(new PlatformTransactionHolder(txStatus, txMgr)); }
private void Start() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.PropagationBehavior = TransactionPropagation.Required; status = transactionManager.GetTransaction(def); }
public void ProgrammaticRollback() { ITransactionAttribute txatt = new DefaultTransactionAttribute(); MethodInfo m = typeof(RollbackTestObject).GetMethod("GetDescription"); MethodMapTransactionAttributeSource tas = new MethodMapTransactionAttributeSource(); tas.AddTransactionalMethod(m, txatt); ITransactionStatus status = TransactionStatusForNewTransaction(); IPlatformTransactionManager ptm = PlatformTxManagerForNewTransaction(); Expect.Call(ptm.GetTransaction(txatt)).Return(status).Repeat.Once(); ptm.Commit(status); LastCall.On(ptm).Repeat.Once(); mocks.ReplayAll(); RollbackTestObject to = new RollbackTestObject(); ITestObject ito = (ITestObject)Advised(to, ptm, tas); Assert.AreEqual("test description", ito.GetDescription()); mocks.VerifyAll(); }
private void DoTestRollbackOnException(Exception exception, bool shouldRollback, bool rollbackException) { ITransactionAttribute txatt = new ConfigurableTransactionAttribute(shouldRollback); MethodInfo mi = typeof(ITestObject).GetMethod("Exceptional"); MethodMapTransactionAttributeSource tas = new MethodMapTransactionAttributeSource(); tas.AddTransactionalMethod(mi, txatt); ITransactionStatus status = TransactionStatusForNewTransaction(); IPlatformTransactionManager ptm = (IPlatformTransactionManager)mocks.DynamicMock(typeof(IPlatformTransactionManager)); Expect.On(ptm).Call(ptm.GetTransaction(txatt)).Return(status); if (shouldRollback) { ptm.Rollback(status); } else { ptm.Commit(status); } TransactionSystemException tex = new TransactionSystemException("system exception"); if (rollbackException) { LastCall.On(ptm).Throw(tex).Repeat.Once(); } else { LastCall.On(ptm).Repeat.Once(); } mocks.ReplayAll(); TestObject to = new TestObject(); ITestObject ito = (ITestObject)Advised(to, ptm, tas); try { ito.Exceptional(exception); Assert.Fail("Should have thrown exception"); } catch (Exception e) { if (rollbackException) { Assert.AreEqual(tex, e); } else { Assert.AreEqual(exception, e); } } mocks.VerifyAll(); }
public void ParticipatingTransactionWithCommit() { IConnectionFactory connectionFactory = mocks.StrictMock <IConnectionFactory>(); IConnection connection = mocks.StrictMock <IConnection>(); ISession session = mocks.StrictMock <ISession>(); using (mocks.Ordered()) { SetupCommitExpectations(connection, connectionFactory, session); } mocks.ReplayAll(); NmsTransactionManager tm = new NmsTransactionManager(connectionFactory); ITransactionStatus ts = tm.GetTransaction(new DefaultTransactionDefinition()); NmsTemplate nt = new NmsTemplate(connectionFactory); nt.Execute(new AssertSessionCallback(session)); TransactionTemplate tt = new TransactionTemplate(tm); tt.Execute(status => { nt.Execute(new AssertSessionCallback(session)); return(null); }); tm.Commit(ts); mocks.VerifyAll(); }
public override string GetDescription() { ITransactionStatus txStatus = TransactionInterceptor.CurrentTransactionStatus; txStatus.SetRollbackOnly(); return("test description"); }
public void CannotCommitTransaction() { ITransactionAttribute txatt = new DefaultTransactionAttribute(); MethodInfo m = typeof(ITestObject).GetMethod("GetDescription"); MethodMapTransactionAttributeSource tas = new MethodMapTransactionAttributeSource(); tas.AddTransactionalMethod(m, txatt); IPlatformTransactionManager ptm = PlatformTxManagerForNewTransaction(); ITransactionStatus status = TransactionStatusForNewTransaction(); Expect.On(ptm).Call(ptm.GetTransaction(txatt)).Return(status); UnexpectedRollbackException ex = new UnexpectedRollbackException("foobar", null); ptm.Commit(status); LastCall.On(ptm).Throw(ex); mocks.ReplayAll(); TestObject to = new TestObject(); ITestObject ito = (ITestObject)Advised(to, ptm, tas); try { ito.GetDescription(); Assert.Fail("Shouldn't have succeeded"); } catch (UnexpectedRollbackException thrown) { Assert.IsTrue(thrown == ex); } mocks.VerifyAll(); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sessionFactory), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sessionFactory); return(ht.ExecuteFind(new TransactionCommitWithFlushFailureHibernateCallback(list))); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sf); return(ht.ExecuteFind(new ThrowExceptionHibernateCallback())); }
public PlatformTransactionHolder(ITransactionStatus txStatus, IPlatformTransactionManager txMgr) { AssertUtils.ArgumentNotNull(txStatus, "txStatus"); AssertUtils.ArgumentNotNull(txMgr, "txMgr"); this.txStatus = txStatus; this.txMgr = txMgr; this.commit = false; }
public void Rollback(ITransactionStatus transactionStatus) { _rollbackCalls.Inc(); if (_throwRollbackException) { throw new Exception("Rollback"); } }
public BaseTransaction(AbstractPlatformTransactionManager transactionManager) { _TransactionManager = transactionManager; DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.PropagationBehavior = TransactionPropagation.Required; _ITransactionStatus = _TransactionManager.GetTransaction(def); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; return(ht.Execute(new HibernateDelegate(Del))); }
/// <summary> /// Gets called by TransactionTemplate.Execute within a /// transaction context. /// </summary> /// <param name="status">The associated transaction status.</param> /// <returns>A result object or <c>null</c>.</returns> public object DoInTransaction(ITransactionStatus status) { if (throwException) { throw new ArgumentException("Explicitly thrown exception"); } adoTemplateTests.DoUpdateDataSet(); return(null); }
public object TransactionInformationTxDelegate(ITransactionStatus status) { Assert.AreEqual(System.Transactions.IsolationLevel.ReadUncommitted, System.Transactions.Transaction.Current.IsolationLevel); Assert.AreEqual(System.Data.IsolationLevel.ReadUncommitted, TransactionSynchronizationManager.CurrentTransactionIsolationLevel); return(null); }
private object TransactionMethod(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sf); object returnValue = ht.Execute(new HibernateDelegate(Del)); status.SetRollbackOnly(); return(null); }
private object TransactionMethod(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive, "Synchronization active"); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); status.SetRollbackOnly(); return(null); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sfProxy), "Has thread session"); Assert.IsTrue(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); HibernateTemplate ht = new HibernateTemplate(sfProxy); return(ht.Find("some query string")); }
public TransactionStatus(ITransactionStatus item) { ClientId = item.ClientId; TransactionHash = item.TransactionHash; WalletAddress = item.WalletAddress; OutputNumber = item.OutputNumber; TransactionAmount = item.TransactionAmount; ChainalysisCategory = item.ChainalysisCategory; ChainalysisName = item.ChainalysisName; ChainalysisRiskScore = item.ChainalysisRiskScore; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sf), "Hasn't thread session"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; return(ht.ExecuteFind(new NotSupportedTxCallbackInner())); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(!TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsTrue(!status.IsNewTransaction, "Is not new transaction"); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sf), "Hasn't thread session"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; return ht.ExecuteFind(new NotSupportedTxCallbackInner()); }
public object DoInTransaction(ITransactionStatus status) { HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; return ht.ExecuteFind(new RequiresNewTxCallbackInner(holder)); }
public object DoInTransaction(ITransactionStatus status) { return tt.Execute(new TransactionDelegate(TransactionMethod)); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; ht.Execute(new HibernateDelegate(Del)); status.SetRollbackOnly(); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sessionFactory), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sessionFactory); return ht.ExecuteFind(new TransactionCommitWithFlushFailureHibernateCallback(list)); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sf), "Hasn't thread session"); Assert.IsTrue(!status.IsNewTransaction, "Is not new transaction"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); ht.Execute(new HibernateDelegate(HibernateDelegate)); Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); tt.Execute(new PropagationSupportsTxCallback(ht, session2)); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); return null; }
/// <summary> /// Does the receive and execute using TxPlatformTransactionManager. Starts a distributed /// transaction before calling Receive. /// </summary> /// <param name="mq">The message queue.</param> /// <param name="status">The transactional status.</param> /// <returns> /// true if should continue peeking, false otherwise. /// </returns> protected override bool DoReceiveAndExecuteUsingPlatformTransactionManager(MessageQueue mq, ITransactionStatus status) { #region Logging if (LOG.IsDebugEnabled) { LOG.Debug("Executing DoReceiveAndExecuteUsingTxScopeTransactionManager"); } #endregion Logging //We are sure to be talking to a second resource manager, so avoid going through //the promotable transaction and force a distributed transaction right from the start. TransactionInterop.GetTransmitterPropagationToken(System.Transactions.Transaction.Current); Message message; try { message = mq.Receive(TimeSpan.Zero, MessageQueueTransactionType.Automatic); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { //expected to occur occasionally #region Logging if (LOG.IsTraceEnabled) { LOG.Trace( "MessageQueueErrorCode.IOTimeout: No message available to receive. May have been processed by another thread."); } #endregion status.SetRollbackOnly(); return false; // no more peeking unless this is the last listener thread } else { // A real issue in receiving the message lock (messageQueueMonitor) { mq.Close(); MessageQueue.ClearConnectionCache(); } throw; // will cause rollback in surrounding platform transaction manager and log exception } } if (message == null) { #region Logging if (LOG.IsTraceEnabled) { LOG.Trace("Message recieved is null from Queue = [" + mq.Path + "]"); } #endregion status.SetRollbackOnly(); return false; // no more peeking unless this is the last listener thread } try { #region Logging if (LOG.IsDebugEnabled) { LOG.Debug("Received message [" + message.Id + "] on queue [" + mq.Path + "]"); } #endregion MessageReceived(message); if (DistributedTransactionExceptionHandler != null) { if (DistributedTransactionExceptionHandler.IsPoisonMessage(message)) { DistributedTransactionExceptionHandler.HandlePoisonMessage(message); return true; // will remove from queue and continue receive loop. } } DoExecuteListener(message); } catch (Exception ex) { HandleDistributedTransactionListenerException(ex, message); throw; // will rollback and keep message on the queue. } finally { message.Dispose(); } return true; }
/// <summary> /// Gets called by TransactionTemplate.Execute within a /// transaction context. /// </summary> /// <param name="status">The associated transaction status.</param> /// <returns>a result object or <c>null</c></returns> public object DoInTransaction(ITransactionStatus status) { AdoTemplate adoTemplate = new AdoTemplate(dbProvider); return adoTemplate.Execute(new TestCommandCallback()); }
/// <summary> /// Gets called by TransactionTemplate.Execute within a /// transaction context. /// </summary> /// <param name="status">The associated transaction status.</param> /// <returns>a result object or <c>null</c></returns> public object DoInTransaction(ITransactionStatus status) { return dao.FindByName("Gabriel"); }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive, "Synchronization active"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); innerTxTemplate.Execute(new PropagationRequiresNewWithExistingTransactionCallback2(dbProvider)); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(dbProvider), "Has thread connection"); Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive, "Synchronization active"); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); status.SetRollbackOnly(); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); throw exception; }
/// <summary> /// Gets called by TransactionTemplate.execute within a transactional context /// when no return value is required. /// </summary> /// <param name="status">The status.</param> /// <remarks> /// Does not need to care about transactions itself, although it can retrieve /// and influence the status of the current transaction via the given status /// object, e.g. setting rollback-only. /// A RuntimeException thrown by the callback is treated as application /// exception that enforces a rollback. An exception gets propagated to the /// caller of the template. /// </remarks> public abstract void DoInTransactionWithoutResult(ITransactionStatus status);
/// <summary> /// Gets called by TransactionTemplate.Execute within a /// transaction context. /// </summary> /// <param name="status">The associated transaction status.</param> /// <returns>a result object or <c>null</c></returns> public object DoInTransaction(ITransactionStatus status) { DoInTransactionWithoutResult(status); return null; }
public object DoInTransaction(ITransactionStatus status) { return ht.Execute(new HibernateDelegate(HibernateDelegate)); }
public object DoInTransaction(ITransactionStatus status) { status.SetRollbackOnly(); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sfProxy),"Has thread session"); Assert.IsTrue(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); HibernateTemplate ht = new HibernateTemplate(sfProxy); return ht.Find("some query string"); }
public object DoInTransaction(ITransactionStatus status) { try { Thread.Sleep(1500); } catch (Exception) { } try { IDbConnection con = ConnectionUtils.GetConnection(provider); IDbCommand cmd = con.CreateCommand(); cmd.CommandText = "some SQL statement"; ConnectionUtils.ApplyTransactionTimeout(cmd, provider); } catch (Exception e) { if (e.GetType() != typeof(TransactionTimedOutException)) { throw new DataAccessResourceFailureException("", e); } throw; } return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; return ht.ExecuteFind(new ThrowExceptionHibernateCallback()); }
private object TransactionWithExceptionOnRollbackMethod(ITransactionStatus status) { status.SetRollbackOnly(); return null; }
private object TransactionMethod(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); HibernateTemplate ht = new HibernateTemplate(sf); object returnValue = ht.Execute(new HibernateDelegate(Del)); status.SetRollbackOnly(); return null; }
private object TransactionWithPropagationNestedMethod(ITransactionStatus status) { Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); return null; }
public object DoInTransaction(ITransactionStatus status) { SessionHolder holder = (SessionHolder)TransactionSynchronizationManager.GetResource(sf); Assert.IsNotNull(holder, "Has thread session"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); tt.PropagationBehavior = TransactionPropagation.NotSupported; tt.Execute(new NotSupportedTxCallback(sf)); Assert.IsTrue(holder.Session == SessionFactoryUtils.GetSession(sf, false), "Same thread session as before"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsTrue(TransactionSynchronizationManager.ActualTransactionActive); return null; }
private object TransactionWithPropagationNestedAndRollbackMethod(ITransactionStatus status) { Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); status.SetRollbackOnly(); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sf), "Hasn't thread session"); Assert.IsTrue(!status.IsNewTransaction, "Is not new transaction"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); HibernateTemplate ht = new HibernateTemplate(sf); ht.TemplateFlushMode = TemplateFlushMode.Eager; object returnValue = ht.Execute(new HibernateDelegate(Del)); Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session"); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(!TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsTrue(!status.IsNewTransaction,"Is not new transaction"); Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); return null; }
public object DoInTransaction(ITransactionStatus status) { Assert.IsTrue(TransactionSynchronizationManager.HasResource(dbProvider), "Has thread db provider"); Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations active"); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); Assert.AreSame(connection2, ConnectionUtils.GetConnection(dbProvider)); Assert.AreSame(connection2, ConnectionUtils.GetConnection(dbProvider)); return null; }
private object TransactionWithExceptionNoOp(ITransactionStatus status) { return null; }