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