public IObservable <ICommit> ReadStream(string stream, int minRevision, int maxRevision) { Guard.AgainstNull(stream, "stream"); minRevision = Math.Max(minRevision, 0); Guard.Against <ArgumentOutOfRangeException>(maxRevision < minRevision, "maxRevision"); const int batchSize = 512; int start = 0; return(Observable.Create <ICommit>(async observer => { bool isEndOfStream; do { StreamEventsSlice slice = await _connection.ReadStreamEventsForwardAsync(stream, start, batchSize, true); var commits = (from resolved in slice.Events where false == IsSystemEvent(resolved) let dto = DeserializeEvent(resolved) where SingleStreamIsInRange(dto, minRevision, maxRevision) let commit = BuildCommit(dto, resolved) select commit).ToList(); commits.ForEach(observer.OnNext); start += batchSize; isEndOfStream = slice.IsEndOfStream || commits.Any(commit => commit.StreamRevision > maxRevision); } while (false == isEndOfStream); observer.OnCompleted(); })); }
/// <summary> /// Attempts to get the aggregate root entity associated with the aggregate identifier. /// </summary> /// <param name="identifier">The aggregate identifier.</param> /// <returns>The found <typeparamref name="TAggregateRoot"/>, or empty if not found.</returns> public async Task <Optional <TAggregateRoot> > GetOptionalAsync(string identifier) { Aggregate aggregate; if (_unitOfWork.TryGet(identifier, out aggregate)) { return(new Optional <TAggregateRoot>((TAggregateRoot)aggregate.Root)); } var streamUserCredentials = _configuration.StreamUserCredentialsResolver.Resolve(identifier); var streamName = _configuration.StreamNameResolver.Resolve(identifier); var slice = await _connection.ReadStreamEventsForwardAsync(streamName, StreamPosition.Start, _configuration.SliceSize, false, streamUserCredentials); if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound) { return(Optional <TAggregateRoot> .Empty); } var root = _rootFactory(); root.Initialize(slice.Events.Select(resolved => _configuration.Deserializer.Deserialize(resolved))); while (!slice.IsEndOfStream) { slice = await _connection.ReadStreamEventsForwardAsync(streamName, slice.NextEventNumber, _configuration.SliceSize, false, streamUserCredentials); root.Initialize(slice.Events.Select(resolved => _configuration.Deserializer.Deserialize(resolved))); } aggregate = new Aggregate(identifier, slice.LastEventNumber, root); _unitOfWork.Attach(aggregate); return(new Optional <TAggregateRoot>(root)); }
public static async Task <EventsData> ReadEvents(this IEventStoreConnection connection, string streamName, int sliceSize, Assembly assembly) { var slice = await connection.ReadStreamEventsForwardAsync(streamName, StreamPosition.Start, sliceSize, false); if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound) { return(null); } var assemblyName = assembly.GetName().Name; var lastEventNumber = slice.LastEventNumber; var events = new List <object>(); events.AddRange(slice.Events.SelectMany(x => JsonSerialisation.Deserialize(x, assemblyName))); while (!slice.IsEndOfStream) { slice = await connection.ReadStreamEventsForwardAsync(streamName, slice.NextEventNumber, sliceSize, false); events.AddRange(slice.Events.SelectMany(x => JsonSerialisation.Deserialize(x, assemblyName))); lastEventNumber = slice.LastEventNumber; } var tuple = new EventsData(events, lastEventNumber); return(tuple); }
public override async Task <TAggregate> GetById <TAggregate>( string bucketId, string id, int version, CancellationToken _) { var streamId = id.FormatStreamIdWithBucket(bucketId); var slice = await _connection.ReadStreamEventsForwardAsync(streamId, StreamPosition.Start, PageSize, false).NotOnCapturedContext(); if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound) { return(default(TAggregate)); } var aggregate = CreateAggregate <TAggregate>(id); ApplySlice(version, slice, aggregate); while (!slice.IsEndOfStream) { slice = await _connection.ReadStreamEventsForwardAsync(streamId, slice.NextEventNumber, PageSize, false).NotOnCapturedContext(); ApplySlice(version, slice, aggregate); } return(aggregate); }
public static List <string> GetData(this IEventStoreConnection connection) { try { List <string> result = new List <string>(); var readEvents = connection.ReadStreamEventsForwardAsync("$streams", 0, 100, true).Result; var lastEvent = readEvents.NextEventNumber; readEvents = connection.ReadStreamEventsForwardAsync("$streams", 0, (int)lastEvent + 1, true).Result; foreach (var e in readEvents.Events) { if (e.Event != null) { if (e.Event.EventStreamId.StartsWith("acc-")) { result.Add(e.Event.EventStreamId); } } } return(result); } catch (Exception ex) { throw; } }
public async Task <Portfolio> Get(string username) { var streamName = GetStreamName(username); var snapshot = await GetSnapshot(username); var portfolio = new Portfolio(username, snapshot.State); StreamEventsSlice currentSlice; var nextSliceStart = snapshot.Version + 1; do { currentSlice = await _connection.ReadStreamEventsForwardAsync( streamName, nextSliceStart, 200, false ); nextSliceStart = currentSlice.NextEventNumber; foreach (var evnt in currentSlice.Events) { var evntObj = DeserializeEvent(evnt); portfolio.ApplyEvent(evntObj, true); } } while (!currentSlice.IsEndOfStream); return(portfolio); }
/// <summary> /// Returns multiple events from a given stream. /// If all the events do not exist, as many as can be found will be returned. /// </summary> /// <param name="stream">The stream name.</param> /// <param name="fromEventNumber">The event number to start from (inclusive).</param> /// <param name="numberOfEvents">The number of events to return.</param> /// <returns></returns> public IList <Message> Get(string stream, int fromEventNumber, int numberOfEvents) { var eventStreamSlice = _eventStore .ReadStreamEventsForwardAsync(stream, fromEventNumber, numberOfEvents, true).Result; return(eventStreamSlice.Events.Select(e => ConvertEventToMessage(e.Event, stream)).ToList()); }
public async Task GetEventsAsync(Func <StoredEvent, Task> callback, string streamFilter = null, string position = null, CancellationToken cancellationToken = default(CancellationToken)) { var streamName = await connection.CreateProjectionAsync(projectionsManager, prefix, streamFilter); var sliceStart = ProjectionHelper.ParsePosition(position); StreamEventsSlice currentSlice; do { currentSlice = await connection.ReadStreamEventsForwardAsync(streamName, sliceStart, ReadPageSize, true); if (currentSlice.Status == SliceReadStatus.Success) { sliceStart = currentSlice.NextEventNumber; foreach (var resolved in currentSlice.Events) { var storedEvent = Formatter.Read(resolved); await callback(storedEvent); } } }while (!currentSlice.IsEndOfStream && !cancellationToken.IsCancellationRequested); }
public async Task <IEnumerable <EventModel> > ReadStreamEventsForwardAsync(string streamName) { var records = await eventStoreConnection.ReadStreamEventsForwardAsync(streamName, 0, PageSize, false, CredentialsHelper.Default); return(records.Events.Select(@event => @event.Event.ParseEvent()).ToList()); }
public async Task <IEnumerable <IEventData> > Read(string streamId, long start = 0, IUserCredentials userCredentials = null) { var userCreds = userCredentials == null ? null : new global::EventStore.ClientAPI.SystemData.UserCredentials(userCredentials.Username, userCredentials.Password); var result = await _connection.ReadStreamEventsForwardAsync(streamId, start, _batchSize, true, userCreds); return(result.Events.Select(FromDb)); }
public async Task read_stream_forward_respects_max_count() { var res = await _connection.ReadStreamEventsForwardAsync(Stream, 0, 100, false); Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(3, res.Events.Length); Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(), res.Events.Select(x => x.Event.EventId).ToArray()); }
public TAggregate GetById <TAggregate>(Guid id, int version) where TAggregate : class, IEventSource { if (version <= 0) { throw new InvalidOperationException("Cannot get version <= 0"); } var streamName = _aggregateIdToStreamName(typeof(TAggregate), id); var aggregate = ConstructAggregate <TAggregate>(); long sliceStart = 0; StreamEventsSlice currentSlice; var appliedEventCount = 0; do { long sliceCount = sliceStart + ReadPageSize <= version ? ReadPageSize : version - sliceStart; //todo: why does this need an int with v 4.0 of eventstore? currentSlice = _eventStoreConnection.ReadStreamEventsForwardAsync(streamName, sliceStart, (int)sliceCount, false).Result; if (currentSlice.Status == SliceReadStatus.StreamNotFound) { throw new AggregateNotFoundException(id, typeof(TAggregate)); } if (currentSlice.Status == SliceReadStatus.StreamDeleted) { throw new AggregateDeletedException(id, typeof(TAggregate)); } sliceStart = currentSlice.NextEventNumber; foreach (var evnt in currentSlice.Events) { appliedEventCount++; aggregate.RestoreFromEvent(DeserializeEvent(evnt.OriginalEvent.Metadata, evnt.OriginalEvent.Data)); } } while (version > currentSlice.NextEventNumber && !currentSlice.IsEndOfStream); if (version != Int32.MaxValue && version != appliedEventCount) { throw new AggregateVersionException(id, typeof(TAggregate), version, aggregate.ExpectedVersion); } if (version != Int32.MaxValue && aggregate.ExpectedVersion != version - 1) { throw new AggregateVersionException(id, typeof(TAggregate), version, aggregate.ExpectedVersion); } return(aggregate); }
public void following_append_with_correct_expected_version_are_commited_correctly() { Assert.AreEqual(4, _connection.AppendToStreamAsync(_stream, 2, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); var res = _connection.ReadStreamEventsForwardAsync(_stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(5, res.Events.Length); for (int i = 0; i < 5; ++i) { Assert.AreEqual(i, res.Events[i].OriginalEventNumber); } }
public override bool Exists <TResult>(string id) { try { var streamName = AggregateToStreamName(typeof(TResult), id); var currentSlice = _connection.ReadStreamEventsForwardAsync(streamName, 1, 1, false).Result; return(currentSlice.Status != SliceReadStatus.StreamNotFound); } catch (System.Exception ex) { throw new RepositoryException("Unable to retrieve from eventStore", ex); } }
protected new async Task <IEnumerable <TEventBase> > RetrieveConfirmedEvents(int fromVersion, int toVersion) { var resolvedEvents = new List <TEventBase>(); var allEventsSlice = await _eventStoreConnection.ReadStreamEventsForwardAsync(GetStreamName(), fromVersion, toVersion, false); foreach (var resolvedEvent in allEventsSlice.Events) { resolvedEvents.Add(DeserializeEvent(resolvedEvent.Event) as TEventBase); } return(resolvedEvents); }
public async Task <TAggregateRoot> FindAsync(params object[] keyValues) { var existingAggregate = _unitOfworkAsync.AttachedObject(keyValues[0].ToString()); if (existingAggregate != null) { return((TAggregateRoot)(((Aggregate)existingAggregate).Root)); } var streamName = StreamExtensions.GetStreamName(typeof(TAggregateRoot), keyValues[0].ToString()); var version = StreamPosition.Start; StreamEventsSlice slice = await _connection.ReadStreamEventsForwardAsync(streamName, version, 100, false); if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound) { throw new AggregateNotFoundException($"Aggregate not found by {streamName}"); } TAggregateRoot root = (TAggregateRoot)Activator.CreateInstance(typeof(TAggregateRoot), true); slice.Events.ToList().ForEach(e => { var resolvedEvent = this._serializer.Deserialize(Type.GetType(e.Event.EventType, true), Encoding.UTF8.GetString(e.Event.Data)); (root as IEntity).ApplyEvent(resolvedEvent); }); while (!slice.IsEndOfStream) { slice = await _connection.ReadStreamEventsForwardAsync(streamName, slice.NextEventNumber, 100, false); slice.Events.ToList().ForEach(e => { var resolvedEvent = this._serializer.Deserialize(Type.GetType(e.Event.EventType, true), Encoding.UTF8.GetString(e.Event.Data)); (root as IEntity).ApplyEvent(resolvedEvent); }); } (root as IEntity).ClearEvents(); var aggregate = new Aggregate(keyValues[0].ToString(), (int)slice.LastEventNumber, root); this._unitOfworkAsync.Attach(aggregate); return(root); }
/// <summary> /// Attempts to get the aggregate root entity associated with the aggregate identifier. /// </summary> /// <param name="identifier">The aggregate identifier.</param> /// <returns>The found <typeparamref name="TAggregateRoot" />, or empty if not found.</returns> public async Task <Optional <TAggregateRoot> > GetOptionalAsync(string identifier) { if (_unitOfWork.TryGet(identifier, out Aggregate aggregate)) { return(new Optional <TAggregateRoot>((TAggregateRoot)aggregate.Root)); } Optional <Snapshot> snapshot = await _reader.ReadOptionalAsync(identifier); var version = StreamPosition.Start; if (snapshot.HasValue) { version = snapshot.Value.Version + 1; } UserCredentials streamUserCredentials = _configuration.StreamUserCredentialsResolver.Resolve(identifier); string streamName = _configuration.StreamNameResolver.Resolve(identifier); StreamEventsSlice slice = await _connection.ReadStreamEventsForwardAsync(streamName, version, _configuration.SliceSize, false, streamUserCredentials); if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound) { return(Optional <TAggregateRoot> .Empty); } TAggregateRoot root = _rootFactory(); if (snapshot.HasValue) { root.RestoreSnapshot(snapshot.Value.State); } root.Initialize(slice.Events.Select(resolved => _configuration.Deserializer.Deserialize(resolved))); while (!slice.IsEndOfStream) { slice = await _connection.ReadStreamEventsForwardAsync(streamName, slice.NextEventNumber, _configuration.SliceSize, false, streamUserCredentials); root.Initialize(slice.Events.Select(resolved => _configuration.Deserializer.Deserialize(resolved))); } aggregate = new Aggregate(identifier, (int)slice.LastEventNumber, root); _unitOfWork.Attach(aggregate); return(new Optional <TAggregateRoot>(root)); }
public async Task <IList <Message> > GetAsync( int pageSize = 100, int pageNumber = 1, Dictionary <string, object> args = null, CancellationToken cancellationToken = default) { string stream = GetStreamFromArgs(args); var fromEventNumber = pageSize * (pageNumber - 1); var eventStreamSlice = await _eventStore.ReadStreamEventsForwardAsync(stream, fromEventNumber, pageSize, true); return(eventStreamSlice.Events.Select(e => EventStoreMessageReader.ConvertEventToMessage(e.Event, stream)).ToList()); }
private async Task <long> Dispatch <TProjection, TState>(string streamId, long version, Dictionary <string, TState> result) where TProjection : ProjectionBase <TProjection, TState>, new() where TState : new() { StreamEventsSlice eventsSlice; var p = new TProjection(); do { eventsSlice = await _connection.ReadStreamEventsForwardAsync(streamId, version, _configuration.SnapchotLimit, false).ConfigureAwait(false); var events = eventsSlice.Events.Select(e => EventSerializer.Deserialize(e.Event.Data, new Guid(e.Event.EventType))); foreach (var @event in events) { var type = @event.GetType(); var attr = type.GetCustomAttribute <EventTypeIdAttribute>(); if (attr == null) { throw new ArgumentException($"Mark e '{type.FullName}' with {nameof(EventTypeIdAttribute)}"); } var id = attr.Id; var dispatchedEvent = new DispatchedEvent { Event = @event, Metadata = new Metadata { EventId = Guid.NewGuid(), EventTypeId = id, StreamId = streamId } }; var partition = p.GetPartitioningKey(dispatchedEvent); if (string.IsNullOrWhiteSpace(partition) == false) { if (result.TryGetValue(partition, out var state) == false) { result[partition] = state = new TState(); } await p.Dispatch(dispatchedEvent, state).ConfigureAwait(false); } version++; } } while (!eventsSlice.IsEndOfStream); return(version); }
public override TResult GetById <TResult>(string id, int eventsToLoad) { var streamName = AggregateToStreamName(typeof(TResult), id); var eventsSlice = _connection.ReadStreamEventsForwardAsync(streamName, 0, eventsToLoad, false); if (eventsSlice.Result.Status == SliceReadStatus.StreamNotFound) { throw new AggregateNotFoundException("Could not found aggregate of type " + typeof(TResult) + " and id " + id); } var deserializedEvents = eventsSlice.Result.Events.Select(e => SerializationUtils.DeserializeObject(e.OriginalEvent.Data, e.OriginalEvent.Metadata) as Event); return(BuildAggregate <TResult>(deserializedEvents)); }
public async Task <T> LoadAsync <T>(Guid aggregateId) where T : Aggregate, new() { if (aggregateId == Guid.Empty) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(aggregateId)); } var aggregate = new T(); var streamName = GetStreamName(aggregate, aggregateId); var nextPageStart = 0L; do { var page = await _eventStore.ReadStreamEventsForwardAsync( streamName, nextPageStart, 4096, false); if (page.Events.Length > 0) { aggregate.Load( page.Events.Last().Event.EventNumber, page.Events.Select(@event => JsonSerializer.Deserialize(Encoding.UTF8.GetString(@event.OriginalEvent.Data), Type.GetType(Encoding.UTF8.GetString(@event.OriginalEvent.Metadata))) ).ToArray()); } nextPageStart = !page.IsEndOfStream ? page.NextEventNumber : -1; } while (nextPageStart != -1); return(aggregate); }
protected async Task <IEnumerable <IEvent> > ReadEvents(Type aggregateType, IEventStoreConnection connection, Guid aggregateId, int start, int count) { var events = new List <IEvent>(); var streamEvents = new List <ResolvedEvent>(); StreamEventsSlice currentSlice; var nextSliceStart = start < 0 ? StreamPosition.Start : start; //Read the stream using pagesize which was set before. //We only need to read the full page ahead if expected results are larger than the page size do { int nextReadCount = count - streamEvents.Count(); if (nextReadCount > EventStorePageSize) { nextReadCount = EventStorePageSize; } currentSlice = await connection.ReadStreamEventsForwardAsync( $"{AggregateIdToStreamName(aggregateType, aggregateId)}", nextSliceStart, nextReadCount, false); nextSliceStart = currentSlice.NextEventNumber; streamEvents.AddRange(currentSlice.Events); } while (!currentSlice.IsEndOfStream); //Deserialize and add to events list foreach (var returnedEvent in streamEvents) { events.Add(DeserializeEvent(returnedEvent)); } return(events); }
public async Task <IEnumerable <PersistentEvent <TAggregateId> > > ReadEventsAsync <TAggregateId>(TAggregateId id) where TAggregateId : IAggregateId { try { var ret = new List <PersistentEvent <TAggregateId> >(); StreamEventsSlice currentSlice; long nextSliceStart = StreamPosition.Start; do { currentSlice = await connection.ReadStreamEventsForwardAsync(id.IdAsString(), nextSliceStart, 200, false); if (currentSlice.Status != SliceReadStatus.Success) { throw new EventStoreAggregateNotFoundException($"Aggregate {id.IdAsString()} not found"); } nextSliceStart = currentSlice.NextEventNumber; foreach (var resolvedEvent in currentSlice.Events) { ret.Add(new PersistentEvent <TAggregateId>(Deserialize <TAggregateId>(resolvedEvent.Event.EventType, resolvedEvent.Event.Data), resolvedEvent.Event.EventNumber)); } } while (!currentSlice.IsEndOfStream); return(ret); } catch (EventStoreConnectionException ex) { throw new EventStoreCommunicationException($"Error while reading events for aggregate {id}", ex); } }
public void SavesCommitHeadersOnEachEvent() { var commitId = Guid.NewGuid(); var aggregateToSave = new TestWoftamAggregate(Guid.NewGuid()); aggregateToSave.ProduceEvents(20); _repo.Save(aggregateToSave, commitId, d => { d.Add("CustomHeader1", "CustomValue1"); d.Add("CustomHeader2", "CustomValue2"); }); var read = _connection.ReadStreamEventsForwardAsync($"aggregate-{aggregateToSave.Id}", 1, 20, false).Result; foreach (var serializedEvent in read.Events) { var parsedMetadata = JObject.Parse(Encoding.UTF8.GetString(serializedEvent.OriginalEvent.Metadata)); var deserializedCommitId = parsedMetadata.Property("CommitId").Value.ToObject <Guid>(); Assert.Equal(commitId, deserializedCommitId); var deserializedCustomHeader1 = parsedMetadata.Property("CustomHeader1").Value.ToObject <string>(); Assert.Equal("CustomValue1", deserializedCustomHeader1); var deserializedCustomHeader2 = parsedMetadata.Property("CustomHeader2").Value.ToObject <string>(); Assert.Equal("CustomValue2", deserializedCustomHeader2); } }
/// <summary> /// Loads and returns an aggregate by id, from the store. /// </summary> public async Task <T> Load <T>(string aggregateId, CancellationToken cancellationToken = default) where T : Aggregate, new() { if (IsNullOrWhiteSpace(aggregateId)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(aggregateId)); } var stream = _getStreamName(typeof(T), aggregateId); var aggregate = new T(); var nextPageStart = 0L; do { var page = await _connection.ReadStreamEventsForwardAsync( stream, nextPageStart, MaxReadSize, false, _userCredentials); aggregate.Load(page.Events.Select(resolvedEvent => { var dataType = _typeMapper.GetType(resolvedEvent.Event.EventType); var data = _serializer.Deserialize(resolvedEvent.Event.Data, dataType); return(data); }).ToArray()); nextPageStart = !page.IsEndOfStream ? page.NextEventNumber : -1; } while (nextPageStart != -1); Log.Debug("Loaded {aggregate} changes from stream {stream}", aggregate, stream); return(aggregate); }
public async Task <T> Load <T, TId>(string aggregateId) where T : Aggregate <TId>, new() { if (IsNullOrWhiteSpace(aggregateId)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(aggregateId)); } var stream = GetStreamName <T>(aggregateId); var aggregate = new T(); var page = await _connection.ReadStreamEventsForwardAsync( stream, 0, int.MaxValue, false); aggregate.Load(page.Events.Select(resolvedEvent => { var dataType = Type.GetType(resolvedEvent.Event.EventType); var jsonData = Encoding.UTF8.GetString(resolvedEvent.Event.Data); var data = JsonConvert.DeserializeObject(jsonData, dataType); return(data); }).ToArray()); return(aggregate); }
public async Task <IReadOnlyCollection <ICommittedDomainEvent> > LoadCommittedEventsAsync( IIdentity id, int fromEventSequenceNumber, CancellationToken cancellationToken) { var streamEvents = new List <ResolvedEvent>(); StreamEventsSlice currentSlice; var nextSliceStart = fromEventSequenceNumber <= 1 ? StreamPosition.Start : fromEventSequenceNumber - 1; // Starts from zero do { currentSlice = await _connection.ReadStreamEventsForwardAsync( id.Value, nextSliceStart, 200, false) .ConfigureAwait(false); nextSliceStart = (int)currentSlice.NextEventNumber; streamEvents.AddRange(currentSlice.Events); }while (!currentSlice.IsEndOfStream); return(Map(streamEvents)); }
public async Task <IEnumerable <object> > GetEventStream <TAggregate>(Guid id) where TAggregate : IAggregate, new() { var streamName = StreamName($"{typeof(TAggregate).Name }-{id}"); var eventNumber = 0; StreamEventsSlice currentSlice; var eventStream = new List <object>(); do { currentSlice = await _eventStoreConnection.ReadStreamEventsForwardAsync(streamName, eventNumber, ReadPageSize, false); if (currentSlice.Status == SliceReadStatus.StreamNotFound) { throw new AggregateNotFoundException(id, typeof(TAggregate)); } if (currentSlice.Status == SliceReadStatus.StreamDeleted) { throw new AggregateDeletedException(id, typeof(TAggregate)); } eventNumber = (int)currentSlice.NextEventNumber; foreach (var resolvedEvent in currentSlice.Events) { eventStream.Add(_eventDeserializer.Deserialize(resolvedEvent.Event)); } } while (!currentSlice.IsEndOfStream); return(eventStream); }
public async Task <IEnumerable <IEvent> > GetStream([NotNull] string streamId) { if (!IsConnected) { throw new InvalidOperationException("not connected"); } StreamEventsSlice currentSlice; var result = new List <IEvent>(); do { currentSlice = await _eventStoreConnection.ReadStreamEventsForwardAsync(streamId, StreamPosition.Start, _eventStoreRepositoryConfiguration.ReadPageSize, false); if (currentSlice.Status == SliceReadStatus.StreamNotFound || currentSlice.Status == SliceReadStatus.StreamDeleted) { break; } foreach (var resolvedEvent in currentSlice.Events) { var @event = DeserializeEvent(resolvedEvent.Event); result.Add(@event); } } while (!currentSlice.IsEndOfStream); return(result); }
public List <IEvent> GetAllEvents(CompositeAggregateId aggregateId) { var eventList = new List <IEvent>(); long sliceStart = 0; StreamEventsSlice currentEventSlice; do { currentEventSlice = _eventStoreConnection.ReadStreamEventsForwardAsync(aggregateId.CompositeId, sliceStart, 500, false).Result; if (currentEventSlice.Status == SliceReadStatus.StreamNotFound) { throw new StreamNotFoundException(aggregateId.CompositeId); } if (currentEventSlice.Status == SliceReadStatus.StreamDeleted) { throw new StreamDeletedException(aggregateId.CompositeId); } sliceStart = currentEventSlice.NextEventNumber; eventList.AddRange(currentEventSlice.Events.Select(data => data.Event.DeserializeEvent()).Where(@event => @event != null)); } while (!currentEventSlice.IsEndOfStream); return(eventList); }
public static int Count(IEventStoreConnection store, string stream) { var result = 0; while (true) { var slice = store.ReadStreamEventsForwardAsync(stream, result, SliceSize, false).Result; result += slice.Events.Length; if (slice.IsEndOfStream) break; } return result; }
internal static BatterAggregate LoadEvents(IEventStoreConnection conn, String streamId) { var player = new BatterAggregate(); var slice = conn.ReadStreamEventsForwardAsync(streamId, StreamPosition.Start, 200, false).Result; var events = slice.Events.Select(e => JsonConvert.DeserializeObject(Encoding.UTF8.GetString(e.Event.Data), typeof(PlayerWasAtBat)) as EventBase); player.LoadFromHistory(events); return player; }
/// <summary> /// Read events until the given event number async. /// </summary> /// <param name="connection">The connection.</param> /// <param name="resolveLinkTos">Whether to resolve Link events.</param> /// <param name="userCredentials">User credentials for the operation.</param> /// <param name="lastCommitPosition">The commit position to read until.</param> /// <param name="lastEventNumber">The event number to read until.</param> /// <returns></returns> protected override Task ReadEventsTillAsync(IEventStoreConnection connection, bool resolveLinkTos, UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber) { return connection.ReadStreamEventsForwardAsync(StreamId, _nextReadEventNumber, ReadBatchSize, resolveLinkTos,userCredentials) .ContinueWith(_ => { if (_.IsFaulted || _.IsCanceled) { _.Wait(); //force exception to be thrown } if (!ProcessEvents(lastEventNumber, _.Result) && !ShouldStop) { ReadEventsTillAsync(connection, resolveLinkTos, userCredentials, lastCommitPosition, lastEventNumber); } else if (Verbose) { Log.Debug("Catch-up Subscription to {0}: finished reading events, nextReadEventNumber = {1}.", IsSubscribedToAll ? "<all>" : StreamId, _nextReadEventNumber); } }, TaskContinuationOptions.AttachedToParent); }
/// <summary> /// Read events until the given event number. /// </summary> /// <param name="connection">The connection.</param> /// <param name="resolveLinkTos">Whether to resolve Link events.</param> /// <param name="userCredentials">User credentials for the operation.</param> /// <param name="lastCommitPosition">The commit position to read until.</param> /// <param name="lastEventNumber">The event number to read until.</param> protected override void ReadEventsTill(IEventStoreConnection connection, bool resolveLinkTos, UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber) { bool done; do { var slice = connection.ReadStreamEventsForwardAsync(StreamId, _nextReadEventNumber, ReadBatchSize, resolveLinkTos, userCredentials).Result; switch (slice.Status) { case SliceReadStatus.Success: { foreach (var e in slice.Events) { TryProcess(e); } _nextReadEventNumber = slice.NextEventNumber; done = lastEventNumber == null ? slice.IsEndOfStream : slice.NextEventNumber > lastEventNumber; break; } case SliceReadStatus.StreamNotFound: { if (lastEventNumber.HasValue && lastEventNumber != -1) throw new Exception(string.Format("Impossible: stream {0} disappeared in the middle of catching up subscription.", StreamId)); done = true; break; } case SliceReadStatus.StreamDeleted: throw new StreamDeletedException(StreamId); default: throw new ArgumentOutOfRangeException(string.Format("Unexpected StreamEventsSlice.Status: {0}.", slice.Status)); } if (!done && slice.IsEndOfStream) Thread.Sleep(1); // we are waiting for server to flush its data } while (!done && !ShouldStop); if (Verbose) Log.Debug("Catch-up Subscription to {0}: finished reading events, nextReadEventNumber = {1}.", IsSubscribedToAll ? "<all>" : StreamId, _nextReadEventNumber); }
private void ReadEventsInternal(IEventStoreConnection connection, bool resolveLinkTos, UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber) { try { connection.ReadStreamEventsForwardAsync(StreamId, _nextReadEventNumber, ReadBatchSize, resolveLinkTos, userCredentials) .ContinueWith(_ => { ReadEventsCallback(_, connection, resolveLinkTos, userCredentials, lastCommitPosition, lastEventNumber); }); } catch(Exception ex) { _completion.SetException(ex); } }
private static void ReadStreamEventsForward(IEventStoreConnection connection) { StreamEventsSlice slice = connection.ReadStreamEventsForwardAsync("test-stream", StreamPosition.Start, 10, false).Result; if (slice.Events.Length > 0) { Console.WriteLine("id: " + slice.Events[0].Event.EventId); string data = Encoding.UTF8.GetString(slice.Events[0].Event.Data); Console.WriteLine("data: " + data); string metadata = Encoding.UTF8.GetString(slice.Events[0].Event.Metadata); Console.WriteLine("metadata: " + metadata); } }