public EventStoreProjectorRegistry(ILoggerFactory loggerFactory
, EventStoreConnectionProvider connectionProvider
, IServiceProvider serviceProvider
, IEntityStore entityStore
, ICacheClient cache
, IOptions <ProjectionOptions> options
)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_logger = loggerFactory.CreateLogger(GetType());
_projectors = serviceProvider.GetServices <IReadModelProjector>();
_entityStore = entityStore ?? throw new ArgumentNullException(nameof(entityStore));
_cache = cache ?? throw new ArgumentNullException(nameof(cache));
_options = options.Value;
}
public async Task <Nothing> AppendAsync(
AggregateId aggregateId,
IReadOnlyList <IDomainEvent> domainEvents,
long expectedVersion)
{
if (domainEvents.Count > 0)
{
var connection = await EventStoreConnectionProvider.GrabSingleEventStoreConnectionFor(_connectionString);
var results = await connection.ConditionalAppendToStreamAsync(
aggregateId.ToStreamName(_eventStoreName),
expectedVersion,
domainEvents.Select(e => e.ToEventData()));
switch (results.Status)
{
case ConditionalWriteStatus.Succeeded:
break;
case ConditionalWriteStatus.VersionMismatch:
throw new VersionMismatchException(aggregateId.ToStreamName(_eventStoreName), expectedVersion);
case ConditionalWriteStatus.StreamDeleted:
throw new StreamDeletedException(aggregateId.ToStreamName(_eventStoreName));
default:
throw new ArgumentOutOfRangeException();
}
}
return(Nothing.NotAtAll);
}
public async Task write_events_to_stream()
{
var connectionProvider = new EventStoreConnectionProvider(Options.Create(_fixture.EventStoreConnectionOptions));
var aggregateId = Guid.NewGuid();
var streamId =
StreamIdBuilder.Create()
.WithAggregateId(aggregateId)
.WithAggregateType <DummyAggregate>()
.Build();
var writeEvents = new List <Event> {
new DummyCreatedEvent(aggregateId, "The name", "https://url.example.com"),
new DummyNameChangedEvent(aggregateId, "The new name"),
new DummyUrlChangedEvent(aggregateId, "https://newurl.example.com")
};
var sut = new EventStoreStreamWriter(connectionProvider, _serializer);
await sut.AppendEventsToStream(streamId, writeEvents);
var reader = new EventStoreStreamReader(connectionProvider, _serializer);
var count = 0;
var enumerator = reader.ReadAllEventsFromStreamAsync(streamId).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync())
{
count++;
}
await enumerator.DisposeAsync();
count.Should().Be(3);
}
public async Task write_events_to_stream_when_expected_version_matches()
{
var connectionProvider = new EventStoreConnectionProvider(Options.Create(_fixture.EventStoreConnectionOptions));
var aggregateId = Guid.NewGuid();
var streamId =
StreamIdBuilder.Create()
.WithAggregateId(aggregateId)
.WithAggregateType <DummyAggregate>()
.Build();
var writeEvents = new List <Event> {
new DummyCreatedEvent(aggregateId, "The name", "https://url.example.com"),
new DummyNameChangedEvent(aggregateId, "The new name"),
new DummyUrlChangedEvent(aggregateId, "https://newurl.example.com")
};
var sut = new EventStoreStreamWriter(connectionProvider, _serializer);
await sut.AppendEventsToStream(streamId, writeEvents);
var changeEvent = new DummyUrlChangedEvent(aggregateId, "https://newnewurl.example.com");
await sut.AppendEventsToStream(streamId, new List <Event> {
changeEvent
}, 2);
}
public async Task throw_on_write_when_expected_version_does_not_match()
{
var connectionProvider = new EventStoreConnectionProvider(Options.Create(_fixture.EventStoreConnectionOptions));
var aggregateId = Guid.NewGuid();
var streamId =
StreamIdBuilder.Create()
.WithAggregateId(aggregateId)
.WithAggregateType <DummyAggregate>()
.Build();
var writeEvents = new List <Event> {
new DummyCreatedEvent(aggregateId, "The name", "https://url.example.com"),
new DummyNameChangedEvent(aggregateId, "The new name"),
new DummyUrlChangedEvent(aggregateId, "https://newurl.example.com")
};
//Write 3 events to the stream, this sets the version to 2
var sut = new EventStoreStreamWriter(connectionProvider, _serializer);
await sut.AppendEventsToStream(streamId, writeEvents);
//Write should fail
var changeEvent = new DummyUrlChangedEvent(aggregateId, "https://newnewurl.example.com");
await Assert.ThrowsAsync <WrongExpectedVersionException>(
async() => await sut.AppendEventsToStream(streamId, new List <Event> {
changeEvent
}, 1));
}
private static void TestConnection(IEventStoreConfiguration config)
{
var connectionProvider = new EventStoreConnectionProvider(config);
connectionProvider.SetConnectionSettingsBuilder(
() => ConnectionSettings.Create()
.FailOnNoServerResponse()
.SetDefaultUserCredentials(new UserCredentials("Inforigami.Regalo.EventStore", "changeit")));
var connection = connectionProvider.GetConnection();
Assert.DoesNotThrow(() => connection.ConnectAsync().Wait());
Assert.DoesNotThrow(
() =>
{
try
{
connection.ReadAllEventsForwardAsync(Position.Start, 512, false).Wait();
}
catch (AggregateException e)
{
if (e.InnerExceptions.Any(x => x is AccessDeniedException))
{
throw new InvalidOperationException(
"Unable to authenticate with the eventstore instance at 'localhost:1113'. Ensure there is an admin user "
+ "configured called 'Inforigami.Regalo.EventStore', with password 'changeit'.", e);
}
}
});
}
public EventStoreProjectionContext(ILoggerFactory loggerFactory
, EventStoreConnectionProvider connectionProvider
, IEntityStore entityStore
, IReadModelProjector projector
// , bool useQueue
, string projectorId
)
{
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_logger = loggerFactory.CreateLogger(GetType());
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_entityStore = entityStore ?? throw new ArgumentNullException(nameof(entityStore));
_projector = projector ?? throw new ArgumentNullException(nameof(projector));
// _useQueue = useQueue;
StreamName = projector.StreamName;
if (string.IsNullOrEmpty(StreamName))
{
throw new InvalidOperationException("no stream name in projector " + projector.GetType().FullName);
}
ProjectorId = projectorId;
// if (_useQueue)
// {
// Queue = new InMemoryQueue<ProjectionEventData>(new InMemoryQueueOptions<ProjectionEventData>
// {
// LoggerFactory = loggerFactory
// });
// }
}
public async Task <IReadOnlyList <IDomainEvent> > AsyncLoadAllEventsFor(AggregateId aggregateId)
{
var connection = await EventStoreConnectionProvider.GrabSingleEventStoreConnectionFor(_connectionString);
var resolvedEvents = await connection.ReadAllStreamEventsForward(aggregateId.ToStreamName(_eventStoreName));
return(resolvedEvents.Select(e => e.Event.ToDomainEvent()).ToList());
}
public EventStoreReader(EventStoreConnectionProvider provider, ILoggerFactory loggerFactory)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_logger = loggerFactory.CreateLogger(GetType());
_provider = provider ?? throw new ArgumentNullException(nameof(provider));
}
public PersistentSubscriptionAdapter(EventStoreConnectionProvider connectionProvider, IApplicationLifetime applicationLifetime)
{
if (applicationLifetime == null)
{
throw new ArgumentNullException(nameof(applicationLifetime));
}
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_cancellationToken = applicationLifetime.ApplicationStopping;
}
private EventRepository <T> CreateRepository <T>()
where T : AggregateRoot
{
var connectionProvider = new EventStoreConnectionProvider(Options.Create(_fixture.EventStoreConnectionOptions));
var reader = new EventStoreStreamReader(connectionProvider, _serializer);
var writer = new EventStoreStreamWriter(connectionProvider, _serializer);
var sut = new EventRepository <T>(writer, reader);
return(sut);
}
private IEventStoreSubscription EventStoreSubscriptionFrom(string streamName, long lastCheckpoint)
{
var connection = EventStoreConnectionProvider.GrabSingleEventStoreConnectionFor(_connectionString).Result;
var eventStream = new BlockingCollection <IDomainEvent>();
var catchUpSubscription = connection.SubscribeToStreamFrom(
streamName,
lastCheckpoint == 0 ? (long?)null : lastCheckpoint,
CatchUpSubscriptionSettings.Default,
(_, x) => eventStream.Add(x.Event.ToDomainEvent()));
return(new EventStoreSubscription(catchUpSubscription, eventStream));
}
public DomainEventStore(ILoggerFactory loggerFactory
, EventStoreConnectionProvider provider
, Func <Type, string, string> aggregateIdToStreamName
)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_logger = loggerFactory.CreateLogger(GetType());
_provider = provider ?? throw new ArgumentNullException(nameof(provider));
_aggregateIdToStreamName = aggregateIdToStreamName ??
throw new ArgumentNullException(nameof(aggregateIdToStreamName));
}
public EventStoreProjectionContext(ILoggerFactory loggerFactory
, EventStoreConnectionProvider connectionProvider
, IEntityStore entityStore
, IReadModelProjector projector
)
{
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_logger = loggerFactory.CreateLogger(GetType());
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_entityStore = entityStore ?? throw new ArgumentNullException(nameof(entityStore));
_projector = projector ?? throw new ArgumentNullException(nameof(projector));
//Queue = new InMemoryQueue<ProjectionEventData>(new InMemoryQueueOptions<ProjectionEventData>()
//{
// LoggerFactory = loggerFactory
//});
//Queue.StartWorkingAsync(HandleAsync);
}
public async Task Throw_stream_not_found_exception_if_stream_does_not_exist()
{
var connectionProvider = new EventStoreConnectionProvider(Options.Create(_fixture.EventStoreConnectionOptions));
var aggregateId = Guid.NewGuid();
var streamId =
StreamIdBuilder.Create()
.WithAggregateId(aggregateId)
.WithAggregateType <DummyAggregate>()
.Build();
var reader = new EventStoreStreamReader(connectionProvider, _serializer);
await Assert.ThrowsAsync <StreamNotFoundException>(async() =>
{
var enumerator = reader.ReadAllEventsFromStreamAsync(streamId).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync())
{
;
}
await enumerator.DisposeAsync();
});
}
private IEventStreamReader CreateStreamReader()
{
var connectionProvider = new EventStoreConnectionProvider(Options.Create(_fixture.EventStoreConnectionOptions));
return(new EventStoreStreamReader(connectionProvider, _serializer));
}
public DomainEventStore(ILoggerFactory loggerFactory, EventStoreConnectionProvider provider) : this(loggerFactory, provider,
Util.AggregateIdToStreamName) //, Util.EventTypeToEventName)
{
}
public PersistentSubscriptionFactory(EventStoreConnectionProvider connectionProvider, IHostApplicationLifetime applicationLifetime)
{
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_applicationLifetime = applicationLifetime ?? throw new ArgumentNullException(nameof(applicationLifetime));
}
