private async Task <EventRange> loadEvents(EventRange range)
{
if (_cancellation.IsCancellationRequested)
{
return(null);
}
await _daemon.TryAction(this, async() =>
{
try
{
await _fetcher.Load(range, _cancellation);
}
catch (Exception e)
{
if (!_cancellation.IsCancellationRequested)
{
_logger.LogError(e, "Error loading events for {Range}", range);
throw new EventFetcherException(_projectionShard.Name, e);
}
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Loaded events for {Range}", range);
}
}, _cancellation);
return(range);
}
public async Task Load(EventRange range, CancellationToken token)
{
// There's an assumption here that this method is only called sequentially
// and never at the same time on the same instance
try
{
range.Events = new List <IEvent>();
using var session = querySession();
_floor.Value = range.SequenceFloor;
_ceiling.Value = range.SequenceCeiling;
using var reader = await session.ExecuteReaderAsync(_command, token).ConfigureAwait(false);
while (await reader.ReadAsync(token).ConfigureAwait(false))
{
var @event = await _storage.ResolveAsync(reader, token).ConfigureAwait(false);
if (!await reader.IsDBNullAsync(_aggregateIndex, token).ConfigureAwait(false))
{
@event.AggregateTypeName = await reader.GetFieldValueAsync <string>(_aggregateIndex, token).ConfigureAwait(false);
}
range.Events.Add(@event);
}
}
catch (Exception e)
{
throw new EventFetcherException(range.ShardName, _database, e);
}
Debug.WriteLine("here");
}
private async Task <EventRangeGroup> groupEventRange(EventRange range)
{
if (_cancellation.IsCancellationRequested)
{
return(null);
}
EventRangeGroup group = null;
await TryAction(async() =>
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Shard '{ProjectionShardIdentity}':Starting to group {Range}", ProjectionShardIdentity, range);
}
@group = await _source.GroupEvents(_store, _daemon.Database, range, _cancellation).ConfigureAwait(false);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Shard '{ProjectionShardIdentity}': successfully grouped {Range}", ProjectionShardIdentity, range);
}
}, _cancellation, (logger, e) =>
{
logger.LogError(e, "Error while trying to group event range {EventRange} for projection shard {SProjectionShardIdentity}", range, ProjectionShardIdentity);
}).ConfigureAwait(false);
return(group);
}
private async Task<EventRangeGroup> groupEventRange(EventRange range)
{
if (_cancellation.IsCancellationRequested) return null;
EventRangeGroup group = null;
await TryAction(async () =>
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Shard '{ShardName}':Starting to group {Range}", Name, range);
}
group = await _source.GroupEvents(_store, range, _cancellation);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Shard '{ShardName}': successfully grouped {Range}", Name, range);
}
}, _cancellation, (logger, e) =>
{
logger.LogError(e, "Error while trying to group event range {EventRange} for projection shard {ShardName}", range, Name);
});
return group;
}
private void startRange(long floor, long ceiling)
{
var range = new EventRange(_shardName, floor, ceiling);
LastEnqueued = range.SequenceCeiling;
_inFlight.Enqueue(range);
_agent.StartRange(range);
}
public TenantedEventRange(IDocumentStore store, IProjection projection, EventRange range,
CancellationToken shardCancellation) : base(range, shardCancellation)
{
_store = (DocumentStore)store;
_projection = projection;
buildGroups();
}
public void StartRange(EventRange range)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Enqueued processing of " + range);
}
_loader.Post(range);
}
public TenantedEventRangeGroup(IDocumentStore store, IMartenDatabase daemonDatabase, IProjection projection,
EventRange range,
CancellationToken shardCancellation) : base(range, shardCancellation)
{
_store = (DocumentStore)store;
_daemonDatabase = daemonDatabase;
_projection = projection ?? throw new ArgumentNullException(nameof(projection));
buildGroups();
}
public void EventRangeUpdated(EventRange range)
{
LastCommitted = range.SequenceCeiling;
if (Equals(range, _inFlight.Peek()))
{
_inFlight.Dequeue();
}
enqueueNewEventRanges();
}
public void StartRange(EventRange range)
{
if (_cancellation.IsCancellationRequested) return;
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Enqueued processing of {Range}", range);
}
_loader.Post(range);
}
private async Task <EventRange> loadEvents(EventRange range)
{
var parameters = new ActionParameters(this, async() =>
{
await _fetcher !.Load(range, _cancellation).ConfigureAwait(false);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Loaded events {Range} for {ProjectionShardIdentity}", range, ProjectionShardIdentity);
}
})
public void StartRange(EventRange range)
{
if (_cancellation.IsCancellationRequested)
{
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Enqueued processing {Range} for {ProjectionShardIdentity}", range, ProjectionShardIdentity);
}
_loader.Post(range);
}
internal ProjectionUpdateBatch(EventGraph events, DocumentSessionBase session, EventRange range)
{
Range = range;
_session = session;
Queue = new ActionBlock <IStorageOperation>(processOperation,
new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = 1, EnsureOrdered = true
});
startNewPage(session);
var progressOperation = range.BuildProgressionOperation(events);
Queue.Post(progressOperation);
}
public async Task Load(EventRange range, CancellationToken token)
{
if (_session == null)
{
reset();
}
_cancellation.CancelAfter(5.Seconds());
// There's an assumption here that this method is only called sequentially
// and never at the same time on the same instance
_statement.Range = range;
range.Events = await _session.ExecuteHandlerAsync(_handler, token);
}
public async Task Load(ShardName projectionShardName, EventRange range, CancellationToken token)
{
using var session = (QuerySession)_store.QuerySession();
// There's an assumption here that this method is only called sequentially
// and never at the same time on the same instance
_statement.Range = range;
try
{
range.Events = new List <IEvent>(await session.ExecuteHandlerAsync(_handler, token).ConfigureAwait(false));
}
catch (Exception e)
{
throw new EventFetcherException(projectionShardName, e);
}
}
internal ProjectionUpdateBatch(EventGraph events, DaemonSettings settings,
DocumentSessionBase session, EventRange range, CancellationToken token, ShardExecutionMode mode)
{
Range = range;
_settings = settings;
_session = session;
_token = token;
_mode = mode;
Queue = new ActionBlock <IStorageOperation>(processOperation,
new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = 1, EnsureOrdered = true, CancellationToken = token
});
startNewPage(session);
var progressOperation = range.BuildProgressionOperation(events);
Queue.Post(progressOperation);
}
private async Task <EventRange> loadEvents(EventRange range)
{
try
{
// TODO -- resiliency here.
await _fetcher.Load(range, _cancellationSource.Token);
}
catch (Exception e)
{
_logger.LogError(e, "Error loading events for " + range);
// TODO -- retry? circuit breaker?
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"Loaded events for {range}");
}
return(range);
}
private T groupEventRange(EventRange range)
{
if (_token.IsCancellationRequested)
{
return(null);
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"Shard '{ProjectionOrShardName}': Starting to slice {range}");
}
var group = applyGrouping(range);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"Shard '{ProjectionOrShardName}': successfully sliced {range}");
}
return(group);
}
public async Task Load(ShardName projectionShardName, EventRange range, CancellationToken token)
{
if (_session == null)
{
reset();
}
_cancellation.CancelAfter(5.Seconds());
// There's an assumption here that this method is only called sequentially
// and never at the same time on the same instance
_statement.Range = range;
try
{
range.Events = await _session.ExecuteHandlerAsync(_handler, token);
}
catch (Exception e)
{
throw new EventFetcherException(projectionShardName, e);
}
}
private async Task<EventRange> loadEvents(EventRange range)
{
var parameters = new ActionParameters(this, async () =>
{
await _fetcher.Load(_projectionShard.Name, range, _cancellation);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Loaded events for {Range}", range);
}
})
{
LogAction = (logger, e) =>
{
logger.LogError(e, "Error loading events for {Range}", range);
}
};
await _daemon.TryAction(parameters);
return range;
}
private async Task <EventRange> loadEvents(EventRange range)
{
var parameters = new ActionParameters(this, async() =>
{
await _fetcher.Load(range, _cancellation).ConfigureAwait(false);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Loaded events {Range} for {ProjectionShardIdentity}", range, ProjectionShardIdentity);
}
})
{
LogAction = (logger, e) =>
{
logger.LogError(e, "Error loading events {Range} for {ProjectionShardIdentity}", range, ProjectionShardIdentity);
}
};
await _daemon.TryAction(parameters).ConfigureAwait(false);
return(range);
}
private async Task <T> groupEventRange(EventRange range)
{
if (_token.IsCancellationRequested)
{
return(null);
}
T group = null;
await _updater.TryAction(() =>
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Shard '{ShardName}':Starting to slice {Range}", Name, range);
}
group = applyGrouping(range);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Shard '{ShardName}': successfully slice {Range}", Name, range);
}
return(Task.CompletedTask);
}
catch (Exception e)
{
_logger.LogError(e, "Error while trying to group event range {EventRange} for projection shard {ShardName}", range, Name);
throw;
}
}, _token);
return(group);
}
public TenantedEventRange(EventGraph graph, ITenancy tenancy, EventRange range)
{
Range = range;
var byTenant = range.Events.GroupBy(x => x.TenantId);
foreach (var group in byTenant)
{
var tenant = tenancy[group.Key];
var actions = graph.StreamIdentity switch
{
StreamIdentity.AsGuid => group.GroupBy(x => x.StreamId)
.Select(events => StreamAction.For(events.Key, events.ToList())),
StreamIdentity.AsString => group.GroupBy(x => x.StreamKey)
.Select(events => StreamAction.For(events.Key, events.ToList())),
_ => null
};
Groups.Add(new TenantActionGroup(tenant, actions));
}
}
protected bool Equals(EventRange other)
{
return(Equals(ShardName, other.ShardName) && SequenceFloor == other.SequenceFloor && SequenceCeiling == other.SequenceCeiling);
}
public ProjectionUpdateBatch StartNewBatch(EventRange range)
{
var session = _store.LightweightSession();
return(new ProjectionUpdateBatch(_store.Events, (DocumentSessionBase)session, range));
}
protected abstract T applyGrouping(EventRange range);
protected EventRangeGroup(EventRange range, CancellationToken parent)
{
_parent = parent;
Range = range;
}
protected override TenantedEventRange applyGrouping(EventRange range)
{
return(new(Store.Events, Store.Tenancy, range));
}
protected bool Equals(EventRange other)
{
return(ProjectionOrShardName == other.ProjectionOrShardName && SequenceFloor == other.SequenceFloor && SequenceCeiling == other.SequenceCeiling);
}