public void FetchAllFilteredCompleted(ClientMessage.FilteredReadAllEventsForwardCompleted msg)
            {
                switch (msg.Result)
                {
                case FilteredReadAllResult.Success:
                    if (msg.Events.Length == 0 && msg.ConsideredEventsCount > 0)
                    {
                        // Checkpoint on the position we read from rather than the next position
                        // to prevent skipping the next event when loading from the checkpoint
                        _onEventsSkipped(
                            new PersistentSubscriptionAllStreamPosition(msg.CurrentPos.CommitPosition, msg.CurrentPos.PreparePosition),
                            msg.ConsideredEventsCount);
                    }
                    _onFetchCompleted(_skipFirstEvent ? msg.Events.Skip(1).ToArray() : msg.Events,
                                      new PersistentSubscriptionAllStreamPosition(msg.NextPos.CommitPosition, msg.NextPos.PreparePosition), msg.IsEndOfStream);

                    break;

                case FilteredReadAllResult.AccessDenied:
                    _onError($"Read access denied for stream: {SystemStreams.AllStream}");
                    break;

                default:
                    _onError(msg.Error ?? $"Error reading stream: {SystemStreams.AllStream} at position: {msg.CurrentPos}");
                    break;
                }
            }
Example #2
0
        private static TcpPackage WrapFilteredReadAllEventsForwardCompleted(
            ClientMessage.FilteredReadAllEventsForwardCompleted msg)
        {
            var dto = new TcpClientMessageDto.FilteredReadAllEventsCompleted(
                msg.CurrentPos.CommitPosition, msg.CurrentPos.PreparePosition, ConvertToResolvedEvents(msg.Events),
                msg.NextPos.CommitPosition, msg.NextPos.PreparePosition, msg.IsEndOfStream,
                (TcpClientMessageDto.FilteredReadAllEventsCompleted.FilteredReadAllResult)msg.Result, msg.Error);

            return(new TcpPackage(TcpCommand.FilteredReadAllEventsForwardCompleted, msg.CorrelationId, dto.Serialize()));
        }
Example #3
0
        public static FeedElement ToAllEventsForwardFilteredFeed(ClientMessage.FilteredReadAllEventsForwardCompleted msg,
                                                                 Uri requestedUrl, EmbedLevel embedContent)
        {
            var self = HostName.Combine(requestedUrl, "/streams/{0}", AllFilteredEscaped);
            var feed = new FeedElement();

            feed.SetTitle("All events");
            feed.SetId(self);
            feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null
                                ? msg.Events[msg.Events.Length - 1].Event.TimeStamp
                                : DateTime.MinValue.ToUniversalTime());
            feed.SetAuthor(AtomSpecs.Author);

            feed.AddLink("self", self);
            feed.AddLink("first",
                         HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllFilteredEscaped, msg.MaxCount));
            if (msg.CurrentPos.CommitPosition != 0)
            {
                feed.AddLink("last",
                             HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllFilteredEscaped,
                                              new TFPos(0, 0).AsString(), msg.MaxCount));
                feed.AddLink("next",
                             HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllFilteredEscaped, msg.PrevPos.AsString(),
                                              msg.MaxCount));
            }

            if (!msg.IsEndOfStream || msg.Events.Length > 0)
            {
                feed.AddLink("previous",
                             HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllFilteredEscaped, msg.NextPos.AsString(),
                                              msg.MaxCount));
            }
            for (int i = msg.Events.Length - 1; i >= 0; --i)
            {
                feed.AddEntry(ToEntry(msg.Events[i].WithoutPosition(), requestedUrl, embedContent));
            }

            return(feed);
        }