public async Task HandleAsync(ReadStreamQuery query, ReadStreamResult streamResult, CancellationToken cancellationToken)
{
using (iterationMetric?.For("transform_time").Measure())
{
var resultingEvents = streamResult.Payload.Events as IEnumerable <HerculesEvent>;
if (settings.Filter != null)
{
resultingEvents = resultingEvents.Where(settings.Filter);
}
if (settings.Transformer != null)
{
resultingEvents = resultingEvents.SelectMany(Transform);
}
buffer.Clear();
buffer.AddRange(resultingEvents);
}
if (buffer.Count == 0)
{
return;
}
using (iterationMetric?.For("write_time").Measure())
{
await writer.WriteEvents(buffer, cancellationToken).ConfigureAwait(false);
}
log.Info("Inserted {EventsCount} event(s) into target stream '{TargetStream}'.", buffer.Count, settings.TargetStreamName);
eventsMetric?.For("out").Add(buffer.Count);
buffer.Clear();
}
private void ReadIndexCheckpointStreamCompleted(
ReadStreamResult result, EventStore.Core.Data.ResolvedEvent[] events)
{
if (_disposed)
{
return;
}
if (!_indexCheckpointStreamRequested)
{
throw new InvalidOperationException("Read index checkpoint has not been requested");
}
if (_reader.Paused)
{
throw new InvalidOperationException("Paused");
}
_indexCheckpointStreamRequested = false;
switch (result)
{
case ReadStreamResult.NoStream:
_reader.PauseOrContinueProcessing(delay: true);
_lastKnownIndexCheckpointPosition = default(TFPos);
break;
case ReadStreamResult.Success:
if (events.Length == 0)
{
if (_lastKnownIndexCheckpointPosition == null)
{
_lastKnownIndexCheckpointPosition = default(TFPos);
}
}
else
{
//NOTE: only one event if backward order was requested
foreach (var @event in events)
{
var data = @event.Event.Data.ParseCheckpointTagJson();
_lastKnownIndexCheckpointEventNumber = @event.Event.EventNumber;
_lastKnownIndexCheckpointPosition = data.Position;
// reset eofs before this point - probably some where updated so we cannot go
// forward with this position without making sure nothing appeared
// NOTE: performance is not very good, but we should switch to TF mode shortly
foreach (var key in _eofs.Keys.ToArray())
{
_eofs[key] = false;
}
}
}
_reader.PauseOrContinueProcessing(delay: events.Length == 0);
break;
default:
throw new NotSupportedException(
String.Format("ReadEvents result code was not recognized. Code: {0}", result));
}
}
public void Execute()
{
ReadStreamResult result = _readStreamStrategy.Read();
if (result.TemporaryFile != null)
{
_logger.DataContainer.FilesContainer.LogFile(result.TemporaryFile.FileName, _responseFileName);
}
else if (!string.IsNullOrEmpty(result.Content))
{
_logger.DataContainer.FilesContainer.LogAsFile(result.Content, _responseFileName);
}
}
SliceReadStatus Convert(ReadStreamResult result)
{
switch (result)
{
case ReadStreamResult.Success:
return(SliceReadStatus.Success);
case ReadStreamResult.NoStream:
return(SliceReadStatus.StreamNotFound);
case ReadStreamResult.StreamDeleted:
return(SliceReadStatus.StreamDeleted);
default:
throw new Exception(string.Format("Unexpected ReadStreamResult: {0}.", result));
}
}
public Task HandleAsync(ReadStreamQuery query, ReadStreamResult <T> streamResult, CancellationToken cancellationToken) => handler(query, streamResult, cancellationToken);
private void ReadIndexCheckpointStreamCompleted(
ReadStreamResult result, EventStore.Core.Data.ResolvedEvent[] events)
{
if (_disposed)
{
return;
}
if (!_indexCheckpointStreamRequested)
{
throw new InvalidOperationException("Read index checkpoint has not been requested");
}
if (_reader.Paused)
{
throw new InvalidOperationException("Paused");
}
_indexCheckpointStreamRequested = false;
switch (result)
{
case ReadStreamResult.NoStream:
_indexStreamEof = true;
_lastKnownIndexCheckpointPosition = default(TFPos);
ProcessBuffersAndContinue(null);
break;
case ReadStreamResult.Success:
if (events.Length == 0)
{
_indexStreamEof = true;
if (_lastKnownIndexCheckpointPosition == null)
{
_lastKnownIndexCheckpointPosition = default(TFPos);
}
}
else
{
_indexStreamEof = false;
//NOTE: only one event if backward order was requested
foreach (var @event in events)
{
var data = @event.Event.Data.ParseCheckpointTagJson();
_lastKnownIndexCheckpointEventNumber = @event.Event.EventNumber;
_lastKnownIndexCheckpointPosition = data.Position;
// reset eofs before this point - probably some where updated so we cannot go
// forward with this position without making sure nothing appeared
// NOTE: performance is not very good, but we should switch to TF mode shortly
foreach (var corrId in _validRequests)
{
_publisher.Publish(new AwakeServiceMessage.UnsubscribeAwake(corrId));
}
_validRequests.Clear();
_eventsRequested.Clear();
//TODO: cancel subscribeAwake
//TODO: reissue read requests
//TODO: make sure async completions of awake do not work
foreach (var key in _eofs.Keys.ToArray())
{
_eofs[key] = false;
}
}
}
ProcessBuffersAndContinue(null);
break;
default:
throw new NotSupportedException(
String.Format("ReadEvents result code was not recognized. Code: {0}", result));
}
}
public Task HandleAsync(ReadStreamQuery query, ReadStreamResult <HerculesEvent> streamResult, CancellationToken cancellationToken) => streamEventsHandler.HandleAsync(query, streamResult.FromGenericResult(), cancellationToken);
public async Task <(ReadStreamQuery query, ReadStreamResult <T> result)> ReadAsync(
StreamCoordinates coordinates,
StreamShardingSettings shardingSettings,
CancellationToken cancellationToken)
{
log.Info(
"Reading logical shard with index {ClientShard} from {ClientShardCount}.",
shardingSettings.ClientShardIndex,
shardingSettings.ClientShardCount);
log.Debug("Current coordinates: {StreamCoordinates}.", coordinates);
coordinates = await GetShardCoordinates(coordinates, shardingSettings, cancellationToken).ConfigureAwait(false);
log.Debug("Current shard coordinates: {StreamCoordinates}.", coordinates);
streamPartitionsCount = streamPartitionsCount ?? await GetPartitionsCount(cancellationToken).ConfigureAwait(false);
var current = coordinates.ToDictionary();
foreach (var partition in coordinates.Positions.Select(p => p.Partition))
{
var start = current.ContainsKey(partition) ? current[partition].Offset : 0;
var end = settings.End.ContainsKey(partition) ? settings.End[partition].Offset : 0;
if (start < end)
{
var count = end - start;
log.Info("Reading {EventsCount} events from partition #{Partition}.", count, partition);
var(query, result) = await streamReader.ReadAsync(
coordinates,
// ReSharper disable once PossibleInvalidOperationException
new StreamShardingSettings(partition, streamPartitionsCount.Value),
count,
cancellationToken)
.ConfigureAwait(false);
result.EnsureSuccess();
result = new ReadStreamResult <T>(
result.Status,
new ReadStreamPayload <T>(
result.Payload.Events,
coordinates.SetPosition(result.Payload.Next.Positions.Single())),
result.ErrorDetails);
query = new ReadStreamQuery(query.Name)
{
Coordinates = coordinates,
ClientShard = shardingSettings.ClientShardIndex,
ClientShardCount = shardingSettings.ClientShardCount
};
return(query, result);
}
}
return(null, null);
}
