/// <summary>
/// Commits a multi-write transaction in the Event Store
/// </summary>
/// <param name="transaction">The <see cref="EventStoreTransaction"></see> to commit</param>
/// <returns>A <see cref="Task"/> allowing the caller to control the async operation</returns>
internal Task CommitTransactionAsync(EventStoreTransaction transaction)
{
Ensure.NotNull(transaction, "transaction");
EnsureActive();
var source = new TaskCompletionSource<object>();
var operation = new CommitTransactionOperation(source, Guid.NewGuid(), _settings.AllowForwarding, transaction.TransactionId);
EnqueueOperation(operation);
return source.Task;
}
Task<WriteResult> IEventStoreTransactionConnection.CommitTransactionAsync(EventStoreTransaction transaction, UserCredentials userCredentials)
{
Ensure.NotNull(transaction, "transaction");
var source = new TaskCompletionSource<WriteResult>();
EnqueueOperation(new CommitTransactionOperation(_settings.Log, source, _settings.RequireMaster,
transaction.TransactionId, userCredentials));
return source.Task;
}
/// <summary>
/// Writes to a transaction in the event store asynchronously
/// </summary>
/// <remarks>
/// A <see cref="EventStoreTransaction"/> allows the calling of multiple writes with multiple
/// round trips over long periods of time between the caller and the event store. This method
/// is only available through the TCP interface and no equivalent exists for the RESTful interface.
/// </remarks>
/// <param name="transaction">The <see cref="EventStoreTransaction"/> to write to.</param>
/// <param name="events">The events to write</param>
/// <returns>A <see cref="Task"/> allowing the caller to control the async operation</returns>
internal Task TransactionalWriteAsync(EventStoreTransaction transaction, IEnumerable<EventData> events)
{
Ensure.NotNull(transaction, "transaction");
Ensure.NotNull(events, "events");
EnsureActive();
var source = new TaskCompletionSource<object>();
var operation = new TransactionalWriteOperation(source, Guid.NewGuid(), _settings.AllowForwarding, transaction.TransactionId, events);
EnqueueOperation(operation);
return source.Task;
}
public OngoingTransaction(EventStoreTransaction transaction)
{
_transaction = transaction;
}
Task IEventStoreTransactionConnection.TransactionalWriteAsync(EventStoreTransaction transaction, IEnumerable<EventData> events, UserCredentials userCredentials)
{
// ReSharper disable PossibleMultipleEnumeration
Ensure.NotNull(transaction, "transaction");
Ensure.NotNull(events, "events");
var source = new TaskCompletionSource<object>();
EnqueueOperation(new TransactionalWriteOperation(_settings.Log, source, _settings.RequireMaster,
transaction.TransactionId, events, userCredentials));
return source.Task;
// ReSharper restore PossibleMultipleEnumeration
}
public Task TransactionalWriteAsync(EventStoreTransaction transaction, IEnumerable<EventData> events, UserCredentials userCredentials = null)
{
return ((IEventStoreTransactionConnection)_conn).TransactionalWriteAsync(transaction, events, userCredentials);
}
public Task CommitTransactionAsync(EventStoreTransaction transaction, UserCredentials userCredentials = null)
{
return ((IEventStoreTransactionConnection)_conn).CommitTransactionAsync(transaction, userCredentials);
}
private Task<object> CommitTransaction(EventStoreTransaction transaction)
{
var resSource = new TaskCompletionSource<object>();
Action<Task> fail = prevTask =>
{
Log.Info("WriteEventsInTransactionalWay for tran {0} failed", transaction.TransactionId);
resSource.SetException(prevTask.Exception);
};
var commitTask = transaction.CommitAsync();
commitTask.ContinueWith(fail, TaskContinuationOptions.OnlyOnFaulted);
commitTask.ContinueWith(t =>
{
Log.Info("Committed tran {0}", transaction.TransactionId);
resSource.SetResult(null);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
return resSource.Task;
}
private Task<object> WriteTransactionData(EventStoreTransaction transaction, int startingVersion, int eventCount, Func<int, EventData> createEvent)
{
Log.Info("Starting to write {0} events in tran {1}", eventCount, transaction.TransactionId);
var resSource = new TaskCompletionSource<object>();
Action<Task> fail = prevTask =>
{
Log.Info("WriteEventsInTransactionalWay for transaction {0} failed.", transaction.TransactionId);
resSource.SetException(prevTask.Exception);
};
int version = startingVersion;
Action<Task> writeTransactionEvent = null;
writeTransactionEvent = _ =>
{
if (version == startingVersion + eventCount)
{
resSource.SetResult(null);
return;
}
version += 1;
var writeTask = transaction.WriteAsync(new[] { createEvent(version) });
writeTask.ContinueWith(fail, TaskContinuationOptions.OnlyOnFaulted);
writeTask.ContinueWith(writeTransactionEvent, TaskContinuationOptions.OnlyOnRanToCompletion);
};
Task.Factory.StartNew(() => writeTransactionEvent(null));
return resSource.Task;
}
public Task CommitTransactionAsync(EventStoreTransaction transaction, UserCredentials userCredentials = null)
{
return(((IEventStoreTransactionConnection)_conn).CommitTransactionAsync(transaction, userCredentials));
}
public Task TransactionalWriteAsync(EventStoreTransaction transaction, IEnumerable <EventData> events, UserCredentials userCredentials = null)
{
return(((IEventStoreTransactionConnection)_conn).TransactionalWriteAsync(transaction, events, userCredentials));
}
public static void Write(this EventStoreTransaction tx, IEnumerable <EventData> events)
{
var task = tx.WriteAsync(events);
task.Wait();
}
