public async Task <StreamWriteResult> SaveEvents(EventStreamId eventStreamId, long streamVersion, List <IDomainEvent> events)
{
if (events.Any() == false)
{
return(new StreamWriteResult(-1));
}
var commitId = Guid.NewGuid();
var expectedVersion = (int)streamVersion == 0 ? ExpectedVersion.NoStream : (int)streamVersion - 1;
var streamMessagesToAppend = new List <NewStreamMessage>();
foreach (var domainEvent in events)
{
streamMessagesToAppend.Add(ToNewStreamMessage(commitId, domainEvent));
}
try
{
var result = await _streamStore.AppendToStream(
new StreamId(eventStreamId.StreamName),
expectedVersion,
streamMessagesToAppend.ToArray());
return(new StreamWriteResult(result.CurrentPosition));
}
catch (WrongExpectedVersionException e)
{
Console.WriteLine(e);
throw;
}
}
protected async ValueTask ConsumeAsync(
IEvent evt,
object projection,
CancellationToken cancellationToken)
{
if (!CanConsumeEvent(evt))
{
return;
}
var metadata = new EventMetadata(
evt.Metadata.EventId,
EventStreamId.FromStreamId(evt.Metadata.StreamId),
evt.Metadata.Timestamp,
(long)evt.Metadata.Version,
CorrelationId: evt.Metadata.CorrelationId,
CausationId: evt.Metadata.CausationId);
var response = consumeEvents[evt.Data.GetType()]
.Invoke(null, new object[] { projection, evt.Data, metadata, cancellationToken });
if (response is ValueTask v)
{
await v.ConfigureAwait(false);
}
}
public IEventStream OpenStream(EventStreamId streamId)
{
if (!streams.ContainsKey(streamId))
{
streams.Add(streamId, new InMemoryEventStream(streamId, GetEvents(streamId), Commit));
}
return(streams[streamId]);
}
public InMemoryEventStream(EventStreamId streamId, List <SourcedEvent> committedEvents, Action <Commit> addCommit)
{
this.streamId = streamId;
this.committedEvents = committedEvents;
this.addCommit = addCommit;
uncommittedEvents = new List <SourcedEvent>();
uncommittedHeaders = new Dictionary <string, object>();
}
public IEnumerable <SourcedEvent> GetEvents(EventStreamId streamId)
{
NEventStore.IEventStream stream = GetStream(streamId);
return(stream.CommittedEvents
.Select(e => e.CreateSourcedEvent())
.Concat(stream.UncommittedEvents
.Select(e => e.CreateSourcedEvent())));
}
NEventStore.IEventStream GetStream(EventStreamId streamId)
{
NEventStore.IEventStream stream;
if (!streams.TryGetValue(streamId, out stream))
{
streams[streamId] = stream = eventStore.OpenStream(streamId.BucketId, streamId.Id, 0, int.MaxValue);
}
return(stream);
}
public void StoreEvent(SourcedEvent @event, EventStreamId aggregateRootId)
{
var uncommittedEvent = new EventMessage
{
Body = @event.Body
};
@event.Headers.ForEach(h => uncommittedEvent.Headers.Add(h.Key, h.Value));
GetStream(aggregateRootId).Add(uncommittedEvent);
}
IEventStream GetStream(EventStreamId aggregateRootId)
{
IEventStream stream;
if (!streams.TryGetValue(aggregateRootId, out stream))
{
streams[aggregateRootId] = stream = eventStore.OpenStream(aggregateRootId);
}
return(stream);
}
/// <inheritdoc/>
public async Task <IEventStream <T> > GetAsync(EventStreamId id)
{
Requires.NotDefault(id, nameof(id));
InMemoryEventStream <T> stream;
if (!_streams.TryGetValue(id, out stream))
{
throw new EventStreamNotFoundException(id);
}
return(stream);
}
public SqlLiteEventStream(SqlLitePersistenceEngine persistenceEngine, EventStreamId streamId, IEventDispatcher eventDispatcher)
{
this.persistenceEngine = persistenceEngine;
this.streamId = streamId;
this.eventDispatcher = eventDispatcher;
uncommittedEvents = new List <SourcedEvent>();
committedEvents = new List <SourcedEvent>();
UncommittedHeaders = new Dictionary <string, object>();
commits = new List <Guid>();
PopulateStream();
}
/// <inheritdoc/>
public async Task <IEventStream <T> > AddAsync(EventStreamId id)
{
Requires.NotDefault(id, nameof(id));
var stream = new InMemoryEventStream <T>(id);
if (!_streams.TryAdd(id, stream))
{
throw new EventStreamAlreadyExistsException(id);
}
stream.Deleted += OnStreamDeleted;
return(stream);
}
public void Save <TAggregateRoot>(TAggregateRoot aggregateRoot)
where TAggregateRoot : AggregateRoot
{
using (IEventSession eventSession = eventSessionFactory.Create())
{
foreach (SourcedEvent @event in aggregateRoot.EventsAdded)
{
EventStreamId eventStreamId = aggregateRoot.GetEventStreamId();
eventSession.StoreEvent(@event, eventStreamId);
eventSession.StoreHeader(eventStreamId, EventOriginHeader.Key, EventOriginHeader.ForMachine(localMachine));
}
eventSession.Commit(Guid.NewGuid());
}
}
public bool Evaluate(StreamId streamId)
{
var parts = EventStreamId
.FromStreamId(streamId)
.Parts;
var index = 0;
foreach (var eval in validators)
{
if (index >= parts.Count || !eval(parts[index++]))
{
return(false);
}
}
return(parts.Count <= validators.Count ||
endsOnAcceptAll);
}
public override int GetHashCode()
{
unchecked {
int result = LogPosition.GetHashCode();
result = (result * 397) ^ Flags.GetHashCode();
result = (result * 397) ^ TransactionPosition.GetHashCode();
result = (result * 397) ^ TransactionOffset;
result = (result * 397) ^ ExpectedVersion.GetHashCode();
result = (result * 397) ^ EventStreamId.GetHashCode();
result = (result * 397) ^ EventId.GetHashCode();
result = (result * 397) ^ CorrelationId.GetHashCode();
result = (result * 397) ^ TimeStamp.GetHashCode();
result = (result * 397) ^ EventType.GetHashCode();
result = (result * 397) ^ Data.GetHashCode();
result = (result * 397) ^ Metadata.GetHashCode();
return(result);
}
}
public async Task <IList <IDomainEvent> > GetEventsByStreamId(EventStreamId eventStreamId)
{
var streamMessages = new List <StreamMessage>();
ReadStreamPage currentStreamPage;
var nextSliceStart = 0;
do
{
currentStreamPage = await _streamStore.ReadStreamForwards(
streamId : new StreamId(eventStreamId.StreamName),
fromVersionInclusive : nextSliceStart,
maxCount : ReadBatchSize);
nextSliceStart = currentStreamPage.NextStreamVersion;
streamMessages.AddRange(currentStreamPage.Messages);
} while (!currentStreamPage.IsEnd);
return(streamMessages.Select(ConvertStreamMessageToDomainEvent).ToList());
}
public async Task <StreamWriteResult> SaveEvents(EventStreamId eventStreamId, long streamVersion, List <IDomainEvent> events)
{
if (events.Any() == false)
{
return(new StreamWriteResult(-1));
}
var commitId = Guid.NewGuid();
var expectedVersion = streamVersion == 0 ? ExpectedVersion.NoStream : streamVersion - 1;
var eventsToSave = events.Select(domainEvent => ToEventData(commitId, domainEvent));
//if (eventsToSave.Length < WriteBatchSize)
//{
var result = await _connection.AppendToStreamAsync(
stream : eventStreamId.ToString(),
expectedVersion : expectedVersion,
events : eventsToSave);
return(new StreamWriteResult(result.NextExpectedVersion));
//}
//using (var transaction = await _connection.StartTransactionAsync(eventStreamId.ToString(), expectedVersion))
//{
// var position = 0;
// while (position < eventsToSave.Length)
// {
// var pageEvents = eventsToSave.Skip(position).Take(WriteBatchSize);
// await transaction.WriteAsync(pageEvents);
// position += WriteBatchSize;
// }
// var result = await transaction.CommitAsync();
// return new StreamWriteResult(result.NextExpectedVersion);
//}
}
public IEnumerable <SourcedEvent> GetEvents(EventStreamId streamId)
{
IEventStream stream = GetStream(streamId);
return(stream.CommittedEvents.Concat(stream.UncommittedEvents));
}
public async Task <IList <IDomainEvent> > GetEventsByStreamId(EventStreamId eventStreamId)
{
return(await GetEventsFromStreamVersion(eventStreamId.StreamName, MinStreamVersion, eventStreamId.ResolveLinks));
}
public InMemoryEventStream(EventStreamId id)
{
Requires.NotDefault(id, nameof(id));
Id = id;
}
List <SourcedEvent> GetEvents(EventStreamId streamId)
{
return(commits
.Where(c => c.StreamId == streamId.Id && c.BucketId == streamId.BucketId)
.SelectMany(c => c.Events).ToList());
}
public static void StoreEventAndCommit <TEvent>(this IEventSession session, TEvent @event, EventStreamId id, ILocalMachine localMachine)
where TEvent : new()
{
session.StoreEvent(@event, id, localMachine);
session.Commit(Guid.NewGuid());
}
public static void StoreEvent <TEvent>(this IEventSession session, Action <TEvent> eventIntialiser, EventStreamId id, ILocalMachine localMachine)
where TEvent : new()
{
var @event = new TEvent();
eventIntialiser(@event);
session.StoreEvent(@event, id, localMachine);
}
public static void StoreEvent <TEvent>(this IEventSession session, TEvent @event, EventStreamId id, ILocalMachine localMachine)
where TEvent : new()
{
session.StoreEvent(new SourcedEvent {
Body = @event
}, id);
session.StoreHeader(id, EventOriginHeader.Key, EventOriginHeader.ForMachine(localMachine));
}
public IEventStream OpenStream(EventStreamId streamId)
{
return(new SqlLiteEventStream(persistenceEngine, streamId, eventDispatcher));
}
public IEnumerable <SourcedEvent> GetEvents(EventStreamId id)
{
return(factory.Create()
.GetEvents(id)
.ToList());
}
public void StoreEvent(SourcedEvent @event, EventStreamId aggregateRootId)
{
GetStream(aggregateRootId).Add(@event);
}
public void StoreHeader(EventStreamId id, string key, object value)
{
GetStream(id).UncommittedHeaders[key] = value;
}
