public IEnumerable <object> Read(Guid id, int version)
{
using (var stream = _eventStore.OpenStream(id, version, int.MaxValue))
{
return(stream.CommittedEvents.Select(e => e.Body));
}
}
public void Save <TEntity>(TEntity entity) where TEntity : IEntity
{
using (var tx = new TransactionScope())
{
using (var stream = _eventStore.OpenStream(entity.Id, 0, int.MaxValue))
{
Transaction.Current.EnlistVolatile(this, EnlistmentOptions.None);
foreach (var @event in entity.UncommittedEvents())
{
stream.Add(new EventMessage {
Body = @event
});
}
stream.CommitChanges(Guid.NewGuid());
if (typeof(TEntity).IsAssignableToGenericType(typeof(ISnapshotable <>)))
{
var snapshot = _eventStore.Advanced.GetSnapshot(entity.Id, int.MaxValue);
var lastSnapshotRevision = snapshot == null ? 0 : snapshot.StreamRevision;
dynamic snapshotable = entity;
if (stream.StreamRevision - lastSnapshotRevision > snapshotable.MaxAllowedRevisionsBetweenSnapshots)
{
var memento = snapshotable.GetMemento();
_eventStore.Advanced.AddSnapshot(new Snapshot(entity.Id, stream.StreamRevision, memento));
}
}
}
_commitActions.Add(entity.ClearUncommittedEvents);
tx.Complete();
}
}
public async Task Commit <T>(T aggregate, string streamName, string queueName) where T : BaseAggregate
{
using (var evtStream = _storeEvents.OpenStream(streamName, streamName, int.MinValue, int.MaxValue))
{
lock (aggregate.DomainEvents)
{
foreach (var domainEvent in aggregate.DomainEvents)
{
evtStream.Add(new EventMessage {
Body = domainEvent
});
}
}
evtStream.CommitChanges(Guid.NewGuid());
}
foreach (var evt in aggregate.DomainEvents)
{
await _messageBroker.QueueEvent(evt, queueName);
}
if (((aggregate.Version - 1) % _serverOptions.SnapshotFrequency) == 0)
{
await _aggregateSnapshotStore.Add(new SnapshotElement <BaseAggregate>(0, DateTime.UtcNow, streamName, aggregate));
}
}
public Task <T> Get(Guid id)
{
return(Task.Run(() =>
{
var aggregate = (T)Activator.CreateInstance(typeof(T), true);
var stream = _events.OpenStream(aggregate.Id);
try
{
if (stream.CommitSequence == 0)
{
return null;
}
//no aggregate with this id has committed any events.
if (stream.StreamRevision == 0)
{
return null;
}
aggregate.LoadFromHistory(stream.CommittedEvents.Select(x => x.Body).OfType <IEvent>());
aggregate.Version = stream.StreamRevision;
}
finally
{
stream.Dispose();
}
return aggregate;
}));
}
public void Insert(T obj)
{
obj.UpdateIndexes(_collection.Indexes);
var task = _collection.ReplaceOneAsync(x => x.Id == obj.Id, obj, new UpdateOptions {
IsUpsert = true
});
task.Wait();
Guid streamId = obj.StreamId;
if (!_locks.ContainsKey(streamId))
{
lock (_locks)
{
if (!_locks.ContainsKey(streamId))
{
_locks[streamId] = new object();
}
}
}
lock (_locks[streamId])
{
using (var stream = _store.OpenStream(streamId, 0))
{
stream.Add(new EventMessage {
Body = obj
});
stream.CommitChanges(Guid.NewGuid());
}
}
}
/// <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 Optional <TAggregateRoot> GetOptional(string identifier)
{
Aggregate aggregate;
if (_unitOfWork.TryGet(identifier, out aggregate))
{
return(new Optional <TAggregateRoot>((TAggregateRoot)aggregate.Root));
}
var snapshot = _eventStore.Advanced.GetSnapshot(identifier, Int32.MaxValue);
if (snapshot != null)
{
using (var stream = _eventStore.OpenStream(snapshot, Int32.MaxValue))
{
var root = _rootFactory();
root.RestoreSnapshot(snapshot.Payload);
root.Initialize(stream.CommittedEvents.Select(eventMessage => eventMessage.Body));
_unitOfWork.Attach(new Aggregate(identifier, stream.StreamRevision, root));
return(new Optional <TAggregateRoot>(root));
}
}
using (var stream = _eventStore.OpenStream(identifier, minRevision: 0))
{
if (stream.StreamRevision == 0)
{
return(Optional <TAggregateRoot> .Empty);
}
var root = _rootFactory();
root.Initialize(stream.CommittedEvents.Select(eventMessage => eventMessage.Body));
_unitOfWork.Attach(new Aggregate(identifier, stream.StreamRevision, root));
return(new Optional <TAggregateRoot>(root));
}
}
public async Task Commit <T>(T aggregate, string streamName, CancellationToken cancellationToken) where T : BaseAggregate
{
var domainEvents = aggregate.DomainEvents.OrderBy(_ => _.Version);
lock (_obj)
{
using (var evtStream = _storeEvents.OpenStream(streamName, streamName, int.MinValue, int.MaxValue))
{
lock (domainEvents)
{
foreach (var domainEvent in domainEvents)
{
evtStream.Add(new EventMessage {
Body = domainEvent
});
}
}
evtStream.CommitChanges(Guid.NewGuid());
}
}
await _messageBroker.QueueDomainEvents(domainEvents.ToList(), cancellationToken);
if (aggregate.Version > 1 && (aggregate.Version - 1) % SNAP_SHOT_FREQUENCY == 0)
{
await _aggregateSnapshotStore.Add(new SnapshotElement <BaseAggregate>(0, DateTime.UtcNow, streamName, aggregate));
}
}
public override TResult GetById <TResult>(Guid id)
{
using (var stream = _store.OpenStream(id, 0, int.MaxValue))
{
var commitedEvents = stream.CommittedEvents.Select(em => em.Body as IEvent);
return(BuildAggregate <TResult>(commitedEvents));
}
}
public IEnumerable <object> Read(string bucketId, string id, int version)
{
bucketId = this.ChangeBucketIdIfRequired(bucketId);
using (var stream = _eventStore.OpenStream(bucketId, id, int.MinValue, version))
{
Logger.Debug("Stream with bucketId {0} id {1} has revision {2}. CommitedEvents count {3}", bucketId, id, stream.StreamRevision, stream.CommittedEvents.Count);
return(stream.CommittedEvents.Select(e => e.Body));
}
}
private static readonly Guid StreamId = Guid.NewGuid(); // aggregate identifer
private static void AppendToStream()
{
using (var stream = Store.OpenStream(StreamId, int.MinValue, int.MaxValue))
{
var @event = new SomeDomainEvent { Value = "Second event." };
stream.Add(new EventMessage { Body = @event });
stream.CommitChanges(Guid.NewGuid());
}
}
/// <summary>
/// Write a new event to the event store
/// </summary>
/// <param name="streamId"></param>
/// <param name="command"></param>
public void AppendToStream(Guid streamId, Command command)
{
using (IEventStream stream = _store.OpenStream(streamId, 0, int.MaxValue))
{
stream.Add(new EventMessage {
Body = command
});
stream.CommitChanges(command.EventId);
}
}
protected void OpenStreamAndAppendEvents(Guid streamId, List <T> events)
{
using (var stream = Store.OpenStream(streamId, int.MinValue, int.MaxValue))
{
events.ForEach(@event => stream.Add(new EventMessage {
Body = @event
}));
stream.CommitChanges(Guid.NewGuid());
}
}
/// <summary>
/// Gets the events by ID.
/// </summary>
/// <param name="aggregateID">The aggregate ID.</param>
/// <param name="startSequence">The start sequence.</param>
/// <returns></returns>
public IEnumerable <Event> GetEventsByID(object aggregateID, int startSequence)
{
var streamID = (Guid)aggregateID;
using (var stream = _store.OpenStream(streamID, startSequence, int.MaxValue))
{
foreach (var committedEvent in stream.CommittedEvents)
{
yield return((Event)committedEvent.Body);
}
}
}
public Task <IManageSessionOf <TState> > BeginSessionFor(TId id, bool throwIfNotExists = false)
{
var stream = store.OpenStream(id.ToString(), 0);
if (throwIfNotExists && stream.CommittedEvents.Count <= 0)
{
throw new StreamNotFoundException();
}
var session = new NEventStoreSession <TState>(configuration, stream);
session.Initialize();
return(Task.FromResult((IManageSessionOf <TState>)session));
}
public void SaveEvents(Guid aggregateId, IEnumerable <Event> events, int expectedVersion)
{
using (IEventStream stream = store.OpenStream(aggregateId, int.MinValue, int.MaxValue))
{
foreach (var @event in events)
{
stream.Add(new EventMessage {
Body = @event
});
}
stream.CommitChanges(Guid.NewGuid());
}
}
public IEnumerable <IDomainEvent> GetById(Guid id)
{
var list = new List <IDomainEvent>();
using (var stream = eventStore.OpenStream(id, 0, int.MaxValue))
{
var committedEvents = stream.CommittedEvents;
foreach (var eventMessage in committedEvents)
{
list.Add(eventMessage.Body as IDomainEvent);
}
}
return(list);
}
public Task <IEnumerable <IEvent> > GetEventsAsync(Guid aggregateId, int minVersion = int.MinValue, int maxVersion = int.MaxValue)
{
try
{
var stream = _storeEvents.OpenStream(Bucket.Default, aggregateId, minVersion, maxVersion);
var events = stream.CommittedEvents.Select(x => x.Body as IEvent);
return(Task.FromResult(events));
}
catch (StreamNotFoundException ex)
{
return(Task.FromResult(Enumerable.Empty <IEvent>()));
}
}
private IEventStream OpenStream(string bucketId, Guid id, int version, ISnapshot snapshot)
{
IEventStream stream;
var streamId = bucketId + "+" + id;
if (_streams.TryGetValue(streamId, out stream))
{
return(stream);
}
stream = snapshot == null
? _eventStore.OpenStream(bucketId, id, 0, version)
: _eventStore.OpenStream(snapshot, version);
return(_streams[streamId] = stream);
}
public void Save(Guid aggregateId, IEnumerable <IEvent> events, int expectedRevision)
{
//need to think about what is going on with the revision numbers here...
using (var stream = m_storeEvents.OpenStream(aggregateId, int.MinValue, expectedRevision))
{
foreach (var @event in events)
{
stream.Add(new EventMessage {
Body = @event
});
}
stream.CommitChanges(Guid.NewGuid());
}
}
private IEventStream OpenStream(IStoreEvents eventStore, Guid id, int version, Snapshot snapshot)
{
IEventStream stream;
if (_streams.TryGetValue(id, out stream))
{
return(stream);
}
stream = snapshot == null
? eventStore.OpenStream(id, 0, version)
: eventStore.OpenStream(snapshot, version);
return(this._streams[id] = stream);
}
public void verify_basic_in_memory_projection()
{
var id = new TestEventUnfolderId(Interlocked.Increment(ref progressive));
using (var stream = _eventStore.OpenStream("BLAH", id.AsString(), 0, Int32.MaxValue))
{
CommitOneValue(stream, 42);
}
var unfolder = sut.GetById <TestProjector, TestAggregateQueryModel>(id, Int32.MaxValue);
var rm = unfolder.GetProjection();
Assert.That(rm.Sum, Is.EqualTo(42));
Assert.That(rm.ListOfInt, Is.EquivalentTo(new[] { 42 }));
}
public T GetLastAggregate <T>(string id) where T : BaseAggregate
{
// var latestSnapshot = _eventStore.Advanced.GetSnapshot(id, int.MaxValue);
using (var stream = _eventStore.OpenStream(id))
{
var domainEvents = stream.CommittedEvents.Select(e => (DomainEvent)e.Body);
var instance = Construct <T>();
foreach (var domainEvt in domainEvents)
{
instance.Handle(domainEvt);
}
return(instance);
}
}
public Task <T> Get(TId id)
{
using (var stream = eventStore.OpenStream(id.ToString(), 0, int.MaxValue))
{
if (stream.CommittedEvents.Count == 0)
{
return(null);
}
var events = stream.CommittedEvents.Select(o => o.Body).OfType <IEnumerable <IDomainEvent <TId> > >().SelectMany(o => o).ToList();
var instance = Activator.CreateInstance(typeof(T), args: new object[] { events }) as T;
return(Task.FromResult(instance));
}
}
public List <IEvent> GetEventsForAggregate(string aggregateId)
{
using (var stream = _store.OpenStream(aggregateId))
{
var i = 0;
return(stream.CommittedEvents
.Select(ce => {
var thisEvent = ce.Body as IEvent;
thisEvent.Version = i++;
return thisEvent;
})
.ToList());
}
}
public async Task Save(IEnumerable <IEvent> events, CancellationToken cancellationToken = default)
{
foreach (var @event in events)
{
using (var stream = Store.OpenStream(@event.Id, 0, int.MaxValue))
{
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
await Publisher.Publish(@event, cancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Dispatches the eventstream to the reactor
/// </summary>
/// <param name="storeEvents"></param>
/// <returns>int The last streamrevision that was dispatched</returns>
public static async Task <int> DispatchEventStreamAsync(this IReactor reactor, IStoreEvents storeEvents, ConventionalReactionDispatcher dispatcher, Guid aggregateId, int streamRevision = 1)
{
var stream = storeEvents.OpenStream(aggregateId, streamRevision);
await dispatcher.DispatchEventStreamAsync(reactor, stream);
return(stream.StreamRevision);
}
private void OpenCreateStream(IStoreEvents store, AggregateRoot aggregate)
{
var changes = aggregate.GetUncommittedChanges();
if (!changes.Any())
{
return;
}
using (var stream = store.OpenStream(aggregate.Id, 0, int.MaxValue))
{
var version = aggregate.Version;
foreach (var @event in changes)
{
version++;
@event.Version = version;
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
// make a snapshot every 10th event
if (version % 10 != 0)
{
continue;
}
aggregate.Version = version;
store.Advanced.AddSnapshot(new Snapshot(aggregate.Id, version, aggregate));
}
}
aggregate.MarkChangesAsCommitted();
}
public void can_save_with_aggregate_identity()
{
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(
new SampleAggregate.State(),
sampleAggregateId
);
aggregate.Create();
_sut.Save(aggregate, new Guid("135E4E5F-3D65-43AC-9D8D-8A8B0EFF8501"), null);
var stream = _eventStore.OpenStream("Jarvis", sampleAggregateId, int.MinValue, int.MaxValue);
Assert.IsNotNull(stream);
Assert.AreEqual(1, stream.CommittedEvents.Count);
}
/// <summary>
/// Default Constructor
/// </summary>
public RavenNEventStore(string eventStore)
{
_eventStore = eventStore;
_streamId = Guid.NewGuid();
_store = GetInitializedEventStore(new ReceiveCommit(), eventStore);
_stream = _store.OpenStream(_streamId, 0, int.MaxValue);
}
public async Task <IEnumerable <DomainEvent> > GetLastDomainEvents <T>(string id, string streamName) where T : BaseAggregate
{
var snapCv = await _aggregateSnapshotStore.GetLast <T>(streamName);
DateTime?createDateTime = null;
long position = 0;
if (snapCv != null)
{
position = snapCv.Start + 1;
createDateTime = snapCv.CreateDateTime;
}
var domainEvents = new List <DomainEvent>();
if (createDateTime == null)
{
using (var stream = _storeEvents.OpenStream(streamName, streamName, 0, int.MaxValue))
{
domainEvents.AddRange(stream.CommittedEvents.Select(e => (DomainEvent)e.Body));
}
}
else
{
var commits = _storeEvents.Advanced.GetFrom(streamName, snapCv.CreateDateTime);
foreach (var commit in commits)
{
domainEvents.AddRange(commit.Events.Select(e => (DomainEvent)e.Body));
}
}
return(domainEvents);
}
public NEventStore(IStoreSettings<IStoreEvents> settings, IServiceBus serviceBus)
{
_settings = settings;
_serviceBus = serviceBus;
_store = _settings.GetConnection();
_eventStream = _store.OpenStream("main");
}
private void InsertEventsIntoStream(IStoreEvents storeEvents, int eventsPerStream)
{
Guid streamId = Guid.NewGuid();
for (int j = 0; j < eventsPerStream; j++)
{
using (IEventStream eventStream = storeEvents.OpenStream(streamId, 0, int.MaxValue))
{
eventStream.Add(new EventMessage { Body = CreateEvent() });
eventStream.CommitChanges(Guid.NewGuid());
}
}
}