Пример #1
0
        public void Handle(ClientMessage.ReadNextNPersistentMessages message)
        {
            if (!_started)
            {
                return;
            }
            var streamAccess = _readIndex.CheckStreamAccess(
                message.EventStreamId, StreamAccessType.Read, message.User);

            if (!streamAccess.Granted)
            {
                message.Envelope.ReplyWith(
                    new ClientMessage.ReadNextNPersistentMessagesCompleted(message.CorrelationId,
                                                                           ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult
                                                                           .AccessDenied,
                                                                           "Access Denied.",
                                                                           null));
                return;
            }

            List <PersistentSubscription> subscribers;

            if (!_subscriptionTopics.TryGetValue(message.EventStreamId, out subscribers))
            {
                message.Envelope.ReplyWith(
                    new ClientMessage.ReadNextNPersistentMessagesCompleted(message.CorrelationId,
                                                                           ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult
                                                                           .DoesNotExist,
                                                                           "Not found.",
                                                                           null));
                return;
            }

            var key = BuildSubscriptionGroupKey(message.EventStreamId, message.GroupName);
            PersistentSubscription subscription;

            if (!_subscriptionsById.TryGetValue(key, out subscription))
            {
                message.Envelope.ReplyWith(
                    new ClientMessage.ReadNextNPersistentMessagesCompleted(message.CorrelationId,
                                                                           ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult
                                                                           .DoesNotExist,
                                                                           "Not found.",
                                                                           null));
                return;
            }

            var messages = subscription.GetNextNOrLessMessages(message.Count).ToArray();

            message.Envelope.ReplyWith(
                new ClientMessage.ReadNextNPersistentMessagesCompleted(message.CorrelationId,
                                                                       ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult.Success,
                                                                       string.Format("{0} read.", messages.Length),
                                                                       messages));
        }
Пример #2
0
        private void GetNextNMessages(HttpEntityManager http, UriTemplateMatch match)
        {
            if (_httpForwarder.ForwardRequest(http))
            {
                return;
            }
            var groupname = match.BoundVariables["subscription"];
            var stream    = match.BoundVariables["stream"];
            var cnt       = match.BoundVariables["count"];
            var embed     = GetEmbedLevel(http, match);
            int count     = DefaultNumberOfMessagesToGet;

            if (!cnt.IsEmptyString() && (!int.TryParse(cnt, out count) || count > 100 || count < 1))
            {
                SendBadRequest(http,
                               string.Format("Message count must be an integer between 1 and 100 'count' ='{0}'", count));
                return;
            }

            var envelope = new SendToHttpEnvelope(
                _networkSendQueue, http,
                (args, message) => Format.ReadNextNPersistentMessagesCompleted(http,
                                                                               message as ClientMessage.ReadNextNPersistentMessagesCompleted, stream, groupname, count, embed),
                (args, message) => {
                int code;
                var m = message as ClientMessage.ReadNextNPersistentMessagesCompleted;
                if (m == null)
                {
                    throw new Exception("unexpected message " + message);
                }
                switch (m.Result)
                {
                case
                    ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult
                    .Success:
                    code = HttpStatusCode.OK;
                    break;

                case
                    ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult
                    .DoesNotExist:
                    code = HttpStatusCode.NotFound;
                    break;

                case
                    ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult
                    .AccessDenied:
                    code = HttpStatusCode.Unauthorized;
                    break;

                default:
                    code = HttpStatusCode.InternalServerError;
                    break;
                }

                return(new ResponseConfiguration(code, http.ResponseCodec.ContentType,
                                                 http.ResponseCodec.Encoding));
            });

            var cmd = new ClientMessage.ReadNextNPersistentMessages(
                Guid.NewGuid(),
                Guid.NewGuid(),
                envelope,
                stream,
                groupname,
                count,
                http.User);

            Publish(cmd);
        }