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