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);
}
/// <summary>The do cleanup after completion.</summary>
/// <param name="transaction">The transaction.</param>
protected override void DoCleanupAfterCompletion(object transaction)
{
var list = (Stack <object>)TransactionSynchronizationManager.GetResource(this);
var resources = list;
resources.Clear();
TransactionSynchronizationManager.UnbindResource(this);
((ResourcelessTransaction)transaction).Clear();
}
/// <summary>
/// Suspend this synchronization.
/// </summary>
/// <remarks>
/// <p>
/// Supposed to unbind resources from
/// <see cref="Spring.Transaction.Support.TransactionSynchronizationManager"/>
/// if managing any.
/// </p>
/// </remarks>
public override void Suspend()
{
if (holderActive)
{
TransactionSynchronizationManager.UnbindResource(dbProvider);
//TODO do we need to reset the connection inside the conHolder to null?
}
}
/// <summary>
/// Return the current transaction object.
/// </summary>
/// <returns>The current transaction object.</returns>
/// <exception cref="Spring.Transaction.CannotCreateTransactionException">
/// If transaction support is not available.
/// </exception>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of lookup or system errors.
/// </exception>
protected override Object DoGetTransaction()
{
logger.Debug("Do Get Transaction");
Db4oTransactionObject txObject = new Db4oTransactionObject();
ObjectContainerHolder contHolder = (ObjectContainerHolder)TransactionSynchronizationManager.GetResource(_DataSource);
txObject.ObjectContainerHolder = contHolder;
return(txObject);
}
public override void BeforeCompletion()
{
TransactionSynchronizationManager.UnbindResource(resourceKey);
holderActive = false;
if (!transacted)
{
resourceHolder.CloseAll();
}
}
/// <summary>
/// Invoked before transaction commit/rollback (after
/// <see cref="Spring.Transaction.Support.ITransactionSynchronization.BeforeCommit"/>,
/// even if
/// <see cref="Spring.Transaction.Support.ITransactionSynchronization.BeforeCommit"/>
/// threw an exception).
/// </summary>
/// <remarks>
/// <p>
/// Can e.g. perform resource cleanup.
/// </p>
/// <p>
/// Note that exceptions will get propagated to the commit caller
/// and cause a rollback of the transaction.
/// </p>
/// </remarks>
public override void BeforeCompletion()
{
if (connectionHolder.IsOpen)
{
TransactionSynchronizationManager.UnbindResource(dbProvider);
holderActive = false;
ConnectionUtils.DisposeConnection(connectionHolder.Connection, dbProvider);
}
}
/// <summary>
/// Suspend the resources of the current transaction.
/// </summary>
/// <param name="transaction">Transaction object returned by
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
/// <returns>
/// An object that holds suspended resources (will be kept unexamined for passing it into
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoResume"/>.)
/// </returns>
/// <remarks>
/// Transaction synchronization will already have been suspended.
/// </remarks>
/// <exception cref="Spring.Transaction.IllegalTransactionStateException">
/// If suspending is not supported by the transaction manager implementation.
/// </exception>
/// <exception cref="Spring.Transaction.TransactionException">
/// in case of system errors.
/// </exception>
protected override object DoSuspend(object transaction)
{
DbProviderTransactionObject txMgrStateObject = (DbProviderTransactionObject)transaction;
txMgrStateObject.ConnectionHolder = null;
ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.UnbindResource(DbProvider);
return(conHolder);
}
/// <summary>
/// Invoked after transaction commit/rollback.
/// </summary>
/// <param name="status">Status according to <see cref="Spring.Transaction.Support.TransactionSynchronizationStatus"/></param>
/// <remarks>
/// Can e.g. perform resource cleanup, in this case after transaction completion.
/// <p>
/// Note that exceptions will get propagated to the commit or rollback
/// caller, although they will not influence the outcome of the transaction.
/// </p>
/// </remarks>
public override void AfterCompletion(TransactionSynchronizationStatus status)
{
if (TransactionSynchronizationManager.HasResource(dbProvider))
{
TransactionSynchronizationManager.UnbindResource(dbProvider);
holderActive = false;
ConnectionUtils.DisposeConnection(connectionHolder.Connection, dbProvider);
}
}
protected override object DoGetTransaction()
{
IbatisTransactionObject obj = new IbatisTransactionObject();
obj.savepointAllowed = base.NestedTransactionsAllowed;
SqlMapperHolder sqlMapperHolder = (SqlMapperHolder)TransactionSynchronizationManager.GetResource(this.sqlMapper);
obj.SetSqlMapHolder(sqlMapperHolder, false);
return(obj);
}
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);
}
/// <summary>The is existing transaction.</summary>
/// <param name="transaction">The transaction.</param>
/// <returns>The System.Boolean.</returns>
protected override bool IsExistingTransaction(object transaction)
{
if (TransactionSynchronizationManager.HasResource(this))
{
var stack = (Stack <object>)TransactionSynchronizationManager.GetResource(this);
return(stack.Count > 1);
}
return(((ResourcelessTransaction)transaction).Active);
}
/// <summary>
/// Suspend the resources of the current transaction.
/// </summary>
/// <param name="transaction">
/// Transaction object returned by
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
/// </param>
/// <returns>
/// An object that holds suspended resources (will be kept unexamined for passing it into
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoResume"/>.)
/// </returns>
/// <remarks>
/// Transaction synchronization will already have been suspended.
/// </remarks>
/// <exception cref="Spring.Transaction.IllegalTransactionStateException">
/// If suspending is not supported by the transaction manager implementation.
/// </exception>
/// <exception cref="Spring.Transaction.TransactionException">
/// in case of system errors.
/// </exception>
protected override Object DoSuspend(Object transaction)
{
logger.Debug("Do Suspend");
Db4oTransactionObject txObject = (Db4oTransactionObject)transaction;
txObject.ObjectContainerHolder = null;
ObjectContainerHolder containerHolder = (ObjectContainerHolder)TransactionSynchronizationManager.GetResource(_DataSource);
return(new SuspendedResourcesHolder(containerHolder));
}
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"));
}
/// <summary>
/// Determines whether the given JMS Session is transactional, that is,
/// bound to the current thread by Spring's transaction facilities.
/// </summary>
/// <param name="session">The session to check.</param>
/// <param name="cf">The ConnectionFactory that the Session originated from</param>
/// <returns>
/// <c>true</c> if is session transactional, bound to current thread; otherwise, <c>false</c>.
/// </returns>
public static bool IsSessionTransactional(ISession session, IConnectionFactory cf)
{
if (session == null || cf == null)
{
return(false);
}
EmsResourceHolder resourceHolder = (EmsResourceHolder)TransactionSynchronizationManager.GetResource(cf);
return(resourceHolder != null && resourceHolder.ContainsSession(session));
}
/// <summary>
/// Return whether the given DB instance is transactional, that is, bound to the current thread by Spring's transaction
/// facilities.
/// </summary>
/// <param name="db">the Database to check</param>
/// <param name="mongo">the Mongo instance that the DB was created with (may be <code>null</code>)</param>
/// <returns>whether the DB is transactional</returns>
public static bool IsDbTransactional(MongoDatabase db, MongoServer mongo)
{
if (mongo == null)
{
return(false);
}
var dbHolder = (DatabaseHolder)TransactionSynchronizationManager.GetResource(mongo);
return(dbHolder != null && dbHolder.ContainsDatabase(db));
}
public void TransactionWithPropagationSupportsAndInnerTransaction()
{
DbConnection connection = A.Fake <DbConnection>();
ISessionFactory sessionFactory = A.Fake <ISessionFactory>();
ISession session1 = A.Fake <ISession>();
ISession session2 = A.Fake <ISession>();
ITransaction transaction = A.Fake <ITransaction>();
A.CallTo(() => sessionFactory.OpenSession()).Returns(session1).Once()
.Then.Returns(session2).Once();
A.CallTo(() => session1.Connection).Returns(connection);
A.CallTo(() => session1.SessionFactory).Returns(sessionFactory);
A.CallTo(() => session1.FlushMode).Returns(FlushMode.Auto);
A.CallTo(() => session2.Connection).Returns(connection);
A.CallTo(() => session2.BeginTransaction(IsolationLevel.ReadCommitted)).Returns(transaction);
A.CallTo(() => session2.FlushMode).Returns(FlushMode.Auto);
A.CallTo(() => session2.IsOpen).Returns(true);
LocalSessionFactoryObjectStub lsfo = new LocalSessionFactoryObjectStub(sessionFactory);
lsfo.AfterPropertiesSet();
ISessionFactory sfProxy = (ISessionFactory)lsfo.GetObject();
Assert.IsNotNull(sfProxy);
HibernateTransactionManager tm = new HibernateTransactionManager(sessionFactory);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
TransactionTemplate tt = new TransactionTemplate(tm);
tt.PropagationBehavior = TransactionPropagation.Supports;
TransactionTemplate tt2 = new TransactionTemplate(tm);
tt2.PropagationBehavior = TransactionPropagation.Required;
HibernateTemplate ht = new HibernateTemplate(sessionFactory);
ht.TemplateFlushMode = TemplateFlushMode.Eager;
ht.ExposeNativeSession = true;
Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session");
tt.Execute(new TransactionWithPropagationSupportsAndInnerTransactionTxCallback(tt2, sessionFactory, ht, session1, session2));
Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session");
A.CallTo(() => transaction.Commit()).MustHaveHappenedOnceExactly();
A.CallTo(() => session1.Flush()).MustHaveHappenedTwiceExactly();
A.CallTo(() => session2.Flush()).MustHaveHappenedOnceExactly();
A.CallTo(() => session2.Close()).MustHaveHappenedOnceExactly();
}
/// <summary>
/// Return whether the given Hibernate Session is transactional, that is,
/// bound to the current thread by Spring's transaction facilities.
/// </summary>
/// <param name="session">The hibernate session to check</param>
/// <param name="sessionFactory">The session factory that the session
/// was created with, can be null.</param>
/// <returns>
/// <c>true</c> if the session transactional; otherwise, <c>false</c>.
/// </returns>
public static bool IsSessionTransactional(ISession session, ISessionFactory sessionFactory)
{
if (sessionFactory == null)
{
return(false);
}
SessionHolder sessionHolder =
(SessionHolder)TransactionSynchronizationManager.GetResource(sessionFactory);
return(sessionHolder != null && sessionHolder.ContainsSession(session));
}
private void CallExecuteListener(Message message, ulong deliveryTag)
{
var channelLocallyTransacted = _container.IsChannelLocallyTransacted;
try
{
_container.ExecuteListener(Model, message);
HandleAck(deliveryTag, channelLocallyTransacted);
}
catch (ImmediateAcknowledgeAmqpException e)
{
_logger?.LogDebug("User requested ack for failed delivery '" + e.Message + "': " + deliveryTag);
HandleAck(deliveryTag, channelLocallyTransacted);
}
catch (Exception e)
{
if (_container.CauseChainHasImmediateAcknowledgeAmqpException(e))
{
_logger?.LogDebug("User requested ack for failed delivery: " + deliveryTag);
HandleAck(deliveryTag, channelLocallyTransacted);
}
else
{
_logger?.LogError("Failed to invoke listener", e);
if (TransactionManager != null)
{
if (TransactionAttribute.RollbackOn(e))
{
var resourceHolder = (RabbitResourceHolder)TransactionSynchronizationManager.GetResource(ConnectionFactory);
if (resourceHolder == null)
{
/*
* If we don't actually have a transaction, we have to roll back
* manually. See prepareHolderForRollback().
*/
Rollback(deliveryTag, e);
}
throw; // encompassing transaction will handle the rollback.
}
else
{
_logger?.LogDebug("No rollback for " + e);
}
}
else
{
Rollback(deliveryTag, e);
// no need to rethrow e - we'd ignore it anyway, not throw to client
}
}
}
}
/// <summary>
/// Get a ADO.NET Connection/Transaction Pair for the given IDbProvider.
/// Same as <see cref="GetConnection"/> but throwing original provider
/// exception.
/// </summary>
/// <remarks>
/// Is aware of a corresponding Connection/Transaction bound to the current thread, for example
/// when using AdoPlatformTransactionManager. Will bind a IDbConnection to the thread
/// if transaction synchronization is active
/// </remarks>
/// <param name="provider">The provider.</param>
/// <returns></returns>
public static ConnectionTxPair DoGetConnection(IDbProvider provider)
{
AssertUtils.ArgumentNotNull(provider, "provider");
ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.GetResource(provider);
if (conHolder != null && (conHolder.HasConnection || conHolder.SynchronizedWithTransaction))
{
conHolder.Requested();
if (!conHolder.HasConnection)
{
if (LOG.IsDebugEnabled)
{
LOG.Debug("Fetching resumed ADO.NET connection from DbProvider");
}
conHolder.Connection = provider.CreateConnection();
}
return(new ConnectionTxPair(conHolder.Connection, conHolder.Transaction));
}
// Else we either got no holder or an empty thread-bound holder here.
if (LOG.IsDebugEnabled)
{
LOG.Debug("Fetching Connection from DbProvider");
}
IDbConnection conn = provider.CreateConnection();
conn.Open();
if (TransactionSynchronizationManager.SynchronizationActive)
{
LOG.Debug("Registering transaction synchronization for IDbConnection");
//Use same connection for further ADO.NET actions with the transaction.
//Thread-bound object will get removed by manager at transaction completion.
ConnectionHolder holderToUse = conHolder;
if (holderToUse == null)
{
holderToUse = new ConnectionHolder(conn, null);
}
else
{
holderToUse.Connection = conn;
}
holderToUse.Requested();
TransactionSynchronizationManager.RegisterSynchronization(
new ConnectionSynchronization(holderToUse, provider));
holderToUse.SynchronizedWithTransaction = true;
if (holderToUse != conHolder)
{
TransactionSynchronizationManager.BindResource(provider, holderToUse);
}
}
return(new ConnectionTxPair(conn, null));
}
public void TestResourceHolder()
{
var h1 = new RabbitResourceHolder();
var h2 = new RabbitResourceHolder();
var connectionFactory = new Mock <IConnectionFactory>();
TransactionSynchronizationManager.SetActualTransactionActive(true);
ConnectionFactoryUtils.BindResourceToTransaction(h1, connectionFactory.Object, true);
Assert.Same(h1, ConnectionFactoryUtils.BindResourceToTransaction(h2, connectionFactory.Object, true));
TransactionSynchronizationManager.Clear();
}
/// <summary>Register a delivery tag.</summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="channel">The channel.</param>
/// <param name="tag">The tag.</param>
public static void RegisterDeliveryTag(IConnectionFactory connectionFactory, IModel channel, long tag)
{
AssertUtils.ArgumentNotNull(connectionFactory, "ConnectionFactory must not be null");
var resourceHolder = (RabbitResourceHolder)TransactionSynchronizationManager.GetResource(connectionFactory);
if (resourceHolder != null)
{
resourceHolder.AddDeliveryTag(channel, tag);
}
}
public void TransactionCommit()
{
IDbProvider provider = A.Fake <IDbProvider>();
DbConnection connection = A.Fake <DbConnection>();
ISessionFactory sessionFactory = A.Fake <ISessionFactory>();
ISession session = A.Fake <ISession>();
ITransaction transaction = A.Fake <ITransaction>();
IQuery query = A.Fake <IQuery>();
IList list = new ArrayList();
list.Add("test");
A.CallTo(() => sessionFactory.OpenSession()).Returns(session);
A.CallTo(() => session.Connection).Returns(connection);
A.CallTo(() => session.BeginTransaction(IsolationLevel.Serializable)).Returns(transaction);
A.CallTo(() => session.IsOpen).Returns(true);
A.CallTo(() => session.CreateQuery("some query string")).Returns(query);
A.CallTo(() => query.List()).Returns(list);
LocalSessionFactoryObjectStub lsfo = new LocalSessionFactoryObjectStub(sessionFactory);
lsfo.AfterPropertiesSet();
ISessionFactory sfProxy = lsfo.GetObject() as ISessionFactory;
Assert.IsNotNull(sfProxy);
HibernateTransactionManager tm = new HibernateTransactionManager();
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
tm.AdoExceptionTranslator = new FallbackExceptionTranslator();
tm.SessionFactory = sfProxy;
tm.DbProvider = provider;
TransactionTemplate tt = new TransactionTemplate(tm);
tt.TransactionIsolationLevel = IsolationLevel.Serializable;
Assert.IsFalse(TransactionSynchronizationManager.HasResource(sfProxy), "Hasn't thread session");
Assert.IsFalse(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider");
Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active");
Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive, "Actual transaction not active");
object result = tt.Execute(new TransactionCommitTxCallback(sfProxy, provider));
Assert.IsTrue(result == list, "Incorrect result list");
Assert.IsFalse(TransactionSynchronizationManager.HasResource(sfProxy), "Hasn't thread session");
Assert.IsFalse(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider");
Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active");
Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive, "Actual transaction not active");
A.CallTo(() => transaction.Commit()).MustHaveHappenedOnceExactly();
A.CallTo(() => session.Close()).MustHaveHappenedOnceExactly();
}
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()));
}
/// <summary>
/// Opens a new session or participates in an existing session and
/// registers with spring's <see cref="TransactionSynchronizationManager"/>.
/// </summary>
public void Open()
{
if (IsParticipating || IsOpen)
{
throw new InvalidOperationException("This scope is already open");
}
bool isDebugEnabled = log.IsDebugEnabled;
if (SingleSession)
{
// single session mode
if (TransactionSynchronizationManager.HasResource(SessionFactory))
{
// Do not modify the Session: just set the participate flag.
if (isDebugEnabled)
{
log.Debug("Participating in existing Hibernate SessionFactory");
}
SetParticipating(true);
}
else
{
if (isDebugEnabled)
{
log.Debug("Opening single Hibernate Session in SessionScope");
}
TransactionSynchronizationManager.BindResource(SessionFactory, new LazySessionHolder(this));
}
}
else
{
// deferred close mode
if (SessionFactoryUtils.IsDeferredCloseActive(SessionFactory))
{
// Do not modify deferred close: just set the participate flag.
if (isDebugEnabled)
{
log.Debug("Participating in active deferred close mode");
}
SetParticipating(true);
}
else
{
if (isDebugEnabled)
{
log.Debug("Initializing deferred close mode");
}
SessionFactoryUtils.InitDeferredClose(SessionFactory);
}
}
SetOpen(true);
}
public static bool IsChannelTransactional(R.IModel channel, IConnectionFactory connectionFactory)
{
if (channel == null || connectionFactory == null)
{
return(false);
}
var resourceHolder = (RabbitResourceHolder)TransactionSynchronizationManager.GetResource(connectionFactory);
return(resourceHolder != null && resourceHolder.ContainsChannel(channel));
}
/// <summary>
/// Invoked before transaction commit/rollback (after
/// <see cref="Spring.Transaction.Support.ITransactionSynchronization.BeforeCommit"/>,
/// even if
/// <see cref="Spring.Transaction.Support.ITransactionSynchronization.BeforeCommit"/>
/// threw an exception).
/// </summary>
/// <remarks>
/// <p>
/// Can e.g. perform resource cleanup.
/// </p>
/// <p>
/// Note that exceptions will get propagated to the commit caller
/// and cause a rollback of the transaction.
/// </p>
/// </remarks>
public void BeforeCompletion()
{
if (ShouldUnbindAtCompletion())
{
TransactionSynchronizationManager.UnbindResource(_resourceKey);
_holderActive = false;
if (ShouldReleaseBeforeCompletion())
{
ReleaseResource(_resourceHolder, _resourceKey);
}
}
}
/// <summary>The before completion.</summary>
public virtual void BeforeCompletion()
{
if (this.ShouldUnbindAtCompletion())
{
TransactionSynchronizationManager.UnbindResource(this.resourceKey);
this.holderActive = false;
if (this.ShouldReleaseBeforeCompletion())
{
this.ReleaseResource(this.resourceHolder, this.resourceKey);
}
}
}
/// <summary>
/// Return the current transaction object.
/// </summary>
/// <returns>The current transaction object.</returns>
/// <exception cref="Spring.Transaction.CannotCreateTransactionException">
/// If transaction support is not available.
/// </exception>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of lookup or system errors.
/// </exception>
protected override object DoGetTransaction()
{
DbProviderTransactionObject txMgrStateObject =
new DbProviderTransactionObject();
txMgrStateObject.SavepointAllowed = NestedTransactionsAllowed;
ConnectionHolder conHolder =
(ConnectionHolder)TransactionSynchronizationManager.GetResource(DbProvider);
txMgrStateObject.SetConnectionHolder(conHolder, false);
return(txMgrStateObject);
}
/// <summary>
/// Cleanup resources after transaction completion.
/// </summary>
/// <param name="transaction">Transaction object returned by
/// <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
/// <remarks>
/// <note>
/// This implemenation unbinds the SessionFactory and
/// DbProvider from thread local storage and closes the
/// ISession.
/// </note>
/// <p>
/// Called after <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoCommit(Spring.Transaction.Support.DefaultTransactionStatus)"/>
/// and
/// <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoRollback(Spring.Transaction.Support.DefaultTransactionStatus)"/>
/// execution on any outcome.
/// </p>
/// <p>
/// Should not throw any exceptions but just issue warnings on errors.
/// </p>
/// </remarks>
protected override void DoCleanupAfterCompletion(object transaction)
{
HibernateTransactionObject txObject = (HibernateTransactionObject)transaction;
// Remove the session holder from the thread.
if (txObject.NewSessionHolder)
{
TransactionSynchronizationManager.UnbindResource(SessionFactory);
}
// Remove the ADO.NET connection holder from the thread, if exposed.
if (DbProvider != null)
{
TransactionSynchronizationManager.UnbindResource(DbProvider);
}
/*
* try
* {
* //TODO investigate isolation level settings...
* //IDbConnection con = txObject.SessionHolder.Session.Connection;
* //AdoUtils.ResetConnectionAfterTransaction(con, txObject.PreviousIsolationLevel);
* }
* catch (HibernateException ex)
* {
* log.Info("Could not access ADO.NET IDbConnection of Hibernate Session", ex);
* }
*/
ISession session = txObject.SessionHolder.Session;
if (txObject.NewSessionHolder)
{
if (log.IsDebugEnabled)
{
log.Debug("Closing Hibernate Session [" + session + "] after transaction");
}
SessionFactoryUtils.CloseSessionOrRegisterDeferredClose(session, SessionFactory);
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("Not closing pre-bound Hibernate Session [" + session + "] after transaction");
}
if (txObject.SessionHolder.AssignedPreviousFlushMode)
{
session.FlushMode = txObject.SessionHolder.PreviousFlushMode;
}
}
txObject.SessionHolder.Clear();
}
/// <summary>
/// Invoked before transaction commit (before
/// <see cref="Spring.Transaction.Support.ITransactionSynchronization.BeforeCompletion"/>)
/// Can e.g. flush transactional O/R Mapping sessions to the database
/// </summary>
/// <remarks>
/// <para>
/// This callback does not mean that the transaction will actually be
/// commited. A rollback decision can still occur after this method
/// has been called. This callback is rather meant to perform work
/// that's only relevant if a commit still has a chance
/// to happen, such as flushing SQL statements to the database.
/// </para>
/// <para>
/// Note that exceptions will get propagated to the commit caller and cause a
/// rollback of the transaction.</para>
/// <para>
/// (note: do not throw TransactionException subclasses here!)
/// </para>
/// </remarks>
public override void BeforeCompletion()
{
if (this.newSession)
{
// Default behavior: unbind and close the thread-bound Hibernate Session.
TransactionSynchronizationManager.UnbindResource(this.sessionFactory);
this.holderActive = false;
}
else if (this.sessionHolder.AssignedPreviousFlushMode == true)
{
// In case of pre-bound Session, restore previous flush mode.
this.sessionHolder.Session.FlushMode = (this.sessionHolder.PreviousFlushMode);
}
}