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); }
private Task WriteEventsInTransactionalWay(string stream, int eventCount, Func <int, EventData> createEvent) { Log.Info("Starting to write {0} events to [{1}] (in single transaction)", eventCount, stream); var resSource = new TaskCompletionSource <object>(); var store = GetConnection(); Action <Task> fail = prevTask => { Log.Info("WriteEventsInTransactionalWay for stream {0} failed.", stream); resSource.SetException(prevTask.Exception); }; int writtenCount = 0; EventStoreTransaction transaction = null; Action <Task> writeTransactionEvent = null; writeTransactionEvent = prevTask => { if (writtenCount == eventCount) { var commitTask = transaction.CommitAsync(); commitTask.ContinueWith(fail, TaskContinuationOptions.OnlyOnFaulted); commitTask.ContinueWith(t => { Log.Info("Wrote {0} events to [{1}] (in single transaction)", eventCount, stream); resSource.SetResult(null); }, TaskContinuationOptions.OnlyOnRanToCompletion); return; } var writeTask = transaction.WriteAsync(createEvent(writtenCount)); writtenCount += 1; writeTask.ContinueWith(fail, TaskContinuationOptions.OnlyOnFaulted); writeTask.ContinueWith(writeTransactionEvent, TaskContinuationOptions.OnlyOnRanToCompletion); }; var startTask = store.StartTransactionAsync(stream, -1); startTask.ContinueWith(fail, TaskContinuationOptions.OnlyOnFaulted); startTask.ContinueWith(t => { transaction = t.Result; writeTransactionEvent(t); }, TaskContinuationOptions.OnlyOnRanToCompletion); return(resSource.Task); }
public async Task <OngoingTransaction> Write(params EventData[] events) { await _transaction.WriteAsync(events); return(this); }
public OngoingTransaction Write(params EventData[] events) { _transaction.WriteAsync(events).Wait(); return(this); }
private async Task <long> DoWrite(string stream, IEnumerable <EventData> events, long?expectedVersion = null) { var bucket = Math.Abs(stream.GetHashCode() % _clients.Count()); long nextVersion; using (var ctx = WriteTime.NewContext()) { EventStoreTransaction transaction = null; try { if (events.Count() > _readsize) { transaction = await _clients[bucket].StartTransactionAsync(stream, expectedVersion ?? ExpectedVersion.Any).ConfigureAwait(false); } if (transaction != null) { Logger.Write(LogLevel.Debug, () => $"Using transaction {events.Count()} is over max {_readsize} to write stream id [{stream}]"); var page = 0; while (page < events.Count()) { await transaction.WriteAsync(events.Skip(page).Take(_readsize)).ConfigureAwait(false); page += _readsize; } var result = await transaction.CommitAsync().ConfigureAwait(false); nextVersion = result.NextExpectedVersion; } else { var result = await _clients[bucket].AppendToStreamAsync(stream, expectedVersion ?? ExpectedVersion.Any, events) .ConfigureAwait(false); nextVersion = result.NextExpectedVersion; } } catch (WrongExpectedVersionException e) { transaction?.Rollback(); throw new VersionException($"We expected version {expectedVersion ?? ExpectedVersion.Any}", e); } catch (CannotEstablishConnectionException e) { transaction?.Rollback(); throw new PersistenceException(e.Message, e); } catch (OperationTimedOutException e) { transaction?.Rollback(); throw new PersistenceException(e.Message, e); } catch (EventStoreConnectionException e) { transaction?.Rollback(); throw new PersistenceException(e.Message, e); } WrittenEvents.Update(events.Count()); WrittenEventsSize.Update(events.Sum(x => x.Data.Length)); if (ctx.Elapsed > TimeSpan.FromSeconds(1)) { SlowLogger.Write(LogLevel.Warn, () => $"Writing {events.Count()} events of total size {events.Sum(x => x.Data.Length)} to stream [{stream}] version {expectedVersion} took {ctx.Elapsed.TotalSeconds} seconds!"); } Logger.Write(LogLevel.Debug, () => $"Writing {events.Count()} events of total size {events.Sum(x => x.Data.Length)} to stream [{stream}] version {expectedVersion} took {ctx.Elapsed.TotalMilliseconds} ms"); } return(nextVersion); }