public void Commit(Guid guid)
{
using (IEventStream stream = _store.OpenStream(guid, 0, int.MaxValue))
{
stream.CommitChanges(Guid.NewGuid());
}
}
protected override Task <int> SaveChanges(ItemWithType[] newEvents,
TState currentState,
CancellationToken?cancellationToken)
{
for (var index = 0; index < newEvents.Length; index++)
{
eventStream.Add(new EventMessage()
{
Body = newEvents[index].instance,
Headers = new Dictionary <string, object>
{
{ "EventType", newEvents[index].type }
}
});
}
try
{
eventStream.CommitChanges(Guid.NewGuid());
}
catch (ConcurrencyException nce)
{
throw new Exceptions.ConcurrencyException(eventStream.StreamId, nce);
}
return(Task.FromResult(eventStream.StreamRevision));
}
// Header of stream (like NEeventStore does). See: https://github.com/NEventStore/NEventStore/blob/master/src/NEventStore/CommonDomain/Persistence/EventStore/EventStoreRepository.cs#L197
public static void AddMigrationCommit(this IEventStream stream, Type mementoType, object @event)
{
stream.UncommittedHeaders[AggregateTypeHeader] = mementoType.FullName.Replace("Memento", "");
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
public void AppendToStream(IEvent @event)
{
using (IEventStream stream = _store.OpenStream(@event.Guid, 0, int.MaxValue))
{
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
private static void CommitOneValue(IEventStream stream, int value)
{
stream.Add(new EventMessage()
{
Body = new TestDomainEvent()
{
Value = value
}
});
stream.CommitChanges(Guid.NewGuid());
}
private static void OnSoldierCreateEvent(SoldierCreatedEvent createSoldier)
{
using (IEventStream stream = _store.OpenStream(_castleId))
{
var @event = new CreateSoldierEvent(Guid.NewGuid(), ProductionTime);
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
public void LoadFromSnapshotForwardAndAppend(IEvent @event)
{
var latestSnapshot = _store.Advanced.GetSnapshot(@event.Guid, 0);
using (IEventStream stream = _store.OpenStream(latestSnapshot, int.MaxValue))
{
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
private static void CreateGame()
{
using (IEventStream stream = _store.OpenStream(_gameId, 0))
{
// create game
var @event = new CreateGameEvent();
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
CreateCastle(_castleId);
}
public void AppendToStream(IList <IEvent> @events)
{
using (IEventStream stream = _store.OpenStream(@events.FirstOrDefault().Guid, 0, int.MaxValue))
{
foreach (var @event in @events)
{
stream.Add(new EventMessage {
Body = @event
});
}
stream.CommitChanges(Guid.NewGuid());
}
}
public void OpenOrCreateStream(IEvent @event)
{
// we can call CreateStream(StreamId) if we know there isn't going to be any data.
// or we can call OpenStream(StreamId, 0, int.MaxValue) to read all commits,
// if no commits exist then it creates a new stream for us.
using (IEventStream stream = _store.OpenStream(@event.Guid, 0, int.MaxValue))
{
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
private static void CreateSoldier()
{
Console.WriteLine("Create soldier");
using (IEventStream stream = _store.OpenStream(_castleId, 0))
{
var @event = new CreateSoldierEvent(Guid.NewGuid(), ProductionTime);
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
private static void CreateCastle(Guid castleId)
{
Console.WriteLine("Create castle");
using (IEventStream stream = _store.OpenStream(castleId, 0))
{
// create game
var @event = new CreateCastleEvent();
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
CreateSoldier();
}
private Task PopulateMaster()
{
IEventStream stream = _master.CreateStream("tweets");
IEnumerable <Task> tasks = ReadTweets().Select(tweet =>
{
var message = new TweetMessage(tweet);
stream.Add(new EventMessage {
Body = message
});
return(stream.CommitChanges(Guid.NewGuid()));
});
return(Task.WhenAll(tasks));
}
/// <summary>
///
/// </summary>
/// <param name="bucketId"></param>
/// <param name="aggregate"></param>
/// <param name="commitId"></param>
/// <param name="updateHeaders"></param>
/// <returns></returns>
public Int32 Save(string bucketId, IAggregateEx aggregate, Guid commitId, Action <IDictionary <string, object> > updateHeaders)
{
if (_disposed)
{
throw new ObjectDisposedException("This instance of repository was already disposed");
}
Dictionary <string, object> headers = PrepareHeaders(aggregate, updateHeaders);
Int32 uncommittedEvents = aggregate.GetUncommittedEvents().Count;
while (true)
{
IEventStream stream = this.PrepareStream(bucketId, aggregate, headers);
int commitEventCount = stream.CommittedEvents.Count;
try
{
stream.CommitChanges(commitId);
aggregate.ClearUncommittedEvents();
return(uncommittedEvents);
}
catch (DuplicateCommitException dex)
{
stream.ClearChanges();
_logger.Debug(String.Format("Duplicate commit exception bucket {0} - id {1} - commitid {2}. \n{3}", bucketId, aggregate.Id, commitId, dex));
return(0); //no events commited
}
catch (ConcurrencyException e)
{
_logger.Warn(String.Format("Concurrency Exception bucket {0} - id {1} - commitid {2}. \n{3}", bucketId, aggregate.Id, commitId, e));
if (this.ThrowOnConflict(stream, commitEventCount))
{
//@@FIX -> aggiungere prima del lancio dell'eccezione
stream.ClearChanges();
throw new ConflictingCommandException(e.Message, e);
}
stream.ClearChanges();
}
catch (StorageException e)
{
throw new PersistenceException(e.Message, e);
}
finally
{
ReleaseAggregateId(aggregate.Id);
}
}
}
void CommitStream(Guid commitId, IEventStream toCommit)
{
try
{
toCommit.CommitChanges(commitId);
}
catch (DuplicateCommitException)
{
toCommit.ClearChanges();
}
catch (ConcurrencyException)
{
toCommit.ClearChanges();
throw;
}
}
public async Task When_new_commit_then_should_dispatch()
{
using (IStoreEvents eventStore = Wireup.Init().UsingInMemoryPersistence().Build())
{
var dispatchedEvents = new List <EventMessage <TestEvent> >();
var handlerModule = new TestHandlerModule(dispatchedEvents);
using (var host = new DurableCommitDispatcher(
new EventStoreClient(eventStore.Advanced),
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedCommits = host
.ProjectedCommits
.Replay();
using (projectedCommits.Connect())
{
await host.Start();
var streamId = Guid.NewGuid().ToString().FormatStreamIdWithBucket();
Guid commitId = Guid.NewGuid();
Task <ICommit> commitProjected = projectedCommits
.Take(1)
.ToTask();
using (IEventStream stream = eventStore.CreateStream(streamId))
{
stream.Add(new global::NEventStore.EventMessage {
Body = new TestEvent()
});
stream.CommitChanges(commitId);
}
host.PollNow();
await commitProjected;
dispatchedEvents.Count.Should().Be(1);
dispatchedEvents[0].Commit().Should().NotBeNull();
dispatchedEvents[0].Headers.Should().NotBeNull();
dispatchedEvents[0].Version.Should().Be(1);
dispatchedEvents[0].DomainEvent.Should().BeOfType <TestEvent>();
}
}
}
}
public async Task When_handler_throws_Then_invoke_exception_callback()
{
using (IStoreEvents eventStore = Wireup.Init().UsingInMemoryPersistence().Build())
{
var projectedEvents = new List <EventMessage <TestEvent> >();
var handlerModule = new TestHandlerModule(projectedEvents);
using (var host = new DurableCommitDispatcher(
new EventStoreClient(eventStore.Advanced),
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedCommits = host
.ProjectedCommits
.Replay();
using (projectedCommits.Connect())
{
await host.Start();
var streamId = Guid.NewGuid().ToString().FormatStreamIdWithBucket();
Guid commitId = Guid.NewGuid();
Task <ICommit> commitProjected = projectedCommits
.Take(1)
.ToTask();
using (IEventStream stream = eventStore.CreateStream(streamId))
{
stream.Add(new global::NEventStore.EventMessage {
Body = new TestEventThatThrows()
});
stream.CommitChanges(commitId);
}
host.PollNow();
Func <Task> act = async() => await commitProjected;
act.ShouldThrow <Exception>();
}
}
}
}
public void Save(string bucketId, IAggregateEx aggregate, Guid commitId, Action <IDictionary <string, object> > updateHeaders)
{
Dictionary <string, object> headers = PrepareHeaders(aggregate, updateHeaders);
while (true)
{
IEventStream stream = this.PrepareStream(bucketId, aggregate, headers);
int commitEventCount = stream.CommittedEvents.Count;
try
{
stream.CommitChanges(commitId);
aggregate.ClearUncommittedEvents();
return;
}
catch (DuplicateCommitException)
{
stream.ClearChanges();
return;
}
catch (ConcurrencyException e)
{
if (this.ThrowOnConflict(stream, commitEventCount))
{
//@@FIX -> aggiungere prima del lancio dell'eccezione
stream.ClearChanges();
throw new ConflictingCommandException(e.Message, e);
}
stream.ClearChanges();
}
catch (StorageException e)
{
throw new PersistenceException(e.Message, e);
}
finally
{
ReleaseAggregateId(aggregate.Id);
}
}
}