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);
}
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();
}