/// <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(); }