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;
}
