public override void Commit()
{
base.Commit();
_clientSessionHandle.CommitTransaction();
_clientSessionHandle.Dispose();
_clientSessionHandle = null;
}
public void Commit()
{
if (_transactionCounter == 1)
{
try
{
Transaction.Commit();
_mongoSession.CommitTransaction();
}
catch
{
Transaction.Rollback();
_mongoSession.AbortTransaction();
throw;
}
finally
{
_connection.Close();
Transaction.Dispose();
_mongoSession.Dispose();
}
}
_transactionCounter--;
}
public async void CommitAsync()
{
if (_session == null)
{
throw new Exception("Session has been gone somehow!");
}
await _session.CommitTransactionAsync();
_session.Dispose();
}
public void Commit()
{
try
{
_transactionSession.CommitTransaction();
}
finally
{
_transactionSession.Dispose();
}
}
public void Dispose()
{
if (_clientSessionHandle != null)
{
_clientSessionHandle.Dispose();
}
}
public void Dispose()
{
if (_session != null)
{
_session.Dispose();
}
}
public void EndSession(IClientSessionHandle session)
{
if (!session.IsInTransaction)
{
session.Dispose();
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
session?.Dispose();
}
}
public void Dispose()
{
if (!_disposed)
{
_transactionSession?.Dispose();
_disposed = true;
}
}
public override void Dispose()
{
if (_session?.IsInTransaction == true)
{
_session.AbortTransaction();
}
_session?.Dispose();
base.Dispose();
}
public void Dispose()
{
_session.Dispose();
if (!_isCompleted)
{
_onCompleted(false);
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_transaction?.Dispose();
}
disposedValue = true;
}
}
public virtual void Dispose()
{
transaction = transactionStack.Pop();
transaction.Dispose();
if (transactionStack.Count > 0)
{
transaction = transactionStack.First();
return;
}
}
public async Task ApplyChangesAsync(CancellationToken token = default)
{
if (_operations.Count > 0)
{
IClientSessionHandle session = null;
if (_connection.UseTransactions)
{
session = _connection.StartSession();
session.StartTransaction();
}
try
{
while (_operations.Count > 0)
{
var item = _operations.Dequeue();
await item.ProcessAsync(session, token);
}
if (session != null)
{
await session.CommitTransactionAsync(token);
session.Dispose();
}
_operations.Clear();
}
catch
{
if (session != null)
{
await session.AbortTransactionAsync(token);
session.Dispose();
}
throw;
}
}
}
protected override void Dispose(bool disposing)
{
try
{
session?.Dispose();
}
catch
{
//No need to throw on disposal
}
base.Dispose(disposing);
}
public void Dispose()
{
if (null != session)
{
if (session.IsInTransaction)
{
session.AbortTransaction();
}
session.Dispose();
}
}
protected override void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
_mongoClient = null;
_clientSessionHandle?.Dispose();
_clientSessionHandle = null;
base.Dispose(disposing);
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing && _dispose)
{
_Session.Dispose();
}
_disposed = true;
}
private static async Task CommitOrAbortTx(IClientSessionHandle session, AppendResult result)
{
if (session != null)
{
if (result.HadWrongVersion || string.IsNullOrWhiteSpace(result.CommitId) || result.CurrentVersion <= 0)
{
await session.AbortTransactionAsync();
}
else
{
await session.CommitTransactionAsync();
}
session.Dispose();
}
}
public async Task CommitAsync()
{
_mongoDbSession = await _eventStoreContext.Client.StartSessionAsync();
_mongoDbSession.StartTransaction();
var insertToESTasks = new List <Task>();
foreach (var eventTransaction in _transactions)
{
insertToESTasks.Add(InsertEventsToESAsync(eventTransaction.Value, eventTransaction.Key));
}
await Task.WhenAll(insertToESTasks);
await _mongoDbSession.CommitTransactionAsync();
_mongoDbSession.Dispose();
}
private async Task ExecuteWithClientSession(IMongoCollection <T> collection, IClientSessionHandle session,
Func <IClientSessionHandle, Task> action)
{
var closeSession = false;
if (session == null)
{
session = collection.Database.Client.StartSession();
closeSession = true;
}
try
{
await action(session);
}
finally
{
if (closeSession)
{
session.Dispose();
}
}
}
public async Task <int> SaveChangesAsync()
{
int count = _commands.Count;
CancellationToken token = new CancellationToken();
using (Session = await MongoClient.StartSessionAsync(options: null, cancellationToken: token))
{
Session.StartTransaction();
var commandTasks = _commands.Select(c => c());
await Task.WhenAll(commandTasks);
//await Session.AbortTransactionAsync(token);
await Session.CommitTransactionAsync();
_commands.Clear();
Session.Dispose();
Session = null;
}
return(count);
}
public void Dispose()
{
_clientSessionHandle.Dispose();
}
public void Dispose()
{
_session?.Dispose();
}
public void Dispose()
{
mongoSession.Dispose();
}
public void Execute()
{
_session.Dispose();
}
public async Task HandleAsync(string messageId, Func <Task> handler)
{
if (!Enabled)
{
_logger.LogWarning("Outbox is disabled, incoming messages won't be processed.");
return;
}
if (string.IsNullOrWhiteSpace(messageId))
{
throw new ArgumentException("Message id to be processed cannot be empty.", nameof(messageId));
}
_logger.LogTrace($"Received a message with id: '{messageId}' to be processed.");
if (await _inboxRepository.ExistsAsync(m => m.Id == messageId))
{
_logger.LogTrace($"Message with id: '{messageId}' was already processed.");
return;
}
IClientSessionHandle session = null;
if (_transactionsEnabled)
{
session = await _sessionFactory.CreateAsync();
session.StartTransaction();
}
try
{
_logger.LogTrace($"Processing a message with id: '{messageId}'...");
await handler();
await _inboxRepository.AddAsync(new InboxMessage
{
Id = messageId,
ProcessedAt = DateTime.UtcNow
});
if (session is not null)
{
await session.CommitTransactionAsync();
}
_logger.LogTrace($"Processed a message with id: '{messageId}'.");
}
catch (Exception ex)
{
_logger.LogError(ex, $"There was an error when processing a message with id: '{messageId}'.");
if (session is not null)
{
await session.AbortTransactionAsync();
}
throw;
}
finally
{
session?.Dispose();
}
}
public void Dispose() => _session.Dispose();
public void Dispose()
{
session.Dispose();
}
public void Dispose()
{
_session?.Dispose();
GC.SuppressFinalize(this);
}