/// <summary>
/// Takes care of freeing the managed and unmanaged resources that
/// this class is responsible for.
/// </summary>
/// <param name="isDisposing">Indicates if this AdoTransaction is being Disposed of or Finalized.</param>
/// <remarks>
/// If this AdoTransaction is being Finalized (<c>isDisposing==false</c>) then make sure not
/// to call any methods that could potentially bring this AdoTransaction back to life.
/// </remarks>
protected virtual void Dispose(bool isDisposing)
{
using (SessionIdLoggingContext.CreateOrNull(sessionId))
{
if (_isAlreadyDisposed)
{
// don't dispose of multiple times.
return;
}
_isAlreadyDisposed = true;
// free managed resources that are being managed by the AdoTransaction if we
// know this call came through Dispose()
if (isDisposing)
{
if (trans != null)
{
trans.Dispose();
trans = null;
log.Debug("DbTransaction disposed.");
}
if (IsActive && session != null)
{
// Assume we are rolled back
AfterTransactionCompletion(false);
}
// nothing for Finalizer to do - so tell the GC to ignore it
GC.SuppressFinalize(this);
}
// free unmanaged resources here
}
}
/// <inheritdoc />
public override async Task <IList <T> > ListAsync <T>(CancellationToken cancellationToken = default)
{
using (SessionIdLoggingContext.CreateOrNull(Session.SessionId))
{
return((IList <T>) await ListAsyncImpl <T>(null, cancellationToken));
}
}
public override IEnumerable <T> Enumerable <T>()
{
using (SessionIdLoggingContext.CreateOrNull(Session.SessionId))
{
//implement an interator which keep the id/class for each hit and get the object on demand
//cause I can't keep the searcher and hence the hit opened. I dont have any hook to know when the
//user stop using it
//scrollable is better in this area
//find the directories
IndexSearcher searcher = BuildSearcher();
if (searcher == null)
{
return(new IteratorImpl <T>(new List <EntityInfo>(), noLoader).Iterate());
}
try
{
var infos = ExtractEntityInfos(searcher);
return(new IteratorImpl <T>(infos, GetLoader((ISession)Session)).Iterate());
}
catch (IOException e)
{
throw new HibernateException("Unable to query Lucene index", e);
}
finally
{
CloseSearcher(searcher);
}
}
}
public override IEnumerable Enumerable()
{
using (SessionIdLoggingContext.CreateOrNull(Session.SessionId))
{
return(Enumerable <object>());
}
}
/// <summary>
/// Takes care of freeing the managed and unmanaged resources that
/// this class is responsible for.
/// </summary>
/// <param name="isDisposing">Indicates if this AdoTransaction is being Disposed of or Finalized.</param>
/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
/// <remarks>
/// If this AdoTransaction is being Finalized (<c>isDisposing==false</c>) then make sure not
/// to call any methods that could potentially bring this AdoTransaction back to life.
/// </remarks>
protected virtual async Task DisposeAsync(bool isDisposing, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (SessionIdLoggingContext.CreateOrNull(sessionId))
{
if (_isAlreadyDisposed)
{
// don't dispose of multiple times.
return;
}
_isAlreadyDisposed = true;
// free managed resources that are being managed by the AdoTransaction if we
// know this call came through Dispose()
if (isDisposing)
{
if (trans != null)
{
trans.Dispose();
trans = null;
log.Debug("DbTransaction disposed.");
}
if (IsActive && session != null)
{
// Assume we are rolled back
await(AfterTransactionCompletionAsync(false, cancellationToken)).ConfigureAwait(false);
}
// nothing for Finalizer to do - so tell the GC to ignore it
GC.SuppressFinalize(this);
}
// free unmanaged resources here
}
}
internal static IDisposable BeginContext(this ISessionImplementor session)
{
if (session == null)
{
return(null);
}
return(session is AbstractSessionImpl impl
? impl.BeginContext()
: SessionIdLoggingContext.CreateOrNull(session.SessionId));
}
public void Dispose()
{
_context?.Dispose();
_context = null;
if (_session == null)
{
throw new ObjectDisposedException("The session process helper has been disposed already");
}
_session._processing = false;
_session = null;
}
internal static IDisposable BeginProcess(this ISessionImplementor session)
{
if (session == null)
{
return(null);
}
return(session is AbstractSessionImpl impl
? impl.BeginProcess()
// This method has only replaced bare call to setting the id, so this fallback is enough for avoiding a
// breaking change in case a custom session implementation is used.
: SessionIdLoggingContext.CreateOrNull(session.SessionId));
}
public void Disabled()
{
var guid = Guid.Empty;
using (SessionIdLoggingContext.CreateOrNull(guid))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
using (SessionIdLoggingContext.CreateOrNull(guid))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
/// <summary>
/// Takes care of freeing the managed and unmanaged resources that
/// this class is responsible for.
/// </summary>
/// <param name="isDisposing">Indicates if this AdoTransaction is being Disposed of or Finalized.</param>
/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
/// <remarks>
/// If this AdoTransaction is being Finalized (<c>isDisposing==false</c>) then make sure not
/// to call any methods that could potentially bring this AdoTransaction back to life.
/// </remarks>
protected virtual async Task DisposeAsync(bool isDisposing, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (SessionIdLoggingContext.CreateOrNull(sessionId))
{
if (_isAlreadyDisposed)
{
// don't dispose of multiple times.
return;
}
_isAlreadyDisposed = true;
// free managed resources that are being managed by the AdoTransaction if we
// know this call came through Dispose()
if (isDisposing)
{
try
{
if (trans != null)
{
trans.Dispose();
trans = null;
log.Debug("DbTransaction disposed.");
}
if (IsActive)
{
// Assume we are rolled back
rolledBack = true;
if (session != null)
{
await(AfterTransactionCompletionAsync(false, cancellationToken)).ConfigureAwait(false);
}
}
// nothing for Finalizer to do - so tell the GC to ignore it
GC.SuppressFinalize(this);
}
finally
{
// Do not leave the object in an inconsistent state in case of disposal failure: we should assume
// the DbTransaction is either no more ongoing or unrecoverable.
begun = false;
}
}
// free unmanaged resources here
}
}
public ProcessHelper(AbstractSessionImpl session)
{
_session = session;
_context = new SessionIdLoggingContext(session.SessionId);
try
{
_session.CheckAndUpdateSessionStatus();
_session._processing = true;
}
catch
{
_context.Dispose();
_context = null;
throw;
}
}
public void Enabled()
{
var guid = Guid.NewGuid();
using (SessionIdLoggingContext.CreateOrNull(guid))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid));
var guid2 = Guid.NewGuid();
using (SessionIdLoggingContext.CreateOrNull(guid2))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid2));
}
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid));
}
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
/// <summary>
/// Rolls back the <see cref="ITransaction"/> by calling the method <c>Rollback</c>
/// on the underlying <see cref="DbTransaction"/>.
/// </summary>
/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
/// <exception cref="TransactionException">
/// Thrown if there is any exception while trying to call <c>Rollback()</c> on
/// the underlying <see cref="DbTransaction"/>.
/// </exception>
public async Task RollbackAsync(CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
using (SessionIdLoggingContext.CreateOrNull(sessionId))
{
CheckNotDisposed();
CheckBegun();
CheckNotZombied();
log.Debug("Rollback");
if (!commitFailed)
{
try
{
trans.Rollback();
log.Debug("DbTransaction RolledBack");
rolledBack = true;
Dispose();
}
catch (HibernateException e)
{
log.Error(e, "Rollback failed");
// Don't wrap HibernateExceptions
throw;
}
catch (Exception e)
{
log.Error(e, "Rollback failed");
throw new TransactionException("Rollback failed with SQL Exception", e);
}
finally
{
await(AfterTransactionCompletionAsync(false, cancellationToken)).ConfigureAwait(false);
CloseIfRequired();
}
}
}
}
public async Task DisabledAsync()
{
var guid = Guid.Empty;
using (SessionIdLoggingContext.CreateOrNull(guid))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
await Task.Delay(1).ConfigureAwait(false);
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
using (SessionIdLoggingContext.CreateOrNull(guid))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
await Task.Delay(1).ConfigureAwait(false);
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
/// <summary>
/// Rolls back the <see cref="ITransaction"/> by calling the method <c>Rollback</c>
/// on the underlying <see cref="DbTransaction"/>.
/// </summary>
/// <exception cref="TransactionException">
/// Thrown if there is any exception while trying to call <c>Rollback()</c> on
/// the underlying <see cref="DbTransaction"/>.
/// </exception>
public void Rollback()
{
using (SessionIdLoggingContext.CreateOrNull(sessionId))
{
CheckNotDisposed();
CheckBegun();
CheckNotZombied();
log.Debug("Rollback");
if (!commitFailed)
{
try
{
trans.Rollback();
log.Debug("DbTransaction RolledBack");
rolledBack = true;
Dispose();
}
catch (HibernateException e)
{
log.Error(e, "Rollback failed");
// Don't wrap HibernateExceptions
throw;
}
catch (Exception e)
{
log.Error(e, "Rollback failed");
throw new TransactionException("Rollback failed with SQL Exception", e);
}
finally
{
AfterTransactionCompletion(false);
CloseIfRequired();
}
}
}
}
public async Task EnabledAsync()
{
var guid = Guid.NewGuid();
using (SessionIdLoggingContext.CreateOrNull(guid))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid));
await Task.Delay(1).ConfigureAwait(false);
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid));
var guid2 = Guid.NewGuid();
using (SessionIdLoggingContext.CreateOrNull(guid2))
{
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid2));
await Task.Delay(1).ConfigureAwait(false);
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid2));
}
Assert.That(SessionIdLoggingContext.SessionId, Is.EqualTo(guid));
}
Assert.That(SessionIdLoggingContext.SessionId, Is.Null);
}
