private void RequestCheckpointStream(bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (_reader.PauseRequested || _reader.Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_indexCheckpointStreamRequested)
{
return;
}
_indexCheckpointStreamRequested = true;
Message readRequest;
if (_lastKnownIndexCheckpointEventNumber == -1)
{
readRequest = new ClientMessage.ReadStreamEventsBackward(
Guid.NewGuid(), _reader.EventReaderCorrelationId, new SendToThisEnvelope(this), "$et", -1, 1, false, false, null,
_readAs);
}
else
{
readRequest = new ClientMessage.ReadStreamEventsForward(
Guid.NewGuid(), _reader.EventReaderCorrelationId, new SendToThisEnvelope(this), "$et",
_lastKnownIndexCheckpointEventNumber + 1, 100, false, false, null, _readAs);
}
_reader.PublishIORequest(delay, readRequest);
}
private void RequestEvents(string stream, bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (_reader.PauseRequested || _reader.Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_eventsRequested.Contains(stream))
{
return;
}
Queue <PendingEvent> queue;
if (_buffers.TryGetValue(stream, out queue) && queue.Count > 0)
{
return;
}
_eventsRequested.Add(stream);
var readEventsForward = new ClientMessage.ReadStreamEventsForward(
Guid.NewGuid(), _reader.EventReaderCorrelationId, new SendToThisEnvelope(this), stream,
_reader._fromPositions[stream], _maxReadCount, _reader._resolveLinkTos, false, null,
_readAs);
_reader.PublishIORequest(delay, readEventsForward);
}
private void RequestEvents(bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (_eventsRequested)
{
throw new InvalidOperationException("Read operation is already in progress");
}
if (_pauseRequested || _paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
_eventsRequested = true;
var readEventsForward = new ClientMessage.ReadStreamEventsForward(
_distibutionPointCorrelationId, new SendToThisEnvelope(this), _streamName, _fromSequenceNumber,
_maxReadCount, _resolveLinkTos);
if (delay)
{
_publisher.Publish(
TimerMessage.Schedule.Create(
TimeSpan.FromMilliseconds(250), new PublishEnvelope(_publisher, crossThread: true), readEventsForward));
}
else
{
_publisher.Publish(readEventsForward);
}
}
public void Handle(ClientMessage.ReadStreamEventsForward message)
{
_externalRequestQueue.Publish(
new ClientMessage.ReadStreamEventsForward(
message.CorrelationId, new PublishToWrapEnvelop(_inputQueue, message.Envelope),
message.EventStreamId, message.FromEventNumber, message.MaxCount, message.ResolveLinks));
}
void IHandle <ClientMessage.ReadStreamEventsForward> .Handle(ClientMessage.ReadStreamEventsForward msg)
{
var res = ReadStreamEventsForward(msg);
switch (res.Result)
{
case ReadStreamResult.Success:
case ReadStreamResult.NoStream:
case ReadStreamResult.NotModified:
if (msg.LongPollTimeout.HasValue && res.FromEventNumber > res.LastEventNumber)
{
_publisher.Publish(new SubscriptionMessage.PollStream(
msg.EventStreamId, res.TfLastCommitPosition, res.LastEventNumber,
DateTime.UtcNow + msg.LongPollTimeout.Value, msg));
}
else
{
msg.Envelope.ReplyWith(res);
}
break;
case ReadStreamResult.StreamDeleted:
case ReadStreamResult.Error:
case ReadStreamResult.AccessDenied:
msg.Envelope.ReplyWith(res);
break;
default:
throw new ArgumentOutOfRangeException(string.Format("Unknown ReadStreamResult: {0}", res.Result));
}
}
private static ClientMessage.ReadStreamEventsForwardCompleted NoData(ClientMessage.ReadStreamEventsForward msg,
ReadStreamResult result, long lastCommitPosition, long lastEventNumber = -1, string error = null)
{
return(new ClientMessage.ReadStreamEventsForwardCompleted(
msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, result,
EmptyRecords, null, false, error ?? string.Empty, -1, lastEventNumber, true, lastCommitPosition));
}
public TcpPackage CreateNetworkPackage()
{
lock (_corrIdLock)
{
var dto = new ClientMessage.ReadStreamEventsForward(_stream, _start, _count, _resolveLinkTos);
return(new TcpPackage(TcpCommand.ReadStreamEventsForward, _correlationId, dto.Serialize()));
}
}
public override void Handle(ClientMessage.ReadStreamEventsForward message)
{
if (!_hasTimedOut)
{
return;
}
message.Envelope.ReplyWith(CreateResultCommandReadResponse(message));
}
public void Handle(ClientMessage.ReadStreamEventsForward msg)
{
_externalRequestQueue.Publish(
new ClientMessage.ReadStreamEventsForward(
msg.InternalCorrId, msg.CorrelationId, new PublishToWrapEnvelop(_inputQueue, msg.Envelope),
msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, msg.ResolveLinkTos, msg.RequireMaster,
msg.ValidationStreamVersion, msg.User));
}
private static void CheckEventsOrder(ClientMessage.ReadStreamEventsForward msg, IndexReadStreamResult result)
{
for (var index = 1; index < result.Records.Length; index++)
{
if (result.Records[index].EventNumber != result.Records[index - 1].EventNumber + 1)
{
throw new Exception(
$"Invalid order of events has been detected in read index for the event stream '{msg.EventStreamId}'. " +
$"The event {result.Records[index].EventNumber} at position {result.Records[index].LogPosition} goes after the event {result.Records[index - 1].EventNumber} at position {result.Records[index - 1].LogPosition}");
}
}
}
public override void Handle(ClientMessage.ReadStreamEventsForward message)
{
if (!_hasTimedOut)
{
_hasTimedOut = true;
_timedOutCorrelationId = message.CorrelationId;
return;
}
else
{
base.Handle(message);
}
}
private void RequestEvents(string stream, bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (PauseRequested || Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_eventsRequested.Contains(stream))
{
return;
}
Queue <Tuple <EventStore.Core.Data.ResolvedEvent, float> > queue;
if (_buffers.TryGetValue(stream, out queue) && queue.Count > 0)
{
return;
}
_eventsRequested.Add(stream);
var pendingRequestCorrelationId = Guid.NewGuid();
_pendingRequests[stream] = pendingRequestCorrelationId;
var readEventsForward = new ClientMessage.ReadStreamEventsForward(
Guid.NewGuid(), pendingRequestCorrelationId, new SendToThisEnvelope(this), stream,
_fromPositions.Streams[stream],
_maxReadCount, _resolveLinkTos, false, null, ReadAs);
if (delay)
{
_publisher.Publish(
new AwakeServiceMessage.SubscribeAwake(
new PublishEnvelope(_publisher, crossThread: true), Guid.NewGuid(), null,
new TFPos(_lastPosition, _lastPosition),
CreateReadTimeoutMessage(pendingRequestCorrelationId, stream)));
_publisher.Publish(
new AwakeServiceMessage.SubscribeAwake(
new PublishEnvelope(_publisher, crossThread: true), Guid.NewGuid(), null,
new TFPos(_lastPosition, _lastPosition), readEventsForward));
}
else
{
_publisher.Publish(readEventsForward);
ScheduleReadTimeoutMessage(pendingRequestCorrelationId, stream);
}
}
public ClientMessage.ReadStreamEventsForwardCompleted CreateReadStreamEventsForwardCompleted(
ClientMessage.ReadStreamEventsForward msg)
{
var lastEventNumber = msg.FromEventNumber + 1;
var nextEventNumber = lastEventNumber + 1;
var events =
IODispatcherTestHelpers.CreateResolvedEvent <TLogFormat, TStreamId>(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);
}
void IHandle <ClientMessage.ReadStreamEventsForward> .Handle(ClientMessage.ReadStreamEventsForward message)
{
var lastCommitPosition = _readIndex.LastCommitPosition;
EventRecord[] records;
var result = _readIndex.ReadStreamEventsForward(message.EventStreamId, message.FromEventNumber, message.MaxCount, out records);
var nextEventNumber = result == RangeReadResult.Success && records.Length > 0
? records[records.Length - 1].EventNumber + 1
: -1;
if (result == RangeReadResult.Success && records.Length > 1)
{
for (var index = 1; index < records.Length; index++)
{
if (records[index].EventNumber != records[index - 1].EventNumber + 1)
{
throw new Exception(string.Format(
"Invalid order of events has been detected in read index for the event stream '{0}'. "
+ "The event {1} at position {2} goes after the event {3} at position {4}",
message.EventStreamId,
records[index].EventNumber,
records[index].LogPosition,
records[index - 1].EventNumber,
records[index - 1].LogPosition));
}
}
}
EventLinkPair[] resolvedPairs;
if (result == RangeReadResult.Success && message.ResolveLinks)
{
resolvedPairs = ResolveLinkToEvents(records);
}
else
{
resolvedPairs = new EventLinkPair[records.Length];
for (int i = 0; i < records.Length; ++i)
{
resolvedPairs[i] = new EventLinkPair(records[i], null);
}
}
message.Envelope.ReplyWith(
new ClientMessage.ReadStreamEventsForwardCompleted(message.CorrelationId,
message.EventStreamId,
resolvedPairs,
result,
nextEventNumber,
records.Length == 0 ? lastCommitPosition : (long?)null));
}
private void RequestCheckpointStream(bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (_reader.PauseRequested || _reader.Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_indexCheckpointStreamRequested)
{
return;
}
_indexCheckpointStreamRequested = true;
var pendingRequestCorrelationId = Guid.NewGuid();
lock (_lock)
{
_pendingRequests["$et"] = pendingRequestCorrelationId;
}
Message readRequest;
if (_lastKnownIndexCheckpointEventNumber == -1)
{
readRequest = new ClientMessage.ReadStreamEventsBackward(
pendingRequestCorrelationId, pendingRequestCorrelationId, new SendToThisEnvelope(this), "$et", -1, 1, false, false, null,
_readAs);
}
else
{
readRequest = new ClientMessage.ReadStreamEventsForward(
pendingRequestCorrelationId, pendingRequestCorrelationId, new SendToThisEnvelope(this), "$et",
_lastKnownIndexCheckpointEventNumber + 1, 100, false, false, null, _readAs);
}
var timeoutMessage = TimerMessage.Schedule.Create(
TimeSpan.FromMilliseconds(ESConsts.ReadRequestTimeout),
new SendToThisEnvelope(this),
new ProjectionManagementMessage.Internal.ReadTimeout(pendingRequestCorrelationId, "$et"));
_reader.PublishIORequest(delay, readRequest, timeoutMessage, pendingRequestCorrelationId);
}
void IHandle <ClientMessage.ReadStreamEventsForward> .Handle(ClientMessage.ReadStreamEventsForward msg)
{
if (msg.Expires < DateTime.UtcNow)
{
if (LogExpiredMessage(msg.Expires))
{
Log.Debug(
"Read Stream Events Forward operation has expired for Stream: {stream}, From Event Number: {fromEventNumber}, Max Count: {maxCount}. Operation Expired at {expiryDateTime}",
msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, msg.Expires);
}
return;
}
using (HistogramService.Measure(_readerStreamRangeHistogram)) {
var res = ReadStreamEventsForward(msg);
switch (res.Result)
{
case ReadStreamResult.Success:
case ReadStreamResult.NoStream:
case ReadStreamResult.NotModified:
if (msg.LongPollTimeout.HasValue && res.FromEventNumber > res.LastEventNumber)
{
_publisher.Publish(new SubscriptionMessage.PollStream(
msg.EventStreamId, res.TfLastCommitPosition, res.LastEventNumber,
DateTime.UtcNow + msg.LongPollTimeout.Value, msg));
}
else
{
msg.Envelope.ReplyWith(res);
}
break;
case ReadStreamResult.StreamDeleted:
case ReadStreamResult.Error:
case ReadStreamResult.AccessDenied:
msg.Envelope.ReplyWith(res);
break;
default:
throw new ArgumentOutOfRangeException(
string.Format("Unknown ReadStreamResult: {0}", res.Result));
}
}
}
private void HandleAsNonMaster(ClientMessage.ReadStreamEventsForward message)
{
if (message.RequireMaster)
{
if (_master == null)
{
DenyRequestBecauseNotReady(message.Envelope, message.CorrelationId);
}
else
{
DenyRequestBecauseNotMaster(message.CorrelationId, message.Envelope);
}
}
else
{
_outputBus.Publish(message);
}
}
private void RequestEvents(string stream, bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (_reader.PauseRequested || _reader.Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_eventsRequested.Contains(stream))
{
return;
}
Queue <PendingEvent> queue;
if (_buffers.TryGetValue(stream, out queue) && queue.Count > 0)
{
return;
}
_eventsRequested.Add(stream);
var corrId = Guid.NewGuid();
_validRequests.Add(corrId);
lock (_lock)
{
_pendingRequests[stream] = corrId;
}
var readEventsForward = new ClientMessage.ReadStreamEventsForward(
corrId, corrId, new SendToThisEnvelope(this), stream,
_reader._fromPositions[stream], EventByTypeIndexEventReader.MaxReadCount, _reader._resolveLinkTos, false, null,
_readAs);
var timeoutMessage = TimerMessage.Schedule.Create(
TimeSpan.FromMilliseconds(ESConsts.ReadRequestTimeout),
new SendToThisEnvelope(this),
new ProjectionManagementMessage.Internal.ReadTimeout(corrId, stream));
_reader.PublishIORequest(delay, readEventsForward, timeoutMessage, corrId);
}
private ClientMessage.ReadStreamEventsForwardCompleted ReadStreamEventsForward(
ClientMessage.ReadStreamEventsForward msg)
{
using (HistogramService.Measure(_readerStreamRangeHistogram)) {
var lastCommitPosition = _readIndex.LastReplicatedPosition;
try {
if (msg.MaxCount > MaxPageSize)
{
throw new ArgumentException(string.Format("Read size too big, should be less than {0} items",
MaxPageSize));
}
if (msg.ValidationStreamVersion.HasValue &&
_readIndex.GetStreamLastEventNumber(msg.EventStreamId) == msg.ValidationStreamVersion)
{
return(NoData(msg, ReadStreamResult.NotModified, lastCommitPosition,
msg.ValidationStreamVersion.Value));
}
var access = _readIndex.CheckStreamAccess(msg.EventStreamId, StreamAccessType.Read, msg.User);
if (!access.Granted)
{
return(NoData(msg, ReadStreamResult.AccessDenied, lastCommitPosition));
}
var result =
_readIndex.ReadStreamEventsForward(msg.EventStreamId, msg.FromEventNumber, msg.MaxCount);
CheckEventsOrder(msg, result);
var resolvedPairs = ResolveLinkToEvents(result.Records, msg.ResolveLinkTos, msg.User);
if (resolvedPairs == null)
{
return(NoData(msg, ReadStreamResult.AccessDenied, lastCommitPosition));
}
return(new ClientMessage.ReadStreamEventsForwardCompleted(
msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber, msg.MaxCount,
(ReadStreamResult)result.Result, resolvedPairs, result.Metadata, access.Public, string.Empty,
result.NextEventNumber, result.LastEventNumber, result.IsEndOfStream, lastCommitPosition));
} catch (Exception exc) {
Log.ErrorException(exc, "Error during processing ReadStreamEventsForward request.");
return(NoData(msg, ReadStreamResult.Error, lastCommitPosition, error: exc.Message));
}
}
}
public ClientMessage.ReadStreamEventsForwardCompleted CreateResultCommandReadResponse(
ClientMessage.ReadStreamEventsForward message)
{
var result = new PartitionProcessingResultResponse {
SubscriptionId = Guid.NewGuid().ToString("N"),
Partition = "teststream",
CausedBy = Guid.NewGuid().ToString("N"),
Position = CheckpointTag.Empty,
Result = "result"
};
var data = JsonConvert.SerializeObject(result);
var evnts = IODispatcherTestHelpers.CreateResolvedEvent(_streamId, "$result", data);
return(new ClientMessage.ReadStreamEventsForwardCompleted(message.CorrelationId, message.EventStreamId,
message.FromEventNumber, message.MaxCount,
ReadStreamResult.Success, evnts, null, false, String.Empty, message.FromEventNumber + 1,
message.FromEventNumber, true, 10000));
}
public Task <StreamEventsSlice> ReadStreamEventsForwardAsync(string stream, int start, int count, bool resolveLinkTos, UserCredentials userCredentials = null)
{
Ensure.NotNullOrEmpty(stream, "stream");
Ensure.Nonnegative(start, "start");
Ensure.Positive(count, "count");
var source = new TaskCompletionSource <StreamEventsSlice>();
var envelope = new EmbeddedResponseEnvelope(new EmbeddedResponders.ReadStreamForwardEvents(source, stream, start));
Guid corrId = Guid.NewGuid();
var message = new ClientMessage.ReadStreamEventsForward(corrId, corrId, envelope,
stream, start, count, resolveLinkTos, false, null, SystemAccount.Principal);
_publisher.Publish(message);
return(source.Task);
}
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 RequestEvents(string stream, bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (PauseRequested || Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_eventsRequested.Contains(stream))
{
return;
}
Queue <Tuple <EventRecord, EventRecord, float> > queue;
if (_buffers.TryGetValue(stream, out queue) && queue.Count > 0)
{
return;
}
_eventsRequested.Add(stream);
var readEventsForward = new ClientMessage.ReadStreamEventsForward(
Guid.NewGuid(), EventReaderCorrelationId, new SendToThisEnvelope(this), stream, _fromPositions.Streams[stream],
_maxReadCount, _resolveLinkTos, false, null, ReadAs);
if (delay)
{
_publisher.Publish(
TimerMessage.Schedule.Create(
TimeSpan.FromMilliseconds(250), new PublishEnvelope(_publisher, crossThread: true),
readEventsForward));
}
else
{
_publisher.Publish(readEventsForward);
}
}
void IHandle <ClientMessage.ReadStreamEventsForward> .Handle(ClientMessage.ReadStreamEventsForward message)
{
var lastCommitPosition = _readIndex.LastCommitPosition;
var result = _readIndex.ReadStreamEventsForward(message.EventStreamId, message.FromEventNumber, message.MaxCount);
if (result.Result == RangeReadResult.Success && result.Records.Length > 1)
{
var records = result.Records;
for (var index = 1; index < records.Length; index++)
{
if (records[index].EventNumber != records[index - 1].EventNumber + 1)
{
throw new Exception(string.Format(
"Invalid order of events has been detected in read index for the event stream '{0}'. "
+ "The event {1} at position {2} goes after the event {3} at position {4}",
message.EventStreamId,
records[index].EventNumber,
records[index].LogPosition,
records[index - 1].EventNumber,
records[index - 1].LogPosition));
}
}
}
var resolvedPairs = ResolveLinkToEvents(result.Records, message.ResolveLinks);
message.Envelope.ReplyWith(
new ClientMessage.ReadStreamEventsForwardCompleted(message.CorrelationId,
message.EventStreamId,
resolvedPairs,
result.Result,
result.NextEventNumber,
result.LastEventNumber,
result.IsEndOfStream,
result.IsEndOfStream ? lastCommitPosition : (long?)null));
}
public virtual void Handle(ClientMessage.ReadStreamEventsForward message)
{
ClientMessage.ReadStreamEventsForwardCompleted reply;
if (!_hasReadForward)
{
_hasReadForward = true;
var events = IODispatcherTestHelpers.CreateResolvedEvent <TLogFormat, TStreamId>(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);
}
private static ClientMessage.ReadStreamEventsForwardCompleted NoData(ClientMessage.ReadStreamEventsForward msg, ReadStreamResult result, long lastCommitPosition, string error = null)
{
return(ClientMessage.ReadStreamEventsForwardCompleted.NoData(
result, msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, lastCommitPosition, error));
}
void IHandle <ClientMessage.ReadStreamEventsForward> .Handle(ClientMessage.ReadStreamEventsForward msg)
{
msg.Envelope.ReplyWith(ReadStreamEventsForward(msg));
}
public override void Handle(ClientMessage.ReadStreamEventsForward message)
{
message.Envelope.ReplyWith(CreateResultCommandReadResponse(message));
}
private ClientMessage.ReadStreamEventsForwardCompleted ReadStreamEventsForward(ClientMessage.ReadStreamEventsForward msg)
{
var lastCommitPosition = _readIndex.LastCommitPosition;
try
{
if (msg.ValidationStreamVersion.HasValue && _readIndex.GetStreamLastEventNumber(msg.EventStreamId) == msg.ValidationStreamVersion)
{
return(NoData(msg, ReadStreamResult.NotModified, lastCommitPosition, msg.ValidationStreamVersion.Value));
}
var access = _readIndex.CheckStreamAccess(msg.EventStreamId, StreamAccessType.Read, msg.User);
if (!access.Granted)
{
return(NoData(msg, ReadStreamResult.AccessDenied, lastCommitPosition));
}
var result = _readIndex.ReadStreamEventsForward(msg.EventStreamId, msg.FromEventNumber, msg.MaxCount);
CheckEventsOrder(msg, result);
var resolvedPairs = ResolveLinkToEvents(result.Records, msg.ResolveLinkTos, msg.User);
if (resolvedPairs == null)
{
return(NoData(msg, ReadStreamResult.AccessDenied, lastCommitPosition));
}
return(new ClientMessage.ReadStreamEventsForwardCompleted(
msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber, msg.MaxCount,
(ReadStreamResult)result.Result, resolvedPairs, result.Metadata, access.Public, string.Empty,
result.NextEventNumber, result.LastEventNumber, result.IsEndOfStream, lastCommitPosition));
}
catch (Exception exc)
{
Log.ErrorException(exc, "Error during processing ReadStreamEventsForward request.");
return(NoData(msg, ReadStreamResult.Error, lastCommitPosition, error: exc.Message));
}
}
