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)); } }