/// <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;
}
}
/// <summary>
/// Convert the given HibernateException to an appropriate exception from the
/// Spring's DAO Exception hierarchy.
/// Will automatically apply a specified IAdoExceptionTranslator to a
/// Hibernate ADOException, else rely on Hibernate's default translation.
/// </summary>
/// <param name="ex">The Hibernate exception that occured.</param>
/// <returns>A corresponding DataAccessException</returns>
protected virtual DataAccessException ConvertHibernateException(HibernateException ex)
{
if (ex is ADOException)
{
return(ConvertAdoAccessException((ADOException)ex));
}
return(SessionFactoryUtils.ConvertHibernateAccessException(ex));
}
/// <summary>
/// Convert the given HibernateException to an appropriate exception from the
/// <code>Spring.Dao</code> hierarchy. Note that it is advisable to
/// handle AdoException specifically by using a AdoExceptionTranslator for the
/// underlying ADO.NET exception.
/// </summary>
/// <param name="ex">The Hibernate exception that occured.</param>
/// <returns>DataAccessException instance</returns>
public static DataAccessException ConvertHibernateAccessException(HibernateException ex)
{
if (ex is ADOException)
{
// ADOException during Hibernate access: only passed in here from custom code,
// as HibernateTemplate etc will use AdoExceptionTranslator-based handling.
return(new HibernateAdoException("Ado Exception", (ADOException)ex));
}
if (ex is UnresolvableObjectException)
{
return(new HibernateObjectRetrievalFailureException((UnresolvableObjectException)ex));
}
if (ex is ObjectDeletedException)
{
return(new InvalidDataAccessApiUsageException(ex.Message, ex));
}
if (ex is WrongClassException)
{
return(new HibernateObjectRetrievalFailureException((WrongClassException)ex));
}
if (ex is StaleObjectStateException)
{
return(new HibernateOptimisticLockingFailureException((StaleObjectStateException)ex));
}
if (ex is StaleStateException)
{
return(new HibernateOptimisticLockingFailureException((StaleStateException)ex));
}
if (ex is QueryException)
{
return(new HibernateQueryException((QueryException)ex));
}
if (ex is PersistentObjectException)
{
return(new InvalidDataAccessApiUsageException(ex.Message, ex));
}
if (ex is TransientObjectException)
{
return(new InvalidDataAccessApiUsageException(ex.Message, ex));
}
if (ex is PropertyValueException)
{
return(new DataIntegrityViolationException(ex.Message, ex));
}
if (ex is PersistentObjectException)
{
return(new InvalidDataAccessApiUsageException(ex.Message, ex));
}
if (ex is NonUniqueResultException)
{
return(new IncorrectResultSizeDataAccessException(ex.Message, 1));
}
// fallback
return(new HibernateSystemException(ex));
}
/// <summary>
/// Convert the given HibernateException to an appropriate exception from
/// the Spring.Dao hierarchy. Can be overridden in subclasses.
/// </summary>
/// <param name="ex">The HibernateException that occured.</param>
/// <returns>The corresponding DataAccessException instance</returns>
protected virtual DataAccessException ConvertHibernateAccessException(HibernateException ex)
{
if (AdoExceptionTranslator != null && ex is ADOException)
{
return(ConvertAdoAccessException((ADOException)ex, AdoExceptionTranslator));
}
else if (ex is ADOException)
{
return(ConvertAdoAccessException((ADOException)ex, DefaultAdoExceptionTranslator));
}
return(SessionFactoryUtils.ConvertHibernateAccessException(ex));
}
private void RollbackShardTransactions()
{
if (transactions == null)
{
return;
}
try
{
HibernateException firstRollbackException = null;
foreach (ITransaction t in transactions)
{
try
{
if (t.IsActive)
{
t.Rollback();
}
}
catch (HibernateException he)
{
Log.Warn("Cannot rollback underlying transaction", he);
// we're only going to rethrow the first commit exception we receive
if (firstRollbackException == null)
{
firstRollbackException = he;
}
}
}
if (firstRollbackException != null)
{
throw new TransactionException("Rollback failed", firstRollbackException);
}
}
finally
{
DisposeShardTransactions();
transactions.Clear();
}
}
public void SetProxyFactoryFactory(string typeName)
{
System.Type pffc;
try
{
pffc = ReflectHelper.ClassForName(typeName);
}
catch(HibernateException he)
{
throw new HibernateException("Unable to load type '" + typeName + "' during configuration of proxy factory class.",
he);
}
if (typeof(IProxyFactoryFactory).IsAssignableFrom(pffc) == false)
{
HibernateException he =
new HibernateException(pffc.FullName + " does not implement " +
typeof(IProxyFactoryFactory).FullName);
throw he;
}
proxyFactoryFactory = pffc;
}
private void CommitShardTransactions()
{
if (transactions == null)
{
return;
}
HibernateException firstCommitException = null;
foreach (ITransaction t in transactions)
{
try
{
if (t.IsActive)
{
t.Commit();
}
}
catch (HibernateException he)
{
Log.Warn("Exception committing underlying transaction", he);
// we're only going to rethrow the first commit exception we receive
if (firstCommitException == null)
{
firstCommitException = he;
}
}
}
if (firstCommitException != null)
{
throw new TransactionException("Commit failed", firstCommitException);
}
DisposeShardTransactions();
transactions.Clear();
}
private async Task CommitShardTransactionsAsync(CancellationToken cancellationToken)
{
if (transactions == null)
{
return;
}
HibernateException firstCommitException = null;
foreach (ITransaction t in transactions)
{
try
{
if (t.IsActive)
{
await t.CommitAsync(cancellationToken);
}
}
catch (HibernateException he)
{
Log.Warn(he, "Exception committing underlying transaction");
// we're only going to rethrow the first commit exception we receive
if (firstCommitException == null)
{
firstCommitException = he;
}
}
}
if (firstCommitException != null)
{
throw new TransactionException("Commit failed", firstCommitException);
}
DisposeShardTransactions();
transactions.Clear();
}
public void Commit()
{
if (!begun)
{
throw new TransactionException("Transaction not succesfully started");
}
log.Debug("Starting transaction commit");
BeforeTransactionCompletion();
bool commitException = false;
HibernateException firstCommitException = null;
foreach (ITransaction t in transactions)
{
try
{
t.Commit();
}
catch (HibernateException he)
{
log.Warn("exception commiting underlying transaction", he);
commitException = true;
// we're only going to rethrow the first commit exception we receive
if (firstCommitException == null)
{
firstCommitException = he;
}
}
}
if (commitException)
{
commitFailed = true;
//afterTransactionCompletion(Status.STATUS_UNKNOWN);
throw new TransactionException("Commit failed", firstCommitException);
}
//afterTransactionCompletion(Status.STATUS_COMMITTED);
committed = true;
}
public void Rollback()
{
if (!begun && !commitFailed)
{
throw new TransactionException("Transaction not successfully started");
}
bool rollbackException = false;
HibernateException firstRollbackException = null;
foreach (ITransaction t in transactions)
{
if (t.WasCommitted)
{
continue;
}
try
{
t.Rollback();
}
catch (HibernateException he)
{
log.Warn("exception rolling back underlying transaction", he);
rollbackException = true;
if (firstRollbackException == null)
{
firstRollbackException = he;
}
}
}
if (rollbackException)
{
//we're only going to rethrow the first rollback exception
throw new TransactionException("Rollback failed", firstRollbackException);
}
rolledBack = true;
}
/// <summary>
/// Convert the given HibernateException to an appropriate exception from the
/// <code>org.springframework.dao</code> hierarchy. Will automatically detect
/// wrapped ADO.NET Exceptions and convert them accordingly.
/// </summary>
/// <param name="ex">HibernateException that occured.</param>
/// <returns>
/// The corresponding DataAccessException instance
/// </returns>
/// <remarks>
/// The default implementation delegates to SessionFactoryUtils
/// and convertAdoAccessException. Can be overridden in subclasses.
/// </remarks>
protected DataAccessException ConvertHibernateAccessException(HibernateException ex)
{
return(hibernateTemplate.ConvertHibernateAccessException(ex));
}
/// <summary>
/// Initializes a new instance of the <see cref="HibernateSystemException"/> class.
/// </summary>
/// <param name="cause">The cause.</param>
public HibernateSystemException(HibernateException cause) : base(cause != null ? cause.Message : null, cause)
{
}
