protected override void DoSetRollbackOnly(DefaultTransactionStatus status)
{
if (status.Debug)
{
log.Debug("Setting transaction rollback-only");
}
try
{
System.Transactions.Transaction.Current.Rollback();
} catch (Exception ex)
{
throw new TransactionSystemException("Failure on System.Transactions.Transaction.Current.Rollback", ex);
}
}
protected override void DoRollback(DefaultTransactionStatus status)
{
PromotableTxScopeTransactionObject txObject =
(PromotableTxScopeTransactionObject)status.Transaction;
try
{
txObject.TxScopeAdapter.Dispose();
}
catch (Exception e)
{
throw new TransactionSystemException("Failure on Transaction Scope rollback.", e);
}
}
/// <summary>
/// Does the tx scope rollback.
/// </summary>
/// <param name="status">The status.</param>
protected void DoTxScopeRollback(DefaultTransactionStatus status)
{
TxScopeTransactionManager.PromotableTxScopeTransactionObject txObject =
((HibernateTransactionObject)status.Transaction).PromotableTxScopeTransactionObject;
try
{
txObject.TxScopeAdapter.Dispose();
}
catch (Exception e)
{
throw new Spring.Transaction.TransactionSystemException("Failure on Transaction Scope rollback.", e);
}
}
protected override void DoSetRollbackOnly(DefaultTransactionStatus status)
{
ServiceDomainTransactionObject txObject = (ServiceDomainTransactionObject)status.Transaction;
if (status.Debug)
{
log.Debug("Setting transaction rollback-only");
}
try
{
txObject.ServiceDomainAdapter.MyTransactionVote = TransactionVote.Abort;
}
catch (Exception ex)
{
throw new TransactionSystemException("Failure on System.Transactions.Transaction.Current.Rollback", ex);
}
}
/// <summary>
/// Perform an actual rollback on the given transaction, calls Transaction.Abort().
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <remarks>
/// An implementation does not need to check the new transaction flag.
/// </remarks>
protected override void DoRollback(DefaultTransactionStatus status)
{
MessageQueueTransactionObject txObject = (MessageQueueTransactionObject)status.Transaction;
MessageQueueTransaction transaction = txObject.ResourceHolder.MessageQueueTransaction;
try
{
if (LOG.IsDebugEnabled)
{
LOG.Debug("Committing MessageQueueTransaction");
}
transaction.Abort();
}
catch (MessageQueueException ex)
{
throw new TransactionSystemException("Could not roll back DefaultMessageQueue transaction", ex);
}
}
/// <summary>
/// Perform an actual rollback on the given transaction.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoRollback(DefaultTransactionStatus status)
{
EmsTransactionObject txObject = (EmsTransactionObject)status.Transaction;
ISession session = txObject.ResourceHolder.GetSession();
try
{
if (status.Debug)
{
LOG.Debug("Rolling back EMS transaction on Session [" + session + "]");
}
session.Rollback();
}
catch (EMSException ex)
{
throw new TransactionSystemException("Could not roll back EMS transaction.", ex);
}
}
/// <summary>
/// Perform an actual rollback on the given transaction.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <remarks>
/// An implementation does not need to check the new transaction flag.
/// </remarks>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoRollback(DefaultTransactionStatus status)
{
DbProviderTransactionObject txMgrStateObject =
(DbProviderTransactionObject)status.Transaction;
IDbConnection conn = txMgrStateObject.ConnectionHolder.Connection;
IDbTransaction trans = txMgrStateObject.ConnectionHolder.Transaction;
if (status.Debug)
{
log.Debug("Rolling back ADO.NET transaction on Connection [" + conn + ", " + conn.ConnectionString + "]");
}
try
{
trans.Rollback();
}
catch (Exception e)
{
throw new TransactionSystemException("Could not rollback ADO.NET transaction", e);
}
}
/// <summary>
/// Perform an actual commit on the given transaction.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoCommit(DefaultTransactionStatus status)
{
MessageTransactionObject txObject = (MessageTransactionObject)status.Transaction;
ISession session = txObject.ResourceHolder.GetSession();
try
{
if (status.Debug)
{
LOG.Debug("Committing NMS transaction on Session [" + session + "]");
}
session.Commit();
//Note that NMS does not have, TransactionRolledBackException
//See https://issues.apache.org/activemq/browse/AMQNET-93
}
catch (NMSException ex)
{
throw new TransactionSystemException("Could not commit NMS transaction.", ex);
}
}
protected override void DoRollback(DefaultTransactionStatus status)
{
ServiceDomainTransactionObject txObject = (ServiceDomainTransactionObject)status.Transaction;
if (txObject.ServiceDomainAdapter.IsInTransaction)
{
try
{
txObject.ServiceDomainAdapter.SetAbort();
txObject.ServiceDomainAdapter.Leave();
}
catch (PlatformNotSupportedException ex)
{
throw new TransactionSystemException("Failure on Rollback. Platform does not support EnterpriseServices 'Services without Components'", ex);
}
catch (Exception e)
{
throw new Spring.Transaction.TransactionSystemException("Failure upon Leaving ServiceDomain (for Rollback)", e);
}
}
}
/// <summary>
/// Perform an actual commit on the given transaction.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoCommit(DefaultTransactionStatus status)
{
EmsTransactionObject txObject = (EmsTransactionObject)status.Transaction;
ISession session = txObject.ResourceHolder.GetSession();
try
{
if (status.Debug)
{
LOG.Debug("Committing EMS transaction on Session [" + session + "]");
}
session.Commit();
}
catch (TransactionRolledBackException ex)
{
throw new UnexpectedRollbackException("EMS transaction rolled back", ex);
}
catch (EMSException ex)
{
throw new TransactionSystemException("Could not commit EMS transaction.", ex);
}
}
/// <summary>
/// Does the tx scope commit.
/// </summary>
/// <param name="status">The status.</param>
protected void DoTxScopeCommit(DefaultTransactionStatus status)
{
TxScopeTransactionManager.PromotableTxScopeTransactionObject txObject =
((HibernateTransactionObject)status.Transaction).PromotableTxScopeTransactionObject;
try
{
txObject.TxScopeAdapter.Complete();
txObject.TxScopeAdapter.Dispose();
}
catch (TransactionAbortedException ex)
{
throw new UnexpectedRollbackException("Transaction unexpectedly rolled back (maybe due to a timeout)", ex);
}
catch (TransactionInDoubtException ex)
{
throw new HeuristicCompletionException(TransactionOutcomeState.Unknown, ex);
}
catch (Exception ex)
{
throw new TransactionSystemException("Failure on Transaction Scope Commit", ex);
}
}
protected override void DoCommit(DefaultTransactionStatus status)
{
ServiceDomainTransactionObject txObject = (ServiceDomainTransactionObject)status.Transaction;
bool globalRollbackOnly = status.GlobalRollbackOnly;
try
{
if (txObject.ServiceDomainAdapter.IsInTransaction)
{
if (txObject.ServiceDomainAdapter.MyTransactionVote == TransactionVote.Commit)
{
txObject.ServiceDomainAdapter.SetComplete();
}
else
{
txObject.ServiceDomainAdapter.SetAbort();
}
}
TransactionStatus serviceDomainTxstatus = txObject.ServiceDomainAdapter.Leave();
if (log.IsDebugEnabled)
{
log.Debug("ServiceDomain Transaction Status upon leaving ServiceDomain = " + serviceDomainTxstatus);
}
txObject.TransactionStatus = serviceDomainTxstatus;
if (!globalRollbackOnly && serviceDomainTxstatus == TransactionStatus.Aborted)
{
throw new UnexpectedRollbackException("Transaction unexpectedly rolled-back (maybe due to a timeout)");
}
}
catch (PlatformNotSupportedException ex)
{
throw new TransactionSystemException("Failure on Commit. Platform does not support EnterpriseServices 'Services without Components'", ex);
}
catch (Exception e)
{
throw new TransactionSystemException("Failure upon Leaving ServiceDomain (for Commit)", e);
}
}
/// <summary>
/// Perform an actual rollback on the given transaction.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <remarks>
/// An implementation does not need to check the new transaction flag.
/// </remarks>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoRollback(DefaultTransactionStatus status)
{
HibernateTransactionObject txObject = (HibernateTransactionObject)status.Transaction;
if (status.Debug)
{
log.Debug("Rolling back Hibernate transaction on Session [" +
txObject.SessionHolder.Session + "]");
}
try
{
IDbTransaction adoTx = GetIDbTransaction(txObject.SessionHolder.Transaction);
if (adoTx != null && adoTx.Connection != null)
{
txObject.SessionHolder.Transaction.Rollback();
}
}
catch (HibernateTransactionException ex)
{
throw new TransactionSystemException("Could not roll back Hibernate transaction", ex);
}
catch (HibernateException ex)
{
// Shouldn't really happen, as a rollback doesn't cause a flush.
throw ConvertHibernateAccessException(ex);
}
finally
{
if (!txObject.NewSessionHolder)
{
// Clear all pending inserts/updates/deletes in the Session.
// Necessary for pre-bound Sessions, to avoid inconsistent state.
txObject.SessionHolder.Session.Clear();
}
}
}
/// <summary>
/// Perform an actual commit on the given transaction.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <remarks>
/// <p>
/// An implementation does not need to check the rollback-only flag.
/// </p>
/// </remarks>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoCommit(DefaultTransactionStatus status)
{
HibernateTransactionObject txObject = (HibernateTransactionObject)status.Transaction;
if (status.Debug)
{
log.Debug("Committing Hibernate transaction on Session [" +
txObject.SessionHolder.Session + "]");
}
try
{
txObject.SessionHolder.Transaction.Commit();
}
// Note, unfortunate collision of namespaces/classname for NHibernate.TransactionException
// and Spring.Data.NHibernate requires this wierd construct.
catch (Exception ex)
{
Type nhibTxExceptiontype = TypeResolutionUtils.ResolveType("NHibernate.TransactionException, NHibernate");
if (ex.GetType().Equals(nhibTxExceptiontype))
{
// assumably from commit call to the underlying ADO.NET connection
throw new TransactionSystemException("Could not commit Hibernate transaction", ex);
}
HibernateException hibEx = ex as HibernateException;
if (hibEx != null)
{
// assumably failed to flush changes to database
throw ConvertHibernateAccessException(hibEx);
}
throw;
}
finally
{
DoTxScopeCommit(status);
}
}
/// <summary>
/// Set the given transaction rollback-only. Only called on rollback
/// if the current transaction takes part in an existing one.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoSetRollbackOnly(DefaultTransactionStatus status)
{
EmsTransactionObject txObject = (EmsTransactionObject)status.Transaction;
txObject.ResourceHolder.RollbackOnly = true;
}
protected override void DoRollback(DefaultTransactionStatus status)
{
++rollbacks;
--inflight;
}
/// <summary>The do rollback.</summary>
/// <param name="status">The status.</param>
protected override void DoRollback(DefaultTransactionStatus status)
{
this.log.Debug("Rolling back resourceless transaction on [" + status.Transaction + "]");
}
/// <summary>The do commit.</summary>
/// <param name="status">The status.</param>
protected override void DoCommit(DefaultTransactionStatus status)
{
this.log.Debug("Committing resourceless transaction on [" + status.Transaction + "]");
}
/// <summary>The do commit.</summary>
/// <param name="status">The status.</param>
protected override void DoCommit(DefaultTransactionStatus status)
{
}
/// <summary>The do rollback.</summary>
/// <param name="status">The status.</param>
protected override void DoRollback(DefaultTransactionStatus status)
{
}
protected override void DoCommit(DefaultTransactionStatus status)
{
_committed = true;
_latch.Signal();
}
protected override void DoSetRollbackOnly(DefaultTransactionStatus status)
{
}
protected override void DoRollback(DefaultTransactionStatus status)
{
_rolledBack = true;
_latch.Signal();
}
protected override void DoCommit(DefaultTransactionStatus status)
{
this.sqlMapper.CommitTransaction();
}
protected override void DoRollback(DefaultTransactionStatus status)
{
this.sqlMapper.RollBackTransaction();
}
protected override void DoCommit(DefaultTransactionStatus status)
{
++commits;
--inflight;
}
protected override void DoRollback(DefaultTransactionStatus status)
{
base.log.Debug("回滚事务");
this.sqlMap.RollBackTransaction();
}
/// <summary>
/// Perform an actual rollback on the given transaction.
/// </summary>
/// <param name="status">The status representation of the transaction.</param>
/// <remarks>
/// An implementation does not need to check the new transaction flag.
/// </remarks>
/// <exception cref="Spring.Transaction.TransactionException">
/// In the case of system errors.
/// </exception>
protected override void DoRollback(DefaultTransactionStatus status)
{
HibernateTransactionObject txObject = (HibernateTransactionObject)status.Transaction;
if (!txObject.NewSessionHolder)
{
// Clear all pending inserts/updates/deletes in the Session.
// Necessary for pre-bound Sessions, to avoid inconsistent state.
txObject.SessionHolder.Session.Clear();
}
DoTxScopeRollback(status);
return;
/* HibernateTransactionObject txObject = (HibernateTransactionObject)status.Transaction;
*
* if (status.Debug)
* {
* log.Debug("Rolling back Hibernate transaction on Session [" +
* txObject.SessionHolder.Session + "]");
* }
* try
* {
* if (txObject.SessionHolder.Session != null && txObject.SessionHolder.Transaction != null && !txObject.SessionHolder.Transaction.IsActive)
* {
* return;
* }
*
* IDbTransaction adoTx = GetIDbTransaction(txObject.SessionHolder.Transaction);
*
* if (adoTx != null && adoTx.Connection != null)
* {
* txObject.SessionHolder.Transaction.Rollback();
* }
* else
* {
* if (status.Debug)
* {
* log.Debug("Unable to RollBack Hibernate transaction; connection for Hibernate transaction on Session [" +
* txObject.SessionHolder.Session + "] was null");
* }
* }
*
* }
* catch (HibernateTransactionException ex)
* {
* throw new TransactionSystemException("Could not roll back Hibernate transaction", ex);
* }
* catch (HibernateException ex)
* {
* // Shouldn't really happen, as a rollback doesn't cause a flush.
* throw ConvertHibernateAccessException(ex);
* }
* finally
* {
* if (!txObject.NewSessionHolder)
* {
* // Clear all pending inserts/updates/deletes in the Session.
* // Necessary for pre-bound Sessions, to avoid inconsistent state.
* txObject.SessionHolder.Session.Clear();
* }
* DoTxScopeRollback(status);
* }*/
}
protected override void DoCommit(DefaultTransactionStatus status)
{
base.log.Debug("提交事务");
this.sqlMap.CommitTransaction();
}
