private void ReadUsersForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted result)
{
if (_aborted)
return;
switch (result.Result)
{
case ReadStreamResult.Success:
if (!result.IsEndOfStream)
BeginReadForward(result.NextEventNumber);
foreach (var loginName in from eventData in result.Events
let @event = eventData.Event
where @event.EventType == UserEventType
let stringData = Helper.UTF8NoBom.GetString(@event.Data)
select stringData)
BeginReadUserDetails(loginName);
break;
case ReadStreamResult.NoStream:
Abort(UserManagementMessage.Error.NotFound);
break;
default:
Abort(UserManagementMessage.Error.Error);
break;
}
_activeRequests--;
TryComplete();
}
public InspectionResult InspectPackage(TcpPackage package)
{
try
{
if (package.Command != TcpCommand.ReadStreamEventsForwardCompleted)
{
return(new InspectionResult(InspectionDecision.NotifyError,
new CommandNotExpectedException(TcpCommand.ReadStreamEventsForwardCompleted.ToString(),
package.Command.ToString())));
}
var data = package.Data;
var dto = data.Deserialize <ClientMessage.ReadStreamEventsForwardCompleted>();
_result = dto;
switch ((RangeReadResult)dto.Result)
{
case RangeReadResult.Success:
case RangeReadResult.StreamDeleted:
case RangeReadResult.NoStream:
return(new InspectionResult(InspectionDecision.Succeed));
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception e)
{
return(new InspectionResult(InspectionDecision.NotifyError, e));
}
}
protected static long?GetLastCommitPositionFrom(ClientMessage.ReadStreamEventsForwardCompleted msg)
{
return((msg.IsEndOfStream ||
msg.Result == ReadStreamResult.NoStream ||
msg.Result == ReadStreamResult.StreamDeleted)
? (msg.LastCommitPosition == -1 ? (long?)null : msg.LastCommitPosition)
: (long?)null);
}
private static TcpPackage WrapReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg)
{
var dto = new TcpClientMessageDto.ReadStreamEventsCompleted(
ConvertToResolvedIndexedEvents(msg.Events), (TcpClientMessageDto.ReadStreamEventsCompleted.ReadStreamResult)msg.Result,
msg.NextEventNumber, msg.LastEventNumber, msg.IsEndOfStream, msg.TfLastCommitPosition, msg.Error);
return(new TcpPackage(TcpCommand.ReadStreamEventsForwardCompleted, msg.CorrelationId, dto.Serialize()));
}
public void Handle(ClientMessage.ReadStreamEventsForwardCompleted message)
{
EventDistributionPoint distributionPoint;
if (_distributionPoints.TryGetValue(message.CorrelationId, out distributionPoint))
{
distributionPoint.Handle(message);
}
}
private static TcpPackage WrapReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg)
{
var dto = new ClientMessageDto.ReadStreamEventsForwardCompleted(msg.EventStreamId,
msg.Events,
msg.Result,
msg.LastCommitPosition);
return(new TcpPackage(TcpCommand.ReadStreamEventsForwardCompleted, msg.CorrelationId, dto.Serialize()));
}
public ClientMessage.ReadStreamEventsForwardCompleted CreateReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForward msg)
{
var lastEventNumber = msg.FromEventNumber + 1;
var nextEventNumber = lastEventNumber + 1;
var events = IODispatcherTestHelpers.CreateResolvedEvent(msg.EventStreamId, "event_type", "test", eventNumber: 10);
var res = new ClientMessage.ReadStreamEventsForwardCompleted(msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber,
msg.MaxCount, ReadStreamResult.Success, events, null, false, String.Empty, nextEventNumber, lastEventNumber, false, 0);
return(res);
}
private void ReadCompleted(ClientMessage.ReadStreamEventsForwardCompleted onReadCompleted,
Action onEmittedStreamsDeleted)
{
if (onReadCompleted.Result == ReadStreamResult.Success ||
onReadCompleted.Result == ReadStreamResult.NoStream)
{
if (onReadCompleted.Events.Length == 0 && !onReadCompleted.IsEndOfStream)
{
DeleteEmittedStreamsFrom(onReadCompleted.NextEventNumber, onEmittedStreamsDeleted);
return;
}
if (onReadCompleted.Events.Length == 0)
{
_ioDispatcher.DeleteStream(_emittedStreamsCheckpointStreamId, ExpectedVersion.Any, false,
SystemAccounts.System, x => {
if (x.Result == OperationResult.Success || x.Result == OperationResult.StreamDeleted)
{
Log.Information("PROJECTIONS: Projection Stream '{stream}' deleted",
_emittedStreamsCheckpointStreamId);
}
else
{
Log.Error("PROJECTIONS: Failed to delete projection stream '{stream}'. Reason: {e}",
_emittedStreamsCheckpointStreamId, x.Result);
}
_ioDispatcher.DeleteStream(_emittedStreamsId, ExpectedVersion.Any, false,
SystemAccounts.System, y => {
if (y.Result == OperationResult.Success ||
y.Result == OperationResult.StreamDeleted)
{
Log.Information("PROJECTIONS: Projection Stream '{stream}' deleted",
_emittedStreamsId);
}
else
{
Log.Error(
"PROJECTIONS: Failed to delete projection stream '{stream}'. Reason: {e}",
_emittedStreamsId, y.Result);
}
onEmittedStreamsDeleted();
});
});
}
else
{
var streamId = Helper.UTF8NoBom.GetString(onReadCompleted.Events[0].Event.Data.Span);
_ioDispatcher.DeleteStream(streamId, ExpectedVersion.Any, false, SystemAccounts.System,
x => DeleteStreamCompleted(x, onEmittedStreamsDeleted, streamId,
onReadCompleted.Events[0].OriginalEventNumber));
}
}
}
private void ReadDataStreamCompleted(ClientMessage.ReadStreamEventsForwardCompleted completed)
{
_dataReadRequestId = Guid.Empty;
if (Paused)
{
throw new InvalidOperationException("Paused");
}
switch (completed.Result)
{
case ReadStreamResult.AccessDenied:
SendNotAuthorized();
return;
case ReadStreamResult.NoStream:
_dataNextSequenceNumber = int.MaxValue;
if (completed.LastEventNumber >= 0)
{
SendPartitionDeleted(_dataStreamName, -1, null, null, null, null);
}
PauseOrContinueProcessing();
break;
case ReadStreamResult.StreamDeleted:
_dataNextSequenceNumber = int.MaxValue;
SendPartitionDeleted(_dataStreamName, -1, null, null, null, null);
PauseOrContinueProcessing();
break;
case ReadStreamResult.Success:
foreach (var e in completed.Events)
{
DeliverEvent(e, 17.7f);
if (CheckEnough())
{
return;
}
}
if (completed.IsEndOfStream)
{
_dataNextSequenceNumber = int.MaxValue;
}
else
{
_dataNextSequenceNumber = completed.NextEventNumber;
}
PauseOrContinueProcessing();
break;
default:
throw new NotSupportedException();
}
}
private static TcpPackage WrapReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg)
{
var dto = new TcpClientMessageDto.ReadStreamEventsForwardCompleted(msg.EventStreamId,
ConvertToDtos(msg.Events),
(int)msg.Result,
msg.NextEventNumber,
msg.LastEventNumber,
msg.IsEndOfStream,
msg.LastCommitPosition);
return(new TcpPackage(TcpCommand.ReadStreamEventsForwardCompleted, msg.CorrelationId, dto.Serialize()));
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_ioDispatcher.ReadForward(
_eventStreamId, _fromEventNumber, _maxCount, true, _principal,
res => _result = res,
() => _hasTimedOut = true,
Guid.NewGuid()
);
_readForward.Envelope.ReplyWith(CreateReadStreamEventsForwardCompleted(_readForward));
}
public static FeedElement ToStreamEventForwardFeed(ClientMessage.ReadStreamEventsForwardCompleted msg,
Uri requestedUrl, EmbedLevel embedContent)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null
? msg.Events[0].Event.TimeStamp
: DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.SetHeadOfStream(msg.IsEndOfStream);
var prevEventNumber = Math.Min(msg.FromEventNumber + msg.MaxCount - 1, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - 1;
feed.AddLink("self", self);
feed.AddLink("first",
HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (nextEventNumber >= 0)
{
feed.AddLink("last",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber,
msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
{
feed.AddLink("previous",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber,
msg.MaxCount));
}
if (!escapedStreamId.StartsWith("$$"))
{
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
}
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return(feed);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var step = _ioDispatcher.BeginReadForward(
_cancellationScope, _eventStreamId, _fromEventNumber, _maxCount, true, _principal,
res => _result = res,
() => _hasTimedOut = true
);
IODispatcherAsync.Run(step);
_readForward.Envelope.ReplyWith(CreateReadStreamEventsForwardCompleted(_readForward));
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var mre = new ManualResetEvent(false);
_ioDispatcher.ReadForward(
_eventStreamId, _fromEventNumber, _maxCount, true, _principal,
res => { _result = res; mre.Set(); },
() => { _hasTimedOut = true; mre.Set(); },
Guid.NewGuid()
);
_readForward.Envelope.ReplyWith(CreateReadStreamEventsForwardCompleted(_readForward));
mre.WaitOne(TimeSpan.FromSeconds(10));
}
when_wrapping_read_stream_events_forward_and_stream_was_deleted_should_not_downgrade_last_event_number_for_v2_clients()
{
var msg = new ClientMessage.ReadStreamEventsForwardCompleted(Guid.NewGuid(), "test-stream", 0, 100,
ReadStreamResult.StreamDeleted, new ResolvedEvent[0], new StreamMetadata(),
true, "", -1, long.MaxValue, true, 1000);
var package = _dispatcher.WrapMessage(msg, (byte)ClientVersion.V2);
Assert.IsNotNull(package, "Package is null");
Assert.AreEqual(TcpCommand.ReadStreamEventsForwardCompleted, package.Value.Command, "TcpCommand");
var dto = package.Value.Data.Deserialize <TcpClientMessageDto.ReadStreamEventsCompleted>();
Assert.IsNotNull(dto, "DTO is null");
Assert.AreEqual(long.MaxValue, dto.LastEventNumber, "Last Event Number");
}
public virtual void Handle(ClientMessage.ReadStreamEventsForward message)
{
ClientMessage.ReadStreamEventsForwardCompleted reply;
if (!_hasReadForward)
{
_hasReadForward = true;
var events = IODispatcherTestHelpers.CreateResolvedEvent(message.EventStreamId, ProjectionEventTypes.ProjectionCheckpoint, _testStreamName);
reply = new ClientMessage.ReadStreamEventsForwardCompleted(message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount,
ReadStreamResult.Success, events, null, false, String.Empty, message.FromEventNumber + 1, message.FromEventNumber, true, 1000);
}
else
{
reply = new ClientMessage.ReadStreamEventsForwardCompleted(message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount,
ReadStreamResult.Success, new ResolvedEvent[] {}, null, false, String.Empty, message.FromEventNumber, message.FromEventNumber, true, 1000);
}
message.Envelope.ReplyWith(reply);
}
public void FetchCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg)
{
switch (msg.Result)
{
case ReadStreamResult.Success:
case ReadStreamResult.NoStream:
_onFetchCompleted(_skipFirstEvent ? msg.Events.Skip(1).ToArray() : msg.Events, new PersistentSubscriptionSingleStreamPosition(msg.NextEventNumber), msg.IsEndOfStream);
break;
case ReadStreamResult.AccessDenied:
_onError($"Read access denied for stream: {msg.EventStreamId}");
break;
default:
_onError(msg.Error ?? $"Error reading stream: {msg.EventStreamId} at event number: {msg.FromEventNumber}");
break;
}
}
private void ReadForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted completed)
{
if (_cancellationScope.Cancelled(completed.CorrelationId))
{
return;
}
if (completed.CorrelationId != _correlationId)
{
return;
}
_correlationId = Guid.Empty;
if (completed.Result == ReadStreamResult.Success ||
completed.Result == ReadStreamResult.NoStream)
{
_readFrom = completed.NextEventNumber == -1 ? 0 : completed.NextEventNumber;
if (completed.Result == ReadStreamResult.Success)
{
foreach (var e in completed.Events)
{
PublishCommand(e);
}
}
if (completed.IsEndOfStream)
{
var subscribeFrom = new TFPos(
completed.TfLastCommitPosition,
completed.TfLastCommitPosition);
SubscribeAwake(subscribeFrom);
}
else
{
ReadForward();
}
}
else
{
Log.Error("Failed reading stream {stream}. Read result: {readResult}, Error: '{e}'",
ProjectionNamesBuilder._projectionsMasterStream, completed.Result, completed.Error);
ReadForward();
}
}
public static ClientMessage.ReadStreamEventsForwardCompleted ReadStreamEventsForward(MiniClusterNode node, string streamId)
{
ClientMessage.ReadStreamEventsForwardCompleted readResult = null;
var resetEvent = new ManualResetEventSlim();
var read = new ClientMessage.ReadStreamEventsForward(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(msg =>
{
readResult = (ClientMessage.ReadStreamEventsForwardCompleted)msg;
resetEvent.Set();
}), streamId, 0, 10,
false, false, null, SystemAccount.Principal);
node.Node.MainQueue.Publish(read);
if (!resetEvent.Wait(_timeout))
{
Assert.Fail("Timed out waiting for the stream to be read forward");
return(null);
}
return(readResult);
}
private void ReadCatalogCompleted(ClientMessage.ReadStreamEventsForwardCompleted completed)
{
_catalogReadRequestId = Guid.Empty;
if (Paused)
{
throw new InvalidOperationException("Paused");
}
switch (completed.Result)
{
case ReadStreamResult.AccessDenied:
SendNotAuthorized();
return;
case ReadStreamResult.NoStream:
case ReadStreamResult.StreamDeleted:
_catalogEof = true;
SendEof();
return;
case ReadStreamResult.Success:
_limitingCommitPosition = _limitingCommitPosition ?? completed.TfLastCommitPosition;
foreach (var e in completed.Events)
{
EnqueueStreamForProcessing(e);
}
if (completed.IsEndOfStream)
{
_catalogEof = true;
}
PauseOrContinueProcessing();
break;
default:
throw new NotSupportedException();
}
}
private IEnumerable <IODispatcherAsync.Step> ControlSteps(Guid instanceCorrelationId)
{
long fromEventNumber = 0;
Log.Debug("PROJECTIONS: Starting read {stream}", ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId));
long subscribeFrom = 0;
while (!_stopped)
{
ClientMessage.ReadStreamEventsForwardCompleted readResultForward = null;
var success = false;
while (!success)
{
yield return
(_ioDispatcher.BeginReadForward(
_cancellationScope,
ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId),
fromEventNumber,
1,
false,
SystemAccount.Principal,
completed => {
readResultForward = completed;
success = true;
},
() => Log.Warn("Read forward of stream {stream} timed out. Retrying",
ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId))));
}
if (readResultForward.Result != ReadStreamResult.Success &&
readResultForward.Result != ReadStreamResult.NoStream)
{
throw new Exception("Control reader failed. Read result: " + readResultForward.Result);
}
if (readResultForward.Events != null && readResultForward.Events.Length > 0)
{
var doWriteRegistration =
readResultForward.Events.Any(v => v.Event.EventType == "$response-reader-started");
fromEventNumber = readResultForward.NextEventNumber;
subscribeFrom = readResultForward.TfLastCommitPosition;
if (doWriteRegistration)
{
var events = new[] {
new Event(
Guid.NewGuid(), "$projection-worker-started", true,
"{\"id\":\"" + _coreServiceId + "\"}", null)
};
yield return
(_ioDispatcher.BeginWriteEvents(
_cancellationScope,
ProjectionNamesBuilder._projectionsMasterStream,
ExpectedVersion.Any,
SystemAccount.Principal,
events,
r => { }));
}
break;
}
if (readResultForward.Result == ReadStreamResult.Success)
{
subscribeFrom = readResultForward.TfLastCommitPosition;
}
yield return
(_ioDispatcher.BeginSubscribeAwake(
_cancellationScope,
ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId),
new TFPos(subscribeFrom, subscribeFrom),
message => { }));
}
}
private IEnumerable <IODispatcherAsync.Step> ControlSteps()
{
ClientMessage.ReadStreamEventsBackwardCompleted readResult = null;
yield return
(_ioDispatcher.BeginReadBackward(
_cancellationScope,
ProjectionNamesBuilder._projectionsControlStream,
-1,
1,
false,
SystemAccount.Principal,
completed => readResult = completed));
int fromEventNumber;
if (readResult.Result == ReadStreamResult.NoStream)
{
fromEventNumber = 0;
}
else
{
if (readResult.Result != ReadStreamResult.Success)
{
throw new Exception("Cannot start control reader. Read result: " + readResult.Result);
}
fromEventNumber = readResult.LastEventNumber + 1;
}
DebugLogger.Log("Starting read control from: " + fromEventNumber);
//TODO: handle shutdown here and in other readers
long subscribeFrom = 0;
var doWriteRegistration = true;
while (!_stopped)
{
if (doWriteRegistration)
{
var events = new[]
{
new Event(
Guid.NewGuid(),
"$projection-worker-started",
true,
"{\"id\":\"" + _coreServiceId + "\"}",
null)
};
DebugLogger.Log("Registering worker " + _coreServiceId);
// ClientMessage.WriteEventsCompleted response = null;
yield return
(_ioDispatcher.BeginWriteEvents(
_cancellationScope,
ProjectionNamesBuilder._projectionsMasterStream,
ExpectedVersion.Any,
SystemAccount.Principal,
events,
r => { }));
DebugLogger.Log("Worker registered: ");
}
do
{
ClientMessage.ReadStreamEventsForwardCompleted readResultForward = null;
yield return
(_ioDispatcher.BeginReadForward(
_cancellationScope,
ProjectionNamesBuilder._projectionsControlStream,
fromEventNumber,
1,
false,
SystemAccount.Principal,
completed => readResultForward = completed));
DebugLogger.Log("Control stream read forward result: " + readResultForward.Result);
if (readResultForward.Result != ReadStreamResult.Success &&
readResultForward.Result != ReadStreamResult.NoStream)
{
throw new Exception("Control reader failed. Read result: " + readResultForward.Result);
}
if (readResultForward.Events != null && readResultForward.Events.Length > 0)
{
doWriteRegistration =
readResultForward.Events.Any(v => v.Event.EventType == "$response-reader-started");
fromEventNumber = readResultForward.NextEventNumber;
subscribeFrom = readResultForward.TfLastCommitPosition;
break;
}
if (readResultForward.Result == ReadStreamResult.Success)
{
subscribeFrom = readResultForward.TfLastCommitPosition;
}
DebugLogger.Log("Awaiting control stream");
yield return
(_ioDispatcher.BeginSubscribeAwake(
_cancellationScope,
ProjectionNamesBuilder._projectionsControlStream,
new TFPos(subscribeFrom, subscribeFrom),
message => { }));
DebugLogger.Log("Control stream await completed");
} while (!_stopped);
}
}
public override void Handle(ClientMessage.ReadStreamEventsForwardCompleted message)
{
}
public void FetchCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg)
{
//TODO mark error?
_onFetchCompleted(msg.Events, msg.NextEventNumber, msg.IsEndOfStream);
}
public override void Handle(ClientMessage.ReadStreamEventsForwardCompleted message)
{
if (_disposed)
{
return;
}
if (!_eventsRequested)
{
throw new InvalidOperationException("Read events has not been requested");
}
if (message.EventStreamId != _streamName)
{
throw new InvalidOperationException(
string.Format("Invalid stream name: {0}. Expected: {1}", message.EventStreamId, _streamName));
}
if (_paused)
{
throw new InvalidOperationException("Paused");
}
_eventsRequested = false;
switch (message.Result)
{
case RangeReadResult.NoStream:
DeliverSafeJoinPosition(message.LastCommitPosition.Value); // allow joining heading distribution
if (_pauseRequested)
{
_paused = true;
}
else
{
RequestEvents(delay: true);
}
break;
case RangeReadResult.Success:
if (message.Events.Length == 0)
{
// the end
DeliverSafeJoinPosition(message.LastCommitPosition.Value);
}
else
{
for (int index = 0; index < message.Events.Length; index++)
{
var @event = message.Events[index].Event;
var @link = message.Events[index].Link;
DeliverEvent(@event, @link, 100.0f * (link ?? @event).EventNumber / message.LastEventNumber);
}
}
if (_pauseRequested)
{
_paused = true;
}
else if (message.Events.Length == 0)
{
RequestEvents(delay: true);
}
else
{
_publisher.Publish(CreateTickMessage());
}
break;
default:
throw new NotSupportedException(
string.Format("ReadEvents result code was not recognized. Code: {0}", message.Result));
}
}
public override void Handle(ClientMessage.ReadStreamEventsForwardCompleted message)
{
if (_disposed)
{
return;
}
if (!_streams.Contains(message.EventStreamId))
{
throw new InvalidOperationException(string.Format("Invalid stream name: {0}", message.EventStreamId));
}
if (!_eventsRequested.Contains(message.EventStreamId))
{
throw new InvalidOperationException("Read events has not been requested");
}
if (_paused)
{
throw new InvalidOperationException("Paused");
}
_eventsRequested.Remove(message.EventStreamId);
switch (message.Result)
{
case RangeReadResult.NoStream:
UpdateSafePositionToJoin(message.EventStreamId, message.LastCommitPosition.Value);
ProcessBuffers();
if (_pauseRequested)
{
_paused = true;
}
else
{
RequestEvents(message.EventStreamId, delay: true);
}
_publisher.Publish(CreateTickMessage());
break;
case RangeReadResult.Success:
if (message.Events.Length == 0)
{
// the end
UpdateSafePositionToJoin(message.EventStreamId, message.LastCommitPosition.Value);
}
else
{
for (int index = 0; index < message.Events.Length; index++)
{
var @event = message.Events[index].Event;
var @link = message.Events[index].Link;
EventRecord positionEvent = (link ?? @event);
UpdateSafePositionToJoin(positionEvent.EventStreamId, positionEvent.LogPosition);
Queue <Tuple <EventRecord, EventRecord, float> > queue;
if (!_buffers.TryGetValue(positionEvent.EventStreamId, out queue))
{
queue = new Queue <Tuple <EventRecord, EventRecord, float> >();
_buffers.Add(positionEvent.EventStreamId, queue);
}
//TODO: progress calculation below is incorrect. sum(current)/sum(last_event) where sum by all streams
queue.Enqueue(Tuple.Create(@event, positionEvent, 100.0f * (link ?? @event).EventNumber / message.LastEventNumber));
}
}
ProcessBuffers();
if (_pauseRequested)
{
_paused = true;
}
else if (message.Events.Length == 0)
{
RequestEvents(message.EventStreamId, delay: true);
}
_publisher.Publish(CreateTickMessage());
break;
default:
throw new NotSupportedException(
string.Format("ReadEvents result code was not recognized. Code: {0}", message.Result));
}
}
