public static ClientMessage.ReadAllEventsForwardCompleted ReadAllEventsForward(MiniClusterNode node,
long position)
{
ClientMessage.ReadAllEventsForwardCompleted readResult = null;
var readEvent = new ManualResetEventSlim();
var done = false;
while (!done)
{
var read = new ClientMessage.ReadAllEventsForward(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(
msg => {
readResult = (ClientMessage.ReadAllEventsForwardCompleted)msg;
readEvent.Set();
}),
0, 0, 100, false, false, null, SystemAccount.Principal);
node.Node.MainQueue.Publish(read);
if (!readEvent.Wait(_timeout))
{
Assert.Fail("Timed out waiting for events to be read forward");
return(null);
}
if (readResult.Result == ReadAllResult.Error)
{
Assert.Fail("Failed to read forwards. Read result error: {0}", readResult.Error);
return(null);
}
done = readResult.NextPos.CommitPosition > position;
readEvent.Reset();
}
return(readResult);
}
void IHandle <ClientMessage.ReadAllEventsForward> .Handle(ClientMessage.ReadAllEventsForward message)
{
var pos = new TFPos(message.CommitPosition, message.PreparePosition);
var result = _readIndex.ReadAllEventsForward(pos, message.MaxCount, message.ResolveLinks);
message.Envelope.ReplyWith(new ClientMessage.ReadAllEventsForwardCompleted(message.CorrelationId, result));
}
private void RequestTfEvents(bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (_reader.PauseRequested || _reader.Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_tfEventsRequested)
{
return;
}
_tfEventsRequested = true;
_pendingRequestCorrelationId = Guid.NewGuid();
//TODO: we do not need resolve links, but lets check first with
var readRequest = new ClientMessage.ReadAllEventsForward(
_pendingRequestCorrelationId, _pendingRequestCorrelationId, new SendToThisEnvelope(this),
_fromTfPosition.CommitPosition,
_fromTfPosition.PreparePosition == -1 ? 0 : _fromTfPosition.PreparePosition,
EventByTypeIndexEventReader.MaxReadCount,
true, false, null, _readAs);
var timeoutMessage = TimerMessage.Schedule.Create(
TimeSpan.FromMilliseconds(ESConsts.ReadRequestTimeout),
new SendToThisEnvelope(this),
new ProjectionManagementMessage.Internal.ReadTimeout(_pendingRequestCorrelationId, "$all"));
_reader.PublishIORequest(delay, readRequest, timeoutMessage, _pendingRequestCorrelationId);
}
public void Handle(ClientMessage.ReadAllEventsForward message)
{
if (!_readAllEnabled)
{
return;
}
var from = new TFPos(message.CommitPosition, message.PreparePosition);
var records = _all.SkipWhile(v => v.Key < from).Take(message.MaxCount).ToArray();
var list = new List <ResolvedEvent>();
var pos = from;
var next = pos;
var prev = new TFPos(pos.CommitPosition, Int64.MaxValue);
foreach (KeyValuePair <TFPos, EventRecord> record in records)
{
pos = record.Key;
next = new TFPos(pos.CommitPosition, pos.PreparePosition + 1);
list.Add(BuildEvent(record.Value, message.ResolveLinkTos, record.Key.CommitPosition));
}
var events = list.ToArray();
message.Envelope.ReplyWith(
new ClientMessage.ReadAllEventsForwardCompleted(
message.CorrelationId, ReadAllResult.Success, "", events, null, false, message.MaxCount, pos, next, prev,
_fakePosition));
}
private void RequestTfEvents(bool delay)
{
if (_disposed)
{
throw new InvalidOperationException("Disposed");
}
if (_reader.PauseRequested || _reader.Paused)
{
throw new InvalidOperationException("Paused or pause requested");
}
if (_tfEventsRequested)
{
return;
}
_tfEventsRequested = true;
//TODO: we do not need resolve links, but lets check first with
var readRequest = new ClientMessage.ReadAllEventsForward(
Guid.NewGuid(), _reader.EventReaderCorrelationId, new SendToThisEnvelope(this),
_fromTfPosition.CommitPosition,
_fromTfPosition.PreparePosition == -1 ? 0 : _fromTfPosition.PreparePosition, 111,
true, false, null, _readAs);
_reader.PublishIORequest(delay, readRequest, Guid.NewGuid());
}
public void Handle(ClientMessage.ReadAllEventsForward message)
{
_externalRequestQueue.Publish(
new ClientMessage.ReadAllEventsForward(
message.CorrelationId, new PublishToWrapEnvelop(_inputQueue, message.Envelope),
message.CommitPosition, message.PreparePosition, message.MaxCount, message.ResolveLinks));
}
private ClientMessage.ReadAllEventsForwardCompleted NoData(ClientMessage.ReadAllEventsForward msg,
ReadAllResult result, TFPos pos, long lastCommitPosition, string error = null)
{
return(new ClientMessage.ReadAllEventsForwardCompleted(
msg.CorrelationId, result, error, ResolvedEvent.EmptyArray, null, false,
msg.MaxCount, pos, TFPos.Invalid, TFPos.Invalid, lastCommitPosition));
}
public void Handle(ClientMessage.ReadAllEventsForward msg)
{
_externalRequestQueue.Publish(
new ClientMessage.ReadAllEventsForward(
msg.InternalCorrId, msg.CorrelationId, new PublishToWrapEnvelop(_inputQueue, msg.Envelope),
msg.CommitPosition, msg.PreparePosition, msg.MaxCount, msg.ResolveLinkTos, msg.RequireMaster,
msg.ValidationTfLastCommitPosition, msg.User));
}
void IHandle <ClientMessage.ReadAllEventsForward> .Handle(ClientMessage.ReadAllEventsForward msg)
{
if (msg.Expires < DateTime.UtcNow)
{
if (LogExpiredMessage(msg.Expires))
{
Log.Debug(
"Read All Stream Events Forward operation has expired for C:{commitPosition}/P:{preparePosition}. Operation Expired at {expiryDateTime}",
msg.CommitPosition, msg.PreparePosition, msg.Expires);
}
return;
}
using (HistogramService.Measure(_readerAllRangeHistogram)) {
var res = ReadAllEventsForward(msg);
switch (res.Result)
{
case ReadAllResult.Success:
if (msg.LongPollTimeout.HasValue && res.IsEndOfStream && res.Events.Length == 0)
{
_publisher.Publish(new SubscriptionMessage.PollStream(
SubscriptionsService.AllStreamsSubscriptionId, res.TfLastCommitPosition, null,
DateTime.UtcNow + msg.LongPollTimeout.Value, msg));
}
else
{
msg.Envelope.ReplyWith(res);
}
break;
case ReadAllResult.NotModified:
if (msg.LongPollTimeout.HasValue && res.IsEndOfStream &&
res.CurrentPos.CommitPosition > res.TfLastCommitPosition)
{
_publisher.Publish(new SubscriptionMessage.PollStream(
SubscriptionsService.AllStreamsSubscriptionId, res.TfLastCommitPosition, null,
DateTime.UtcNow + msg.LongPollTimeout.Value, msg));
}
else
{
msg.Envelope.ReplyWith(res);
}
break;
case ReadAllResult.Error:
case ReadAllResult.AccessDenied:
msg.Envelope.ReplyWith(res);
break;
default:
throw new ArgumentOutOfRangeException(string.Format("Unknown ReadAllResult: {0}", res.Result));
}
}
}
public TcpPackage CreateNetworkPackage()
{
lock (_corrIdLock)
{
var dto = new ClientMessage.ReadAllEventsForward(_position.CommitPosition,
_position.PreparePosition,
_maxCount,
_resolveLinkTos);
return(new TcpPackage(TcpCommand.ReadAllEventsForward, _corrId, dto.Serialize()));
}
}
private ClientMessage.ReadAllEventsForwardCompleted ReadAllEventsForward(ClientMessage.ReadAllEventsForward msg)
{
using (HistogramService.Measure(_readerAllRangeHistogram))
{
var pos = new TFPos(msg.CommitPosition, msg.PreparePosition);
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 (pos == TFPos.HeadOfTf)
{
var checkpoint = _writerCheckpoint.Read();
pos = new TFPos(checkpoint, checkpoint);
}
if (pos.CommitPosition < 0 || pos.PreparePosition < 0)
{
return(NoData(msg, ReadAllResult.Error, pos, lastCommitPosition, "Invalid position."));
}
if (msg.ValidationTfLastCommitPosition == lastCommitPosition)
{
return(NoData(msg, ReadAllResult.NotModified, pos, lastCommitPosition));
}
var access = _readIndex.CheckStreamAccess(SystemStreams.AllStream, StreamAccessType.Read, msg.User);
if (!access.Granted)
{
return(NoData(msg, ReadAllResult.AccessDenied, pos, lastCommitPosition));
}
var res = _readIndex.ReadAllEventsForward(pos, msg.MaxCount);
var resolved = ResolveReadAllResult(res.Records, msg.ResolveLinkTos, msg.User);
if (resolved == null)
{
return(NoData(msg, ReadAllResult.AccessDenied, pos, lastCommitPosition));
}
var metadata = _readIndex.GetStreamMetadata(SystemStreams.AllStream);
return(new ClientMessage.ReadAllEventsForwardCompleted(
msg.CorrelationId, ReadAllResult.Success, null, resolved, metadata, access.Public, msg.MaxCount,
res.CurrentPos, res.NextPos, res.PrevPos, lastCommitPosition));
}
catch (Exception exc)
{
Log.ErrorException(exc, "Error during processing ReadAllEventsForward request.");
return(NoData(msg, ReadAllResult.Error, pos, lastCommitPosition, exc.Message));
}
}
}
private Message BuildMessage(Guid operationId, IEnvelope envelope, TFPos position)
{
var message = new ClientMessage.ReadAllEventsForward(
internalCorrId: operationId,
correlationId: operationId,
envelope,
commitPosition: position.CommitPosition,
preparePosition: position.PreparePosition,
maxCount: 100,
resolveLinkTos: false,
requireMaster: false,
validationTfLastCommitPosition: null,
user: SystemAccount.Principal
);
return(message);
}
public Task <AllEventsSlice> ReadAllEventsForwardAsync(Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials = null)
{
Ensure.Positive(maxCount, "maxCount");
var source = new TaskCompletionSource <AllEventsSlice>();
var envelope = new EmbeddedResponseEnvelope(new EmbeddedResponders.ReadAllEventsForward(source));
Guid corrId = Guid.NewGuid();
var message = new ClientMessage.ReadAllEventsForward(corrId, corrId, envelope,
position.CommitPosition,
position.PreparePosition, maxCount, resolveLinkTos, false, null, SystemAccount.Principal);
_publisher.Publish(message);
return(source.Task);
}
private void HandleAsNonMaster(ClientMessage.ReadAllEventsForward message)
{
if (message.RequireMaster)
{
if (_master == null)
{
DenyRequestBecauseNotReady(message.Envelope, message.CorrelationId);
}
else
{
DenyRequestBecauseNotMaster(message.CorrelationId, message.Envelope);
}
}
else
{
_outputBus.Publish(message);
}
}
private ClientMessage.ReadAllEventsForwardCompleted ReadAllEventsForward(ClientMessage.ReadAllEventsForward msg)
{
var pos = new TFPos(msg.CommitPosition, msg.PreparePosition);
try
{
if (pos == TFPos.HeadOfTf)
{
var checkpoint = _writerCheckpoint.Read();
pos = new TFPos(checkpoint, checkpoint);
}
if (pos.CommitPosition < 0 || pos.PreparePosition < 0)
{
return(NoData(msg, ReadAllResult.Error, pos, "Invalid position."));
}
if (msg.ValidationTfEofPosition.HasValue && _readIndex.LastCommitPosition == msg.ValidationTfEofPosition.Value)
{
return(NoData(msg, ReadAllResult.NotModified, pos));
}
var access = _readIndex.CheckStreamAccess(SystemStreams.AllStream, StreamAccessType.Read, msg.User);
if (!access.Granted)
{
return(NoData(msg, ReadAllResult.AccessDenied, pos));
}
var res = _readIndex.ReadAllEventsForward(pos, msg.MaxCount);
var resolved = ResolveReadAllResult(res.Records, msg.ResolveLinkTos, msg.User);
if (resolved == null)
{
return(NoData(msg, ReadAllResult.AccessDenied, pos));
}
return(new ClientMessage.ReadAllEventsForwardCompleted(
msg.CorrelationId, ReadAllResult.Success, null, resolved, res.Metadata, access.Public, msg.MaxCount,
res.CurrentPos, res.NextPos, res.PrevPos, res.TfEofPosition));
}
catch (Exception exc)
{
Log.ErrorException(exc, "Error during processing ReadAllEventsForward request.");
return(NoData(msg, ReadAllResult.Error, pos, exc.Message));
}
}
void IHandle <ClientMessage.ReadAllEventsForward> .Handle(ClientMessage.ReadAllEventsForward msg)
{
var res = ReadAllEventsForward(msg);
switch (res.Result)
{
case ReadAllResult.Success:
if (msg.LongPollTimeout.HasValue && res.IsEndOfStream && res.Events.Length == 0)
{
_publisher.Publish(new SubscriptionMessage.PollStream(
SubscriptionsService.AllStreamsSubscriptionId, res.TfLastCommitPosition, null,
DateTime.UtcNow + msg.LongPollTimeout.Value, msg));
}
else
{
msg.Envelope.ReplyWith(res);
}
break;
case ReadAllResult.NotModified:
if (msg.LongPollTimeout.HasValue && res.IsEndOfStream && res.CurrentPos.CommitPosition > res.TfLastCommitPosition)
{
_publisher.Publish(new SubscriptionMessage.PollStream(
SubscriptionsService.AllStreamsSubscriptionId, res.TfLastCommitPosition, null,
DateTime.UtcNow + msg.LongPollTimeout.Value, msg));
}
else
{
msg.Envelope.ReplyWith(res);
}
break;
case ReadAllResult.Error:
case ReadAllResult.AccessDenied:
msg.Envelope.ReplyWith(res);
break;
default:
throw new ArgumentOutOfRangeException(string.Format("Unknown ReadAllResult: {0}", res.Result));
}
}
void IHandle <ClientMessage.ReadAllEventsForward> .Handle(ClientMessage.ReadAllEventsForward msg)
{
msg.Envelope.ReplyWith(ReadAllEventsForward(msg));
}