public async Task ContinuouslyCatchUpAllEventStreamsAsync(GlobalCheckpoint initialCommit, Func <Revision, Task> onNext)
{
// Set default cancellation token in case it is not provided (it will do nothing)
CancellationToken cancellationToken = new CancellationTokenSource().Token;
await ContinuouslyCatchUpAllEventStreamsAsync(initialCommit, onNext, cancellationToken);
}
public EventStreamTracker(string trackerId, GlobalCheckpoint checkpoint)
{
this.TrackerId = trackerId;
this.GlobalCheckpoint = checkpoint;
this.Type = Readers.CheckpointType.GlobalCheckpoint;
this.StreamCheckpoint = Readers.EventStreamCheckpoint.Empty;
}
public async Task ContinuouslyCatchUpAllEventStreamsAsync(GlobalCheckpoint initialCommit, Action <Revision> onNext, CancellationToken cancellationToken)
{
await ContinuouslyCatchUpAllEventStreams(initialCommit, async revision =>
{
// Execute onNext task specified by the client
onNext(revision);
await Task.CompletedTask;
},
cancellationToken);
}
public async Task CatchUpAllEventStreamsAsync(string trackerId, Func <Revision, Task> onNext, CancellationToken cancellationToken)
{
await CatchUpAllEventStreams(trackerId, async state =>
{
// Execute onNext task specified by the client
await onNext(state.Revision);
state.Tracker.UpdateCheckpoint(GlobalCheckpoint.Create(state.Revision.CommitId));
await this.TrackerRepository.CommitChanges();
},
cancellationToken);
}
private static IObservable <IEnumerable <Revision> > AllEventStreamBatchesFrom(IEventStreamReader eventStoreClient, GlobalCheckpoint 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 AllEventStreamsSingleBatch(eventStoreClient, checkpoint,
NumberOfResultsPerRequest, timeout, retries, scheduler);
return new AllEventStreamsPollingState
{
LastCheckpoint = GlobalCheckpoint.Create(checkpoint.CommitId + result.Count()),
LastStreamBatch = result
};
},
value => (value.LastStreamBatch != null && value.LastStreamBatch.Count() > 0) || infinitePollingEnabled,
async value =>
{
var streamBatch = AllEventStreamsSingleBatch(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 AllEventStreamsPollingState
{
LastCheckpoint = GlobalCheckpoint.Create(value.LastCheckpoint.CommitId + result.Count()),
LastStreamBatch = result
};
}
else
{
return new AllEventStreamsPollingState
{
LastCheckpoint = GlobalCheckpoint.Create(value.LastCheckpoint.CommitId),
LastStreamBatch = Enumerable.Empty <Revision>()
};
}
},
value => value.LastStreamBatch, scheduler));
}
private async Task <EventStreamTracker> GetTrackerOrCreate(string trackerId)
{
// Load last global checkpoint from tracker
EventStreamTracker tracker = await this.TrackerRepository.GetEventStreamTracker(trackerId, true);
// Create tracker if it does not exist
if (tracker == null)
{
tracker = new EventStreamTracker(trackerId, GlobalCheckpoint.Create(0));
await this.TrackerRepository.CreateEventStreamTracker(tracker);
}
return(tracker);
}
public async Task ContinuouslyCatchUpAllEventStreamsAsync(string trackerId, Action <Revision> onNext, CancellationToken cancellationToken)
{
//EventStreamTracker tracker = await GetTrackerOrCreate(trackerId);
await ContinuouslyCatchUpAllEventStreams(trackerId, async (state) =>
{
// Execute onNext task specified by the client
onNext(state.Revision);
state.Tracker.UpdateCheckpoint(GlobalCheckpoint.Create(state.Revision.CommitId));
await this.TrackerRepository.CommitChanges();
},
cancellationToken);
}
private async Task CatchUpAllEventStreams(GlobalCheckpoint initialCommit, Func <Revision, Task> handleRevision, CancellationToken cancellationToken)
{
try
{
// Subscribe to all event streams and execute onNext action and save changes for each revision received
await(EventStoreObservables.AllEventStreamsFrom(this.EventStreamReader, initialCommit)
.SelectFromAsync(handleRevision)
.RetryWithBackoffStrategy(retryCount: int.MaxValue, retryOnError: e => e is DbUpdateConcurrencyException)
.ToTask(cancellationToken));
}
catch (InvalidOperationException ex)
{
if (ex.HResult == -2146233079)
{
// TODO: Write to log instead of the console
Console.WriteLine(string.Format("An invalid operation exception has been thrown with code {0} when processing results from the server. Perhaps you are already up to date. Detailed error: {1}", ex.HResult, ex.Message));
}
else
{
throw ex;
}
}
}
public static IObservable <Revision> ContinuousAllEventStreamsFrom(IEventStreamReader eventStoreClient, GlobalCheckpoint checkpoint,
TimeSpan timeout, int retries = DefaultRetries, IScheduler scheduler = null)
{
return(ContinuousAllEventStreamsFrom(eventStoreClient, checkpoint, timeout, DefaultPollingInterval, 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()));
}
private static IObservable <IEnumerable <Revision> > ContinuousAllEventStreamBatchesFrom(IEventStreamReader eventStoreClient, GlobalCheckpoint checkpoint,
TimeSpan timeout, TimeSpan pollingInterval, int retries = DefaultRetries, IScheduler scheduler = null)
{
return(AllEventStreamBatchesFrom(eventStoreClient, checkpoint, timeout, pollingInterval, true, retries, scheduler));
}
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));
}
public static IObservable <Revision> ContinuousAllEventStreamsFrom(IEventStreamReader eventStoreClient, GlobalCheckpoint checkpoint,
TimeSpan timeout, TimeSpan pollingInterval, int retries = DefaultRetries, IScheduler scheduler = null)
{
return(Observable.Create <Revision>(observer =>
{
var poll = ContinuousAllEventStreamBatchesFrom(eventStoreClient, checkpoint, timeout, pollingInterval, retries, scheduler);
return poll.Subscribe(
value =>
{
foreach (var revision in value)
{
observer.OnNext(revision);
}
},
ex => observer.OnError(ex),
() => observer.OnCompleted());
}));
}
public async Task ContinuouslyCatchUpAllEventStreamsAsync(GlobalCheckpoint initialCommit, Func <Revision, Task> onNext, CancellationToken cancellationToken)
{
await ContinuouslyCatchUpAllEventStreams(initialCommit, onNext, cancellationToken);
}
static void Main(string[] args)
{
Task t = null;
CancellationTokenSource ct = null;
AppInitializer.Initialize();
var options = new DbContextOptionsBuilder <EventStoreDbContext>()
.UseSqlServer(@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=EventStreamReactiveObservablesExample;Integrated Security=False")
.Options;
var dbContext = new EventStoreDbContext(options);
IEventStore eventStore = new EFEventStore(dbContext, null);
IEventStreamReader eventStreamReader = new InProcessEventStreamReader(eventStore);
Console.WriteLine("CATCHING UP EVENT STREAM");
t = EventStoreObservables.EventStreamFrom(eventStreamReader, EventStreamCheckpoint.CreateStreamCheckpoint("19e2a7fc-d0eb-44b9-8348-e7678ccd37bc", 0, 0))
.ForEachAsync(revision => Console.WriteLine("--> Aggregate: " + revision.AggregateType + " - Revision: " + revision.RevisionId));
t.Wait();
Console.WriteLine("Completed (up to date)");
Console.WriteLine();
Console.WriteLine("Press <ENTER> to continue...");
Console.ReadLine();
Console.WriteLine();
Console.WriteLine("CONTINUOUSLY CATCHING UP EVENT STREAM");
ct = new CancellationTokenSource(TimeSpan.FromSeconds(10));
try
{
t = EventStoreObservables.ContinuousEventStreamFrom(eventStreamReader, EventStreamCheckpoint.CreateStreamCheckpoint("19e2a7fc-d0eb-44b9-8348-e7678ccd37bc", 0, 0))
.ForEachAsync(revision => Console.WriteLine("--> Aggregate: " + revision.AggregateType + " - Revision: " + revision.RevisionId), ct.Token);
t.Wait();
}
catch (AggregateException e)
{
if (e.InnerException is TaskCanceledException)
{
Console.WriteLine("ERROR: The operation has been canceled => " + e.InnerException.Message);
}
else
{
throw e;
}
}
Console.WriteLine();
Console.WriteLine("Press <ENTER> to continue...");
Console.ReadLine();
Console.WriteLine();
Console.WriteLine("CATCHING UP ALL EVENT STREAMS");
t = EventStoreObservables.AllEventStreamsFrom(eventStreamReader, GlobalCheckpoint.Create(27))
.ForEachAsync(revision => Console.WriteLine("--> Aggregate: " + revision.AggregateType + " - Revision: " + revision.RevisionId));
t.Wait();
Console.WriteLine("Completed (up to date)");
Console.WriteLine();
Console.WriteLine("Press <ENTER> to continue...");
Console.ReadLine();
Console.WriteLine();
Console.WriteLine("CONTINUOUSLY CATCHING UP ALL EVENT STREAMS");
ct = new CancellationTokenSource(TimeSpan.FromSeconds(10));
try
{
t = EventStoreObservables.ContinuousAllEventStreamsFrom(eventStreamReader, GlobalCheckpoint.Create(1))
.ForEachAsync(revision => Console.WriteLine("--> Aggregate: " + revision.AggregateType + " - Revision: " + revision.RevisionId), ct.Token);
t.Wait();
}
catch (AggregateException e)
{
if (e.InnerException is TaskCanceledException)
{
Console.WriteLine("ERROR: The operation has been canceled => " + e.Message);
}
else
{
throw e;
}
}
// Dispose resources
dbContext.Dispose();
Console.WriteLine();
Console.WriteLine("Press <ENTER> to exit...");
Console.ReadLine();
}
static void Main(string[] args)
{
Task t = null;
CancellationTokenSource ct = null;
AppInitializer.Initialize();
var options = new DbContextOptionsBuilder <EventStoreDbContext>()
.UseSqlServer(@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=EventStreamReactiveReaderExample;Integrated Security=False")
.Options;
var dbContext = new EventStoreDbContext(options);
IEventStore eventStore = new EFEventStore(dbContext, null);
IEventStreamReader eventStreamReader = new InProcessEventStreamReader(eventStore);
IEventStreamReactiveReader reactiveReader = new EventStreamReactiveReader(eventStreamReader);
Console.WriteLine("******** REACTIVE READER EXAMPLES ********");
Console.WriteLine();
Console.WriteLine("CATCHING UP ALL EVENT STREAMS");
try
{
t = reactiveReader.CatchUpAllEventStreamsAsync(GlobalCheckpoint.CreateFromStart(), revision =>
{
Console.WriteLine(string.Format("--> Processed revision: {0}", revision.ToString()));
});
t.Wait();
}
catch (AggregateException e)
{
Console.WriteLine(string.Format("ERROR: {0}", e.InnerException.Message));
}
Console.WriteLine();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("CONTINUOUSLY CATCHING UP ALL EVENT STREAMS");
ct = new CancellationTokenSource(TimeSpan.FromSeconds(30));
try
{
t = reactiveReader.ContinuouslyCatchUpAllEventStreamsAsync(GlobalCheckpoint.CreateFromStart(), revision =>
{
Console.WriteLine(string.Format("--> Processed revision: {0}", revision.ToString()));
}, ct.Token);
t.Wait();
}
catch (AggregateException e)
{
Console.WriteLine(string.Format("ERROR: {0}", e.InnerException.Message));
}
Console.WriteLine();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
Console.WriteLine("CATCHING UP ALL EVENT STREAMS (WITH ASYNCHRONOUS HANDLER)");
try
{
t = reactiveReader.CatchUpAllEventStreamsAsync(GlobalCheckpoint.CreateFromStart(), async revision =>
{
Console.WriteLine(string.Format("--> Processed revision: {0}", revision.ToString()));
await Task.FromResult(true);
});
t.Wait();
}
catch (AggregateException e)
{
Console.WriteLine(string.Format("ERROR: {0}", e.InnerException.Message));
}
Console.WriteLine();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("CONTINUOUSLY CATCHING UP ALL EVENT STREAMS (WITH ASYNCHRONOUS HANDLER)");
ct = new CancellationTokenSource(TimeSpan.FromSeconds(10));
try
{
t = reactiveReader.ContinuouslyCatchUpAllEventStreamsAsync(GlobalCheckpoint.CreateFromStart(), async revision =>
{
Console.WriteLine(string.Format("--> Processed revision: {0}", revision.ToString()));
await Task.FromResult(true);
}, ct.Token);
t.Wait();
}
catch (AggregateException e)
{
Console.WriteLine(string.Format("ERROR: {0}", e.InnerException.Message));
}
// Dispose resources
dbContext.Dispose();
Console.WriteLine();
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
}
public static IObservable <Revision> AllEventStreamsFrom(IEventStreamReader eventStoreClient, GlobalCheckpoint checkpoint,
int retries = DefaultRetries, IScheduler scheduler = null)
{
return(AllEventStreamsFrom(eventStoreClient, checkpoint, DefaultTimeout, retries, scheduler));
}
