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.ReadEventsForward(
                _distibutionPointCorrelationId, new SendToThisEnvelope(this), _streamName, _fromSequenceNumber,
                _maxReadCount, _resolveLinkTos);

            if (delay)
            {
                _publisher.Publish(
                    TimerMessage.Schedule.Create(
                        TimeSpan.FromMilliseconds(250), new PublishEnvelope(_publisher), readEventsForward));
            }
            else
            {
                _publisher.Publish(readEventsForward);
            }
        }
 public void Handle(ClientMessage.ReadEventsForward message)
 {
     _externalRequestQueue.Publish(
         new ClientMessage.ReadEventsForward(
             message.CorrelationId, new PublishToWrapEnvelop(_inputQueue, message.Envelope),
             message.EventStreamId, message.FromEventNumber, message.MaxCount, message.ResolveLinks));
 }
예제 #3
0
        void IHandle <ClientMessage.ReadEventsForward> .Handle(ClientMessage.ReadEventsForward message)
        {
            EventRecord[] records;
            EventRecord[] links = null;

            var lastCommitPosition = _readIndex.LastCommitPosition;

            var result          = _readIndex.TryReadEventsForward(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));
                    }
                }
            }
            if (result == RangeReadResult.Success && message.ResolveLinks)
            {
                links = ResolveLinkToEvents(records);
            }

            message.Envelope.ReplyWith(
                new ClientMessage.ReadEventsForwardCompleted(message.CorrelationId,
                                                             message.EventStreamId,
                                                             records,
                                                             links,
                                                             result,
                                                             nextEventNumber,
                                                             records.Length == 0 ? lastCommitPosition : (long?)null));
        }