protected AggregateRootReadModelGenerator(IEventStreamReader <TEventStream> eventStreamReader)
{
_eventStreamReader = eventStreamReader;
RegisterEventAppliers()
.For <TAggregateRootEventInterface>(e => ReadModel.Id = e.AggregateRootId);
}
public EventRepository(
IEventStreamWriter streamWriter,
IEventStreamReader streamReader)
{
_streamWriter = streamWriter;
_streamReader = streamReader;
}
public ReadModelGenerator(IEventStreamReader <PersonEventStream> eventStreamReader) : base(eventStreamReader)
{
RegisterEventAppliers()
.For <IFirstNameUpdated>(e => ReadModel.FirstName = e.FirstName)
.For <ILastNameUpdated>(e => ReadModel.LastName = e.LastName)
.For <IMaritalStatusUpdated>(e => ReadModel.MaritalStatus = e.MaritalStatus)
;
}
public async Task ReceiveEventsAsync_WhenReceivingWasNotStartedBefore_CommitsReaderVersion(
[Frozen] CommitStreamVersionFMock commitStreamVersionMock,
[Frozen] IEventStreamReader reader,
EventStreamConsumer consumer)
{
await consumer.ReceiveEventsAsync();
Assert.Equal(0, commitStreamVersionMock.CallsCount);
Assert.Equal(StreamVersion.Unknown, commitStreamVersionMock.CommitedVersion);
}
public StudentReadModelGenerator(IEventStreamReader eventStreamReader) : base(eventStreamReader)
{
RegisterEventAppliers()
.For <IStudentEvent>(e => ReadModel.Id = e.AggregateRootId)
.For <IStudentRegisteredEvent>(e => ReadModel.Name = e.Name)
.For <IStudentEnrolledEvent>(e => ReadModel.Subjects.Add((Subject)e.Subject))
.For <IAddressChangedEvent>(e => ReadModel.Address = new Address {
Street = e.Street, ZipCode = e.ZipCode, City = e.City
});
}
public PartitionedProjectionQuery
(IPartitionedProjectionStateRepository <T> stateRepository,
IEventStreamReader streamReader,
PartitionedProjectionProfile <T> projectionProfile,
IServiceProvider serviceProvider)
{
_stateRepository = stateRepository;
_streamReader = streamReader;
_projectionProfile = projectionProfile;
_serviceProvider = serviceProvider;
}
private async Task EnsureStreamReaderInitializedAsync()
{
if (m_reader == null)
{
m_reader = await m_readerFactory.CreateAsync();
m_stateMachine = m_reader.HasEvents
? new EventStreamConsumerStateMachine(m_reader.ReaderStreamVersion.Decrement())
: new EventStreamConsumerStateMachine(m_reader.ReaderStreamVersion);
}
}
private static IObservable <IEnumerable <Revision> > EventStreamBatchesFrom(IEventStreamReader eventStoreClient, EventStreamCheckpoint checkpoint,
TimeSpan timeout, TimeSpan pollingInterval, bool infinitePollingEnabled = false, int retries = DefaultRetries, IScheduler scheduler = null)
{
scheduler = scheduler ?? Scheduler.Default;
return(ObservableExtensions.Generate(async() =>
{
IEnumerable <Revision> result = await EventStreamSingleBatch(eventStoreClient, checkpoint,
NumberOfResultsPerRequest, timeout, retries, scheduler);
return new EventStreamPollingState
{
LastCheckpoint = EventStreamCheckpoint.CreateStreamCheckpoint(checkpoint.StreamId, checkpoint.RevisionId + result.Count(), 0),
LastStreamBatch = result
};
},
value => (value.LastStreamBatch != null && value.LastStreamBatch.Count() > 0) || infinitePollingEnabled,
async value =>
{
var streamBatch = EventStreamSingleBatch(eventStoreClient, value.LastCheckpoint,
NumberOfResultsPerRequest, timeout, retries, scheduler);
IEnumerable <Revision> result = null;
//Introduce delay before performing next request (if required)
var delay = Observable.Empty <IEnumerable <Revision> >().Delay(pollingInterval);
if (value.LastStreamBatch == null || value.LastStreamBatch.Count() == 0 && infinitePollingEnabled)
{
result = await delay.Concat(streamBatch);
}
else
{
result = await streamBatch;
}
if (result != null && result.Count() > 0)
{
return new EventStreamPollingState
{
LastCheckpoint = EventStreamCheckpoint.CreateStreamCheckpoint(value.LastCheckpoint.StreamId, value.LastCheckpoint.RevisionId + result.Count(), 0),
LastStreamBatch = result
};
}
else
{
return new EventStreamPollingState
{
LastCheckpoint = EventStreamCheckpoint.CreateStreamCheckpoint(value.LastCheckpoint.StreamId, value.LastCheckpoint.RevisionId, 0),
LastStreamBatch = Enumerable.Empty <Revision>()
};
}
},
value => value.LastStreamBatch, scheduler));
}
public static IObservable <IEnumerable <Revision> > EventStreamSingleBatch(IEventStreamReader eventStoreClient, EventStreamCheckpoint checkpoint,
int numberOfResults, TimeSpan timeout, int retries, IScheduler scheduler)
{
return(Observable.Return(1, scheduler)
.SelectMany(_ =>
{
return eventStoreClient.GetEventStreamFromAsync(checkpoint.StreamId, checkpoint.RevisionId, numberOfResults);
})
.Do(_ => Console.WriteLine(string.Format("Requested event stream range [{0} - {1}]", checkpoint.RevisionId, checkpoint.RevisionId + numberOfResults - 1)))
.Timeout(timeout, scheduler)
.Retry(retries)
.Select(stream => stream.Revisions.AsEnumerable()));
}
public async Task ReceiveEventsAsync_WhenReceivingWasStarted_CommitsReaderVersion(
[Frozen] StreamVersion streamVersion,
[Frozen] CommitStreamVersionFMock commitStreamVersionMock,
[Frozen] IEventStreamReader reader,
EventStreamConsumer consumer)
{
await consumer.ReceiveEventsAsync(); // starts receiving
await consumer.ReceiveEventsAsync(); // continues receiving and commits previous events
Assert.Equal(1, commitStreamVersionMock.CallsCount);
Assert.Equal(streamVersion.Increment(reader.Events.Count), commitStreamVersionMock.CommitedVersion);
}
protected EventStoredActorService
(StatefulServiceContext context,
ActorTypeInformation actorTypeInfo,
Func <Microsoft.ServiceFabric.Actors.Runtime.ActorService, ActorId, ActorBase> actorFactory = null,
Func <Microsoft.ServiceFabric.Actors.Runtime.ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null,
IActorStateProvider stateProvider = null,
ActorServiceSettings settings = null,
IReliableStateManagerReplica reliableStateManagerReplica = null,
IEventStreamReader <TEventStream> eventStreamReader = null)
: base(context, actorTypeInfo, actorFactory, stateManagerFactory, stateProvider, settings, reliableStateManagerReplica)
{
StateProviderEventStreamReader = eventStreamReader ?? new EventStreamReader <TEventStream>(StateProvider, EventStoredActor <TAggregateRoot, TEventStream> .EventStreamStateKey);
}
public async Task CloseAsync_WhenReaderInCompletedStateAndHasNoUnprocessedEvents_CommitsConsumedVersion(
[Frozen] StreamVersion version,
[Frozen] CommitStreamVersionFMock commitStreamVersionMock,
[Frozen] IEventStreamReader reader,
EventStreamConsumer consumer)
{
await consumer.ReceiveEventsAsync();
consumer.EnumerateEvents().ToList();
await consumer.CloseAsync();
Assert.Equal(1, commitStreamVersionMock.CallsCount);
Assert.Equal(reader.StreamVersion.Increment(reader.Events.Count), commitStreamVersionMock.CommitedVersion);
}
public async Task CommitProcessedStreamVersionAsync_WhenReceivingWasStartedAndAutoCommitDisabled_DoesNotCommitReaderVersion(
[Frozen] StreamVersion streamVersion,
[Frozen] CommitStreamVersionFMock commitStreamVersionMock,
[Frozen] IEventStreamReader reader,
EventStreamConsumer consumer)
{
var expectedVersion = reader.StreamVersion.Increment(reader.Events.Count * 2);
await consumer.ReceiveEventsAsync();
await consumer.ReceiveEventsAsync();
await consumer.CommitProcessedStreamVersionAsync(false);
Assert.Equal(1, commitStreamVersionMock.CallsCount);
Assert.Equal(expectedVersion, commitStreamVersionMock.CommitedVersion);
}
/// <summary>
/// Initializes a new instance of the <see cref="Repository{TAggregateRoot}"/> class.
/// </summary>
/// <param name="rootFactory">The aggregate root entity factory.</param>
/// <param name="unitOfWork">The unit of work.</param>
/// <param name="eventStreamReader">The event stream reader.</param>
/// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="rootFactory"/> or the <paramref name="unitOfWork"/> or the <paramref name="eventStreamReader"/> is null.</exception>
public Repository(Func <TAggregateRoot> rootFactory, UnitOfWork unitOfWork, IEventStreamReader eventStreamReader)
{
if (rootFactory == null)
{
throw new ArgumentNullException("rootFactory");
}
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
if (eventStreamReader == null)
{
throw new ArgumentNullException("eventStreamReader");
}
_rootFactory = rootFactory;
_unitOfWork = unitOfWork;
_eventStreamReader = eventStreamReader;
}
public EventStreamConsumer(
string consumerName,
IEventStreamReader streamReader,
IEventStreamConsumingSession session,
StreamVersion commitedStreamVersion,
Func<StreamVersion, Task> commitConsumedVersion)
{
Require.NotEmpty(consumerName, "consumerName");
Require.NotNull(streamReader, "streamReader");
Require.NotNull(session, "session");
Require.NotNull(commitConsumedVersion, "commitConsumedVersion");
m_consumerName = consumerName;
m_reader = streamReader;
m_session = session;
m_commitConsumedVersion = commitConsumedVersion;
m_commitedStreamVersion = commitedStreamVersion;
}
public static IObservable <Revision> ContinuousEventStreamFrom(IEventStreamReader eventStoreClient, EventStreamCheckpoint checkpoint,
TimeSpan timeout, TimeSpan pollingInterval, int retries = DefaultRetries, IScheduler scheduler = null)
{
return(Observable.Create <Revision>(observer =>
{
var poll = ContinuousEventStreamBatchesFrom(eventStoreClient, checkpoint, pollingInterval, timeout, retries, scheduler);
return poll.Subscribe(
value =>
{
foreach (var revision in value)
{
observer.OnNext(revision);
}
},
ex => observer.OnError(ex),
() => observer.OnCompleted());
}));
}
public async Task RememberConsumedStreamVersionAsync_WhenAllEventsWereConsumed_CommitsReaderVersion(
[Frozen] StreamVersion streamVersion,
[Frozen] IEventStreamReader streamReader,
[Frozen] CommitStreamVersionFMock commitStreamVersionMock,
EventStreamConsumer consumer)
{
await consumer.ReceiveEventsAsync();
var handledEvents = 0;
foreach (var e in consumer.EnumerateEvents())
{
handledEvents++;
}
await consumer.CommitProcessedStreamVersionAsync(true);
Assert.Equal(1, commitStreamVersionMock.CallsCount);
Assert.Equal(streamReader.StreamVersion.Increment(streamReader.Events.Count), commitStreamVersionMock.CommitedVersion);
}
private static IObservable <IEnumerable <Revision> > AllEventStreamBatchesFrom(IEventStreamReader eventStoreClient, GlobalCheckpoint checkpoint, TimeSpan timeout,
int retries, IScheduler scheduler)
{
return(AllEventStreamBatchesFrom(eventStoreClient, checkpoint, timeout, TimeSpan.Zero, false, retries, scheduler));
}
private static IObservable <IEnumerable <Revision> > AllEventStreamsSingleBatch(IEventStreamReader eventStoreClient,
GlobalCheckpoint checkpoint, int numberOfResults, TimeSpan timeout, int retries, IScheduler scheduler)
{
return(Observable.Return(1, scheduler)
.SelectMany(_ =>
{
return eventStoreClient.GetAllEventStreamsFromAsync(checkpoint.CommitId, numberOfResults);
})
.Do(_ => Console.WriteLine(string.Format("Requested all event streams range (commit) [{0} - {1}]", checkpoint.CommitId, checkpoint.CommitId + numberOfResults - 1)))
.Timeout(timeout, scheduler)
.Retry(retries)
.Select(stream => stream.Revisions.AsEnumerable()));
}
public EventStreamReactiveReader(IEventStreamReader eventStreamReader)
{
this.EventStreamReader = eventStreamReader;
}
public EventStreamChannel(IEventStreamReader eventStreamReader, Stream stream, CancellationToken cancellationToken = default)
{
_eventStreamReader = eventStreamReader;
_pipeReader = PipeReader.Create(stream);
_ = Task.Run(async() => await ReceivePacketsAsync(_pipeReader, cancellationToken), cancellationToken);
}
public ProjectionProcessor(BlobEventStreamReader blobEventStreamReader)
{
// Initialise the reader to use to read the events to be processed
this.eventStreamReader = blobEventStreamReader;
}
public CommandHandler(IEventStreamReader eventStreamReader)
{
_eventStreamReader = eventStreamReader;
}
private static IObservable <IEnumerable <Revision> > EventStreamBatchesFrom(IEventStreamReader eventStoreClient, EventStreamCheckpoint checkpoint,
TimeSpan timeout, int retries = DefaultRetries, IScheduler scheduler = null)
{
return(EventStreamBatchesFrom(eventStoreClient, checkpoint, timeout, TimeSpan.Zero, false, retries, scheduler));
}
public EventStreamChannel(IEventStreamReader eventStreamReader, Stream stream)
{
_eventStreamReader = eventStreamReader;
_pipeReader = PipeReader.Create(stream);
_ = Task.Run(async() => await ReceivePacketsAsync(_pipeReader));
}
public static IObservable <Revision> ContinuousEventStreamFrom(IEventStreamReader eventStoreClient, EventStreamCheckpoint checkpoint,
TimeSpan timeout, int retries = DefaultRetries, IScheduler scheduler = null)
{
return(ContinuousEventStreamFrom(eventStoreClient, checkpoint, timeout, DefaultPollingInterval, retries, scheduler));
}
protected ReadModelGenerator(IEventStreamReader eventStreamReader)
{
_eventStreamReader = eventStreamReader;
}
public EventStreamChannel(IEventStreamReader eventStreamReader, Stream stream)
{
_eventStreamReader = eventStreamReader;
_pipeReader = PipeReader.Create(stream);
}
public EventStreamTrackedReactiveReader(IEventStreamTrackerRepository trackerRepository, IEventStreamReader client)
{
this.TrackerRepository = trackerRepository;
this.Client = client;
}
public ClassificationProcessor(TableEventStreamReader tableEventStreamReader)
{
// Initialise the reader to use to read the events to be processed
this.eventStreamReader = tableEventStreamReader;
}
private static IObservable <IEnumerable <Revision> > ContinuousEventStreamBatchesFrom(IEventStreamReader eventStoreClient, EventStreamCheckpoint checkpoint,
TimeSpan timeout, TimeSpan pollingInterval, int retries = DefaultRetries, IScheduler scheduler = null)
{
return(EventStreamBatchesFrom(eventStoreClient, checkpoint, timeout, pollingInterval, true, retries, scheduler));
}
