//private async Task<bool> ReadStreamAsync(string stream, IQueue<ProjectionEventData> queue, CancellationToken cancellationToken = default(CancellationToken))
//{
// _logger.LogDebug("ReadFromStreamAsync {Stream}", stream);
// var cred = _connectionProvider.OpsCredentials;
// var src = _connectionProvider.Connection.Value;
// StreamEventsSlice slice;
// long sliceStart = StreamPosition.Start;
// do
// {
// _logger.LogTrace("Reading Slice from {0}", sliceStart);
// slice = await src.ReadStreamEventsForwardAsync(stream, sliceStart, 500, true, cred);
// _logger.LogTrace("Next Event: {0} , IsEndOfStream: {1}", slice.NextEventNumber, slice.IsEndOfStream);
// sliceStart = slice.NextEventNumber;
// foreach (var ev in slice.Events)
// {
// if (cancellationToken.IsCancellationRequested)
// {
// _logger.LogWarning("Initialization Cancelled");
// return false;
// }
// var de = ev.Event.ToDomainEvent();
// var desc = new ProjectionEventData
// {
// EventData = de,
// EventNumber = ev.OriginalEventNumber
// };
// _logger.LogTrace("Enqueue Event @{0}", desc);
// await queue.EnqueueAsync(desc);
// }
// } while (!slice.IsEndOfStream);
// return true;
//}
private async Task <ProjectionStatus> ReadStreamAsync(string stream, EventStoreProjectionContext context,
CancellationToken cancellationToken = default(CancellationToken))
{
_logger.LogDebug("ReadFromStreamAsync {Stream} {ProjectorId}", stream, context.ProjectorId);
var sw = Stopwatch.StartNew();
var cred = _connectionProvider.OpsCredentials;
var src = await _connectionProvider.GetActiveConnection();
StreamEventsSlice slice;
long sliceStart = StreamPosition.Start;
do
{
_logger.LogTrace("Reading Slice from {0}", sliceStart);
slice = await src.ReadStreamEventsForwardAsync(stream, sliceStart, 500, true, cred);
_logger.LogTrace("Next Event: {0} , IsEndOfStream: {1}", slice.NextEventNumber, slice.IsEndOfStream);
sliceStart = slice.NextEventNumber;
foreach (var ev in slice.Events)
{
if (cancellationToken.IsCancellationRequested)
{
_logger.LogWarning("Initialization Cancelled");
return(null);
}
try
{
var de = ev.Event.ToDomainEvent();
if (de != null)
{
var entry = new ProjectionEventData
{
EventData = de,
EventNumber = ev.OriginalEventNumber
};
await context.HandleEventAsync(entry);
}
}
catch (Exception e)
{
_logger.LogError(e, "Error Reading Event: {Stream} {ProjectorId} {OriginalEventNumber}", stream,
context.ProjectorId, ev.OriginalEventNumber);
}
}
} while (!slice.IsEndOfStream);
_logger.LogDebug("ReadFromStreamAsync {Stream} {ProjectorId} Finished in {Elapsed:0.0000} ms", stream, context.ProjectorId, sw.ElapsedMilliseconds);
return(context.Status);
}
private async Task InitProjectorInternal(CancellationToken cancellationToken, IReadModelProjector projector)
{
var projectorId = projector.GetType().FullName;
projector.Initialize(cancellationToken);
_logger.LogInformation("Initialize Projector {ProjectorName}", projectorId);
await UpdateInitializationStatusAsync(cancellationToken, projectorId, ProjectionInitializationStatus.StatusPending, "Starting");
var context =
new EventStoreProjectionContext(_loggerFactory, _connectionProvider, _entityStore, projector)
{
StreamName = projector.StreamName,
ProjectorId = projectorId
};
projector.Context = context;
await _cache.RemoveByPrefixAsync(CacheKeys.Create <ProjectionStatus>());
var status = await _entityStore.LoadAsync <ProjectionStatus>(projectorId, cancellationToken);
context.Status = status.Entity;
if (status.IsNew)
{
_logger.LogDebug("Starting Empty Initialization for Projector {Projector}", projectorId);
await UpdateInitializationStatusAsync(cancellationToken, projectorId, ProjectionInitializationStatus.StatusPending, "StartingInitialization");
await context.StartInitializationModeAsync();
await UpdateInitializationStatusAsync(cancellationToken, projectorId, ProjectionInitializationStatus.StatusPending, "InitializationStartingStreamReading");
try
{
var tempStatus = await ReadStreamAsync(context.StreamName, context, cancellationToken);
if (tempStatus != null)
{
status.Entity.LastCheckPoint = tempStatus.LastCheckPoint;
status.Entity.ModifiedOnUtc = tempStatus.ModifiedOnUtc;
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error ReadStreamAsync");
throw;
}
await UpdateInitializationStatusAsync(cancellationToken, projectorId, ProjectionInitializationStatus.StatusPending, "InitializationStartingCopy");
try
{
await projector.CopyEntitiesAsync(context.EntityStore, _entityStore, cancellationToken);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error CopyEntitites");
throw;
}
await context.StopInitializationModeAsync();
await _entityStore.SaveAsync(status, cancellationToken);
await UpdateInitializationStatusAsync(cancellationToken, projectorId, ProjectionInitializationStatus.StatusPending, "InitializationFinished");
}
cancellationToken.ThrowIfCancellationRequested();
_logger.LogDebug("Starting Subscription on EventStore for Projector {Projector}", context.ProjectorId);
await context.StartSubscription(cancellationToken);
await UpdateInitializationStatusAsync(cancellationToken, projectorId, ProjectionInitializationStatus.StatusReady, "Startet");
}
