/// <summary> /// Prepare the session for the transaction commit. Run /// <see cref="ISessionImplementor.BeforeTransactionCompletion(ITransaction)"/> for the session and for /// <see cref="ConnectionManager.DependentSessions"/> if any. <see cref="Lock"/> the context /// before signaling it is done, or before rollback in case of failure. /// </summary> /// <param name="preparingEnlistment">The object for notifying the prepare phase outcome.</param> public virtual void Prepare(PreparingEnlistment preparingEnlistment) { _preparing = true; using (_session.BeginContext()) { try { using (_session.ConnectionManager.BeginProcessingFromSystemTransaction(_useConnectionOnSystemTransactionPrepare)) { if (_useConnectionOnSystemTransactionPrepare) { // Ensure any newly acquired connection gets enlisted in the transaction. When distributed, // this code runs from another thread and we cannot rely on Transaction.Current. using (var tx = new TransactionScope(EnlistedTransaction)) { // Required when both connection auto-enlistment and session auto-enlistment are disabled. _session.JoinTransaction(); _session.BeforeTransactionCompletion(null); foreach (var dependentSession in _session.ConnectionManager.DependentSessions) { dependentSession.BeforeTransactionCompletion(null); } tx.Complete(); } } else { _session.BeforeTransactionCompletion(null); foreach (var dependentSession in _session.ConnectionManager.DependentSessions) { dependentSession.BeforeTransactionCompletion(null); } } } // Lock the session to ensure second phase gets done before the session is used by code following // the transaction scope disposal. Lock(); _logger.Debug("Prepared for system transaction"); _preparing = false; preparingEnlistment.Prepared(); } catch (Exception exception) { _preparing = false; _logger.Error(exception, "System transaction prepare phase failed"); try { CompleteTransaction(false); } finally { preparingEnlistment.ForceRollback(exception); } } } }
void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) { using (new SessionIdLoggingContext(sessionImplementor.SessionId)) { try { using (var tx = new TransactionScope(AmbientTransation)) { sessionImplementor.BeforeTransactionCompletion(null); //if (sessionImplementor.FlushMode != FlushMode.Never && sessionImplementor.ConnectionManager.IsConnected) //{ // using (sessionImplementor.ConnectionManager.FlushingFromDtcTransaction) // { // logger.Debug(string.Format("[session-id={0}] Flushing from Dtc Transaction", sessionImplementor.SessionId)); // sessionImplementor.Flush(); // } //} logger.Debug("prepared for DTC transaction"); tx.Complete(); } preparingEnlistment.Prepared(); } catch (Exception exception) { logger.Error("DTC transaction prepre phase failed", exception); preparingEnlistment.ForceRollback(exception); } } }
void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) { using (new SessionIdLoggingContext(sessionImplementor.SessionId)) { try { using (var tx = new TransactionScope(AmbientTransation)) { if (sessionImplementor.ConnectionManager.IsConnected) { using (sessionImplementor.ConnectionManager.FlushingFromDtcTransaction) { sessionImplementor.BeforeTransactionCompletion(null); foreach (var dependentSession in sessionImplementor.ConnectionManager.DependentSessions) { dependentSession.BeforeTransactionCompletion(null); } logger.Debug("prepared for DTC transaction"); tx.Complete(); } } } preparingEnlistment.Prepared(); } catch (Exception exception) { logger.Error("DTC transaction prepare phase failed", exception); preparingEnlistment.ForceRollback(exception); } } }
/// <summary> /// Commits the <see cref="ITransaction"/> by flushing the <see cref="ISession"/> /// and committing the <see cref="IDbTransaction"/>. /// </summary> /// <exception cref="TransactionException"> /// Thrown if there is any exception while trying to call <c>Commit()</c> on /// the underlying <see cref="IDbTransaction"/>. /// </exception> public void Commit() { using (new SessionIdLoggingContext(sessionId)) { CheckNotDisposed(); CheckBegun(); CheckNotZombied(); log.Debug("Start Commit"); //if (session.FlushMode != FlushMode.Never) //{ // session.Flush(); //} NotifyLocalSynchsBeforeTransactionCompletion(); session.BeforeTransactionCompletion(this); try { if (trans != null) { trans.Commit(); log.Debug("IDbTransaction Committed"); } committed = true; AfterTransactionCompletion(true); Dispose(); log.Debug("Committed"); } catch (HibernateException e) { log.Error("Commit failed", e); AfterTransactionCompletion(false); commitFailed = true; // Don't wrap HibernateExceptions throw; } catch (Exception e) { log.Error("Commit failed", e); AfterTransactionCompletion(false); commitFailed = true; throw new TransactionException("Commit failed with SQL exception", e); } finally { CloseIfRequired(); } } }
/// <summary> /// Commits the <see cref="ITransaction"/> by flushing the <see cref="ISession"/> /// and committing the <see cref="DbTransaction"/>. /// </summary> /// <exception cref="TransactionException"> /// Thrown if there is any exception while trying to call <c>Commit()</c> on /// the underlying <see cref="DbTransaction"/>. /// </exception> public void Commit() { using (session.BeginProcess()) { CheckNotDisposed(); CheckBegun(); CheckNotZombied(); log.Debug("Start Commit"); session.BeforeTransactionCompletion(this); NotifyLocalSynchsBeforeTransactionCompletion(); foreach (var dependentSession in session.ConnectionManager.DependentSessions) { dependentSession.BeforeTransactionCompletion(this); } try { trans.Commit(); log.Debug("DbTransaction Committed"); committed = true; AfterTransactionCompletion(true); Dispose(); } catch (HibernateException e) { log.Error(e, "Commit failed"); AfterTransactionCompletion(false); commitFailed = true; // Don't wrap HibernateExceptions throw; } catch (Exception e) { log.Error(e, "Commit failed"); AfterTransactionCompletion(false); commitFailed = true; throw new TransactionException("Commit failed with SQL exception", e); } finally { CloseIfRequired(); } } }
/// <summary> /// Commits the <see cref="ITransaction"/> by flushing the <see cref="ISession"/> /// and committing the <see cref="IDbTransaction"/>. /// </summary> /// <exception cref="TransactionException"> /// Thrown if there is any exception while trying to call <c>Commit()</c> on /// the underlying <see cref="IDbTransaction"/>. /// </exception> public void Commit() { CheckNotDisposed(); CheckBegun(); log.Debug("commit"); if (session.FlushMode != FlushMode.Never) { session.Flush(); } session.BeforeTransactionCompletion(this); try { trans.Commit(); committed = true; AfterTransactionCompletion(true); Dispose(); } catch (HibernateException e) { log.Error("Commit failed", e); AfterTransactionCompletion(false); commitFailed = true; // Don't wrap HibernateExceptions throw; } catch (Exception e) { log.Error("Commit failed", e); AfterTransactionCompletion(false); commitFailed = true; throw new TransactionException("Commit failed with SQL exception", e); } }
public void BeforeTransactionCompletion(ITransaction tx) { _session.BeforeTransactionCompletion(tx); }
public void beforeTransactionCompletion(ITransaction tx) { delegat.BeforeTransactionCompletion(tx); }