public void Handle(ClientMessage.ReadStreamEventsBackward msg)
{
_externalRequestQueue.Publish(
new ClientMessage.ReadStreamEventsBackward(
msg.InternalCorrId, msg.CorrelationId, new PublishToWrapEnvelop(_inputQueue, msg.Envelope),
msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, msg.ResolveLinkTos, msg.RequireLeader,
msg.ValidationStreamVersion, msg.User));
}
private static ClientMessage.ReadStreamEventsBackwardCompleted NoData(
ClientMessage.ReadStreamEventsBackward msg, ReadStreamResult result, long lastIndexedPosition,
long lastEventNumber = -1, string error = null)
{
return(new ClientMessage.ReadStreamEventsBackwardCompleted(
msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, result,
EmptyRecords, null, false, error ?? string.Empty, -1, lastEventNumber, true, lastIndexedPosition));
}
public virtual void Handle(ClientMessage.ReadStreamEventsBackward message)
{
var events = IODispatcherTestHelpers.CreateResolvedEvent(message.EventStreamId, ProjectionEventTypes.ProjectionCheckpoint, "0");
var reply = new ClientMessage.ReadStreamEventsBackwardCompleted(message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount,
ReadStreamResult.Success, events, null, false, String.Empty, 0, message.FromEventNumber, true, 1000);
message.Envelope.ReplyWith(reply);
}
void IHandle <ClientMessage.ReadStreamEventsBackward> .Handle(ClientMessage.ReadStreamEventsBackward msg)
{
if (msg.Expires < DateTime.UtcNow)
{
return;
}
msg.Envelope.ReplyWith(ReadStreamEventsBackward(msg));
}
void IHandle <ClientMessage.ReadStreamEventsBackward> .Handle(ClientMessage.ReadStreamEventsBackward msg)
{
if (msg.Expires < DateTime.UtcNow)
{
Log.Debug("Read Stream Events Backward operation has expired for Stream: {0}, From Event Number: {1}, Max Count: {2}. Operation Expired at {3}", msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, msg.Expires);
return;
}
msg.Envelope.ReplyWith(ReadStreamEventsBackward(msg));
}
public override void Handle(ClientMessage.ReadStreamEventsBackward message)
{
if (!_hasTimedOut)
{
_hasTimedOut = true;
_timeoutCorrelationId = message.CorrelationId;
return;
}
base.Handle(message);
}
private void ProcessRead(ClientMessage.ReadStreamEventsBackward message)
{
List <EventRecord> list;
if (_deletedStreams.Contains(message.EventStreamId))
{
message.Envelope.ReplyWith(
new ClientMessage.ReadStreamEventsBackwardCompleted(
message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount,
ReadStreamResult.StreamDeleted, new ResolvedEvent[0], null, false, string.Empty, -1,
EventNumber.DeletedStream, true, _fakePosition));
}
else if (_streams.TryGetValue(message.EventStreamId, out list) || _noOtherStreams)
{
if (list != null && list.Count > 0 && (list.Last().EventNumber >= message.FromEventNumber) ||
(message.FromEventNumber == -1))
{
ResolvedEvent[] records =
list.Safe()
.Reverse()
.SkipWhile(v => message.FromEventNumber != -1 && v.EventNumber > message.FromEventNumber)
.Take(message.MaxCount)
.Select(v => BuildEvent(v, message.ResolveLinkTos))
.ToArray();
message.Envelope.ReplyWith(
new ClientMessage.ReadStreamEventsBackwardCompleted(
message.CorrelationId, message.EventStreamId,
message.FromEventNumber == -1
? (EnumerableExtensions.IsEmpty(list) ? -1 : list.Last().EventNumber)
: message.FromEventNumber, message.MaxCount, ReadStreamResult.Success, records, null,
false,
string.Empty,
nextEventNumber: records.Length > 0 ? records.Last().OriginalEvent.EventNumber - 1 : -1,
lastEventNumber: list.Safe().Any() ? list.Safe().Last().EventNumber : -1,
isEndOfStream: records.Length == 0 || records.Last().OriginalEvent.EventNumber == 0,
tfLastCommitPosition: _fakePosition));
}
else
{
if (list == null)
{
message.Envelope.ReplyWith(
new ClientMessage.ReadStreamEventsBackwardCompleted(
message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount,
ReadStreamResult.NoStream, new ResolvedEvent[0], null, false, "", nextEventNumber: -1,
lastEventNumber: -1,
isEndOfStream: true,
tfLastCommitPosition: _fakePosition));
return;
}
throw new NotImplementedException();
}
}
}
public virtual void Handle(ClientMessage.ReadStreamEventsBackward message)
{
if (message.EventStreamId == _namingBuilder.GetOrderStreamName())
{
message.Envelope.ReplyWith(ReadOrderStream(message));
}
if (message.EventStreamId == "a")
{
message.Envelope.ReplyWith(ReadTestStream(message));
}
}
public override void Handle(ClientMessage.ReadStreamEventsBackward message)
{
if (message.CorrelationId == _timedOutCorrelationId)
{
return;
}
else
{
base.Handle(message);
}
}
public ClientMessage.ReadStreamEventsBackwardCompleted ReadTestStream(
ClientMessage.ReadStreamEventsBackward message)
{
var events =
IODispatcherTestHelpers.CreateResolvedEvent <TLogFormat, TStreamId>(message.EventStreamId, "testevent", "{ \"data\":1 }");
return(new ClientMessage.ReadStreamEventsBackwardCompleted(message.CorrelationId, message.EventStreamId,
message.FromEventNumber,
message.MaxCount, ReadStreamResult.Success, events, null, true, "", message.FromEventNumber - 1,
message.FromEventNumber, true, 10000));
}
private static void CheckEventsOrder(ClientMessage.ReadStreamEventsBackward 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 ClientMessage.ReadStreamEventsBackwardCompleted CreateReadStreamEventsBackwardCompleted(
ClientMessage.ReadStreamEventsBackward msg)
{
var startEventNumber = msg.FromEventNumber;
var nextEventNumber = startEventNumber - 1;
var events =
IODispatcherTestHelpers.CreateResolvedEvent(msg.EventStreamId, "event_type", "test", eventNumber: 10);
var res = new ClientMessage.ReadStreamEventsBackwardCompleted(msg.CorrelationId, msg.EventStreamId,
msg.FromEventNumber,
msg.MaxCount, ReadStreamResult.Success, events, null, false, String.Empty, nextEventNumber,
startEventNumber, false, 0);
return(res);
}
void IHandle <ClientMessage.ReadStreamEventsBackward> .Handle(ClientMessage.ReadStreamEventsBackward message)
{
var lastCommitPosition = _readIndex.LastCommitPosition;
EventRecord[] records;
var result = _readIndex.ReadStreamEventsBackward(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.ReadStreamEventsBackwardCompleted(message.CorrelationId,
message.EventStreamId,
resolvedPairs,
result,
nextEventNumber,
records.Length == 0 ? lastCommitPosition : (long?)null));
}
public void Handle(ClientMessage.ReadStreamEventsBackward message) {
if (_readsBackwardsQueuesUp) {
_readEventsBackwardsQueue.Enqueue(message);
return;
}
if (_readsTimeOut) return;
if (_readsToTimeOutOnce.Contains(message.EventStreamId)) {
Console.WriteLine("[TEST] Timing out read backwards for {0}", message.EventStreamId);
_readsToTimeOutOnce.Remove(message.EventStreamId);
return;
}
ProcessRead(message);
}
public virtual void Handle(ClientMessage.ReadStreamEventsBackward message)
{
var evnts = IODispatcherTestHelpers.CreateResolvedEvent <TLogFormat, TStreamId>(message.EventStreamId,
ProjectionEventTypes.ProjectionCheckpoint, "[]",
@"{
""$v"": ""1:-1:3:3"",
""$c"": 269728,
""$p"": 269728
}");
var reply = new ClientMessage.ReadStreamEventsBackwardCompleted(message.CorrelationId,
message.EventStreamId, message.FromEventNumber, message.MaxCount, ReadStreamResult.Success,
evnts, null, true, "", 0, 0, true, 10000);
message.Envelope.ReplyWith(reply);
}
private static void CheckEventsOrder(ClientMessage.ReadStreamEventsBackward 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(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}",
msg.EventStreamId,
result.Records[index].EventNumber,
result.Records[index].LogPosition,
result.Records[index - 1].EventNumber,
result.Records[index - 1].LogPosition));
}
}
}
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);
}
public Task <StreamEventsSlice> ReadStreamEventsBackwardAsync(string stream, int start, int count, bool resolveLinkTos, UserCredentials userCredentials = null)
{
Ensure.NotNullOrEmpty(stream, "stream");
Ensure.Positive(count, "count");
var source = new TaskCompletionSource <StreamEventsSlice>();
var envelope = new EmbeddedResponseEnvelope(new EmbeddedResponders.ReadStreamEventsBackward(source, stream, start));
Guid corrId = Guid.NewGuid();
var message = new ClientMessage.ReadStreamEventsBackward(corrId, corrId, envelope,
stream, start, count, resolveLinkTos, false, null, SystemAccount.Principal);
_publisher.Publish(message);
return(source.Task);
}
private void HandleAsNonMaster(ClientMessage.ReadStreamEventsBackward message)
{
if (message.RequireMaster)
{
if (_master == null)
{
DenyRequestBecauseNotReady(message.Envelope, message.CorrelationId);
}
else
{
DenyRequestBecauseNotMaster(message.CorrelationId, message.Envelope);
}
}
else
{
_outputBus.Publish(message);
}
}
private ClientMessage.ReadStreamEventsBackwardCompleted ReadStreamEventsBackward(
ClientMessage.ReadStreamEventsBackward 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.ReadStreamEventsBackward(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.ReadStreamEventsBackwardCompleted(
msg.CorrelationId, msg.EventStreamId, result.FromEventNumber, result.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 ReadStreamEventsBackward request.");
return(NoData(msg, ReadStreamResult.Error, lastCommitPosition, error: exc.Message));
}
}
}
public override void Handle(ClientMessage.ReadStreamEventsBackward message)
{
if (!_hasTimedOut)
{
_timeoutCorrelationId = message.CorrelationId;
_hasTimedOut = true;
return;
}
var evnts = IODispatcherTestHelpers.CreateResolvedEvent(message.EventStreamId, ProjectionEventTypes.ProjectionCheckpoint, "[]",
@"{
""$v"": ""1:-1:3:3"",
""$c"": 269728,
""$p"": 269728
}");
var reply = new ClientMessage.ReadStreamEventsBackwardCompleted(message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount, ReadStreamResult.Success,
evnts, null, true, "", 0, 0, true, 10000);
message.Envelope.ReplyWith(reply);
}
public static ClientMessage.ReadStreamEventsBackwardCompleted ReadStreamEventsBackward(MiniClusterNode node, string streamId)
{
ClientMessage.ReadStreamEventsBackwardCompleted readResult = null;
var resetEvent = new ManualResetEventSlim();
var read = new ClientMessage.ReadStreamEventsBackward(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(msg =>
{
readResult = (ClientMessage.ReadStreamEventsBackwardCompleted)msg;
resetEvent.Set();
}), streamId, 9, 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 backward");
return(null);
}
return(readResult);
}
void IHandle <ClientMessage.ReadStreamEventsBackward> .Handle(ClientMessage.ReadStreamEventsBackward message)
{
var lastCommitPosition = _readIndex.LastCommitPosition;
var result = _readIndex.ReadStreamEventsBackward(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.ReadStreamEventsBackwardCompleted(message.CorrelationId,
message.EventStreamId,
resolvedPairs,
result.Result,
result.NextEventNumber,
result.LastEventNumber,
result.IsEndOfStream,
result.IsEndOfStream ? lastCommitPosition : (long?)null));
}
public virtual void Handle(ClientMessage.ReadStreamEventsBackward message)
{
_readBackward = message;
}
void IHandle <ClientMessage.ReadStreamEventsBackward> .Handle(ClientMessage.ReadStreamEventsBackward msg)
{
msg.Envelope.ReplyWith(ReadStreamEventsBackward(msg));
}
private ClientMessage.ReadStreamEventsBackwardCompleted ReadStreamEventsBackward(ClientMessage.ReadStreamEventsBackward 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.ReadStreamEventsBackward(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.ReadStreamEventsBackwardCompleted(
msg.CorrelationId, msg.EventStreamId, result.FromEventNumber, result.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 ReadStreamEventsBackward request.");
return(NoData(msg, ReadStreamResult.Error, lastCommitPosition, error: exc.Message));
}
}
private static ClientMessage.ReadStreamEventsBackwardCompleted NoData(ClientMessage.ReadStreamEventsBackward msg, ReadStreamResult result, long lastCommitPosition, string error = null)
{
return(ClientMessage.ReadStreamEventsBackwardCompleted.NoData(
result, msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, lastCommitPosition, error));
}
