private void ResumeAfterBeginException(object transaction, SuspendedResourcesHolder suspendedResources, Exception beginEx)
{
try
{
Resume(transaction, suspendedResources);
}
catch (Exception)
{
var exMessage = "Inner transaction begin exception overridden by outer transaction resume exception";
_logger?.LogError(beginEx, exMessage);
throw;
}
}
/// <summary>
/// Resume the resources of the current transaction.
/// </summary>
/// <param name="transaction">
/// Transaction object returned by
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
/// </param>
/// <param name="suspendedResources">
/// The object that holds suspended resources as returned by
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoSuspend"/>.
/// </param>
/// <remarks>
/// Transaction synchronization will be resumed afterwards.
/// </remarks>
/// <exception cref="Spring.Transaction.IllegalTransactionStateException">
/// If suspending is not supported by the transaction manager implementation.
/// </exception>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoResume(Object transaction, Object suspendedResources)
{
logger.Debug("Do Resume");
SuspendedResourcesHolder resourcesHolder = (SuspendedResourcesHolder)suspendedResources;
Db4oTransactionObject txObject = (Db4oTransactionObject)transaction;
txObject.ObjectContainerHolder = resourcesHolder.ObjectContainerHolder;
if (TransactionSynchronizationManager.HasResource(_DataSource))
{
TransactionSynchronizationManager.UnbindResource(_DataSource);
}
TransactionSynchronizationManager.BindResource(_DataSource,
resourcesHolder.ObjectContainerHolder);
}
/// <summary>
/// Resume the resources of the current transaction.
/// </summary>
/// <param name="transaction">
/// Transaction object returned by
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
/// </param>
/// <param name="suspendedResources">
/// The object that holds suspended resources as returned by
/// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoSuspend"/>.
/// </param>
/// <remarks>
/// Transaction synchronization will be resumed afterwards.
/// </remarks>
/// <exception cref="Spring.Transaction.IllegalTransactionStateException">
/// If suspending is not supported by the transaction manager implementation.
/// </exception>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoResume(object transaction, object suspendedResources)
{
SuspendedResourcesHolder resourcesHolder = (SuspendedResourcesHolder)suspendedResources;
if (TransactionSynchronizationManager.HasResource(SessionFactory))
{
// From non-transactional code running in active transaction synchronization
// -> can be safely removed, will be closed on transaction completion.
TransactionSynchronizationManager.UnbindResource(SessionFactory);
}
TransactionSynchronizationManager.BindResource(SessionFactory, resourcesHolder.SessionHolder);
if (DbProvider != null)
{
TransactionSynchronizationManager.BindResource(DbProvider, resourcesHolder.ConnectionHolder);
}
}
protected virtual void Resume(object transaction, SuspendedResourcesHolder resourcesHolder)
{
if (resourcesHolder != null)
{
var suspendedResources = resourcesHolder.SuspendedResources;
if (suspendedResources != null)
{
DoResume(transaction, suspendedResources);
}
var suspendedSynchronizations = resourcesHolder.SuspendedSynchronizations;
if (suspendedSynchronizations != null)
{
TransactionSynchronizationManager.SetActualTransactionActive(resourcesHolder.WasActive);
TransactionSynchronizationManager.SetCurrentTransactionIsolationLevel(resourcesHolder.IsolationLevel);
TransactionSynchronizationManager.SetCurrentTransactionReadOnly(resourcesHolder.ReadOnly);
TransactionSynchronizationManager.SetCurrentTransactionName(resourcesHolder.Name);
DoResumeSynchronization(suspendedSynchronizations);
}
}
}
