/// <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 void AfterCompletion(TransactionSynchronizationStatus status) { if (ShouldUnbindAtCompletion()) { bool releaseNecessary; if (_holderActive) { // The thread-bound resource holder might not be available anymore, // since afterCompletion might get called from a different thread. _holderActive = false; TransactionSynchronizationManager.UnbindResource(_resourceKey); _resourceHolder.Unbound(); releaseNecessary = true; } else { releaseNecessary = ShouldReleaseAfterCompletion(_resourceHolder); } if (releaseNecessary) { ReleaseResource(_resourceHolder, _resourceKey); } } else { // Probably a pre-bound resource... CleanupResource(_resourceHolder, _resourceKey, (status == TransactionSynchronizationStatus.Committed)); } _resourceHolder.Reset(); }
public override void AfterCompletion(TransactionSynchronizationStatus status) { if (transacted) { resourceHolder.CloseAll(); } }
/// <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 (!newSession) { ISession session = sessionHolder.Session; // Provide correct transaction status for releasing the Session's cache locks, // if possible. Else, closing will release all cache locks assuming a rollback. ISessionImplementor sessionImplementor = session as ISessionImplementor; if (sessionImplementor != null) { sessionImplementor.AfterTransactionCompletion(status == TransactionSynchronizationStatus.Committed, sessionHolder.Transaction); } if (newSession) { SessionFactoryUtils.CloseSessionOrRegisterDeferredClose(session, sessionFactory); } } if (!newSession && status != TransactionSynchronizationStatus.Committed) { // Clear all pending inserts/updates/deletes in the Session. // Necessary for pre-bound Sessions, to avoid inconsistent state. sessionHolder.Session.Clear(); } if (this.sessionHolder.DoesNotHoldNonDefaultSession) { sessionHolder.SynchronizedWithTransaction = false; } }
/// <summary>The after completion.</summary> /// <param name="status">The status.</param> public virtual void AfterCompletion(TransactionSynchronizationStatus status) { if (this.ShouldUnbindAtCompletion()) { var releaseNecessary = false; if (this.holderActive) { // The thread-bound resource holder might not be available anymore, // since afterCompletion might get called from a different thread. this.holderActive = false; // TransactionSynchronizationManager.UnbindResourceIfPossible(this.resourceKey); this.UnbindResourceIfPossible(this.resourceKey); this.resourceHolder.Unbound(); releaseNecessary = true; } else { releaseNecessary = this.ShouldReleaseAfterCompletion(this.resourceHolder); } if (releaseNecessary) { this.ReleaseResource(this.resourceHolder, this.resourceKey); } } else { // Probably a pre-bound resource... this.CleanupResource(this.resourceHolder, this.resourceKey, status == TransactionSynchronizationStatus.Committed); } this.resourceHolder.Reset(); }
/// <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); } }
/// <summary>Actions to be done after completion.</summary> /// <param name="status">The status.</param> public override void AfterCompletion(TransactionSynchronizationStatus status) { if (status != (int)TransactionSynchronizationStatus.Committed) { this.resourceHolder.RollbackAll(); } if (this.resourceHolder.ReleaseAfterCompletion) { this.resourceHolder.SynchronizedWithTransaction = false; } base.AfterCompletion(status); }
/// <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) { base.AfterCompletion(status); logger.Debug("After Completion"); // if not closed BeforeCompletion, do it now // (and if it hasn't been done by someone else) if (TransactionSynchronizationManager.HasResource(_DataSource)) { TransactionSynchronizationManager.UnbindResource(_DataSource); _HolderActive = false; if (_Holder.ObjectContainer != null) { DisposeConnection(_Holder.ObjectContainer, _DataSource); } } }
public void AfterCompletion(TransactionSynchronizationStatus syncStatus) { Assert.IsFalse(afterCompletionCalled); afterCompletionCalled = true; Assert.IsTrue(syncStatus == status); Assert.IsTrue(TransactionSynchronizationManager.HasResource(provider)); }
public TestTransactionSynchronization(IDbProvider provider, TransactionSynchronizationStatus synchronizationStatus) { this.provider = provider; status = synchronizationStatus; }
private void InvokeAfterCompletion(IList synchronizations, TransactionSynchronizationStatus status) { foreach (ITransactionSynchronization synchronization in synchronizations) { try { synchronization.AfterCompletion(status); } catch (Exception e) { log.Error("TransactionSynchronization.AfterCompletion threw exception", e); } } }
/// <summary> /// Trigger afterCompletion callback, handling exceptions properly. /// </summary> /// <param name="status">object representing the transaction</param> /// <param name="completionStatus"> /// Completion status according to <see cref="Spring.Transaction.Support.TransactionSynchronizationStatus"/> /// </param> private void TriggerAfterCompletion(DefaultTransactionStatus status, TransactionSynchronizationStatus completionStatus) { if (status.NewSynchronization) { IList synchronizations = TransactionSynchronizationManager.Synchronizations; if (!status.HasTransaction() || status.IsNewTransaction) { if (status.Debug) { log.Debug("Triggering afterCompletion synchronization"); } InvokeAfterCompletion(synchronizations, completionStatus); } else { //TODO investigate parallel of JTA/System.Txs log.Info("Transaction controlled outside of spring tx manager."); RegisterAfterCompletionWithExistingTransaction(status.Transaction, synchronizations); } } }
/** * Actually invoke the <code>afterCompletion</code> methods of the * given Spring TransactionSynchronization objects. * @param synchronizations List of TransactionSynchronization objects * @param completionStatus the completion status according to the * constants in the TransactionSynchronization interface * @see TransactionSynchronization#afterCompletion(int) * @see TransactionSynchronization#STATUS_COMMITTED * @see TransactionSynchronization#STATUS_ROLLED_BACK * @see TransactionSynchronization#STATUS_UNKNOWN */ /// <summary>The invoke after completion.</summary> /// <param name="synchronizations">The synchronizations.</param> /// <param name="completionStatus">The completion status.</param> public static void InvokeAfterCompletion(IList<ITransactionSynchronization> synchronizations, TransactionSynchronizationStatus completionStatus) { if (synchronizations != null) { foreach (var synchronization in synchronizations) { try { synchronization.AfterCompletion(completionStatus); } catch (Exception tsex) { Logger.Error("TransactionSynchronization.afterCompletion threw exception", tsex); } } } }
/** * Actually invoke the <code>afterCompletion</code> methods of the * given Spring TransactionSynchronization objects. * @param synchronizations List of TransactionSynchronization objects * @param completionStatus the completion status according to the * constants in the TransactionSynchronization interface * @see TransactionSynchronization#afterCompletion(int) * @see TransactionSynchronization#STATUS_COMMITTED * @see TransactionSynchronization#STATUS_ROLLED_BACK * @see TransactionSynchronization#STATUS_UNKNOWN */ /// <summary>The invoke after completion.</summary> /// <param name="synchronizations">The synchronizations.</param> /// <param name="completionStatus">The completion status.</param> public static void InvokeAfterCompletion(IList <ITransactionSynchronization> synchronizations, TransactionSynchronizationStatus completionStatus) { if (synchronizations != null) { foreach (var synchronization in synchronizations) { try { synchronization.AfterCompletion(completionStatus); } catch (Exception tsex) { Logger.Error("TransactionSynchronization.afterCompletion threw exception", tsex); } } } }
/// <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 virtual void AfterCompletion( TransactionSynchronizationStatus status ) {}
/// <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 virtual void AfterCompletion(TransactionSynchronizationStatus status) { }
public void AfterCompletion(TransactionSynchronizationStatus status) { //TODO SPRNET-1244 }
/** * Trigger <code>afterCompletion</code> callbacks on all currently registered synchronizations. * @see TransactionSynchronizationManager#getSynchronizations() * @param completionStatus the completion status according to the * constants in the TransactionSynchronization interface * @see TransactionSynchronization#afterCompletion(int) * @see TransactionSynchronization#STATUS_COMMITTED * @see TransactionSynchronization#STATUS_ROLLED_BACK * @see TransactionSynchronization#STATUS_UNKNOWN */ /// <summary>The trigger after completion.</summary> /// <param name="completionStatus">The completion status.</param> public static void TriggerAfterCompletion(TransactionSynchronizationStatus completionStatus) { var synchronizations = TransactionSynchronizationManager.Synchronizations.ToGenericList <ITransactionSynchronization>(); InvokeAfterCompletion(synchronizations, completionStatus); }
public void AfterCompletion(TransactionSynchronizationStatus status) { sync.AfterCompletion(true); }
/** * Trigger <code>afterCompletion</code> callbacks. * @param status object representing the transaction * @param completionStatus completion status according to TransactionSynchronization constants */ private void TriggerAfterCompletion(DefaultTransactionStatus status, TransactionSynchronizationStatus completionStatus) { if (status.NewSynchronization) { var synchronizations = TransactionSynchronizationManager.Synchronizations.ToGenericList<ITransactionSynchronization>(); if (synchronizations != null) { if (!status.HasTransaction() || status.NewSynchronization) { if (status.Debug) { Logger.Trace("Triggering afterCompletion synchronization"); } // No transaction or new transaction for the current scope -> // invoke the afterCompletion callbacks immediately this.InvokeAfterCompletion(synchronizations, completionStatus); } else if (!(synchronizations.Count < 1)) { // Existing transaction that we participate in, controlled outside // of the scope of this Spring transaction manager -> try to register // an afterCompletion callback with the existing (JTA) transaction. this.RegisterAfterCompletionWithExistingTransaction(status.Transaction, synchronizations); } } } }
/** * Trigger <code>afterCompletion</code> callbacks on all currently registered synchronizations. * @see TransactionSynchronizationManager#getSynchronizations() * @param completionStatus the completion status according to the * constants in the TransactionSynchronization interface * @see TransactionSynchronization#afterCompletion(int) * @see TransactionSynchronization#STATUS_COMMITTED * @see TransactionSynchronization#STATUS_ROLLED_BACK * @see TransactionSynchronization#STATUS_UNKNOWN */ /// <summary>The trigger after completion.</summary> /// <param name="completionStatus">The completion status.</param> public static void TriggerAfterCompletion(TransactionSynchronizationStatus completionStatus) { var synchronizations = TransactionSynchronizationManager.Synchronizations.ToGenericList<ITransactionSynchronization>(); InvokeAfterCompletion(synchronizations, completionStatus); }
/** * Actually invoke the <code>afterCompletion</code> methods of the * given Spring TransactionSynchronization objects. * <p>To be called by this abstract manager itself, or by special implementations * of the <code>registerAfterCompletionWithExistingTransaction</code> callback. * @param synchronizations List of TransactionSynchronization objects * @param completionStatus the completion status according to the * constants in the TransactionSynchronization interface * @see #registerAfterCompletionWithExistingTransaction(Object, java.util.List) * @see TransactionSynchronization#STATUS_COMMITTED * @see TransactionSynchronization#STATUS_ROLLED_BACK * @see TransactionSynchronization#STATUS_UNKNOWN */ /// <summary>The invoke after completion.</summary> /// <param name="synchronizations">The synchronizations.</param> /// <param name="completionStatus">The completion status.</param> protected void InvokeAfterCompletion(IList<ITransactionSynchronization> synchronizations, TransactionSynchronizationStatus completionStatus) { TransactionSynchronizationUtils.InvokeAfterCompletion(synchronizations, completionStatus); }