Esempio n. 1
0
        private void ProcessEventCommited(string eventStreamId, StorageMessage.EventCommited msg)
        {
            List <Subscription> subscriptions;

            if (!_subscriptionGroupsByStream.TryGetValue(eventStreamId, out subscriptions))
            {
                return;
            }
            for (int i = 0, n = subscriptions.Count; i < n; i++)
            {
                var subscr = subscriptions[i];
                if (msg.CommitPosition <= subscr.LastCommitPosition || msg.Event.EventNumber <= subscr.LastEventNumber)
                {
                    continue;
                }

                var pair = new ResolvedEvent(msg.Event, null, msg.CommitPosition);
                if (subscr.ResolveLinkTos)
                {
                    _lastResolvedPair = pair = _lastResolvedPair ?? ResolveLinkToEvent(msg.Event, msg.CommitPosition);
                }

                subscr.Envelope.ReplyWith(new ClientMessage.StreamEventAppeared(subscr.CorrelationId, pair));
            }
        }
Esempio n. 2
0
        public void Handle(StorageMessage.EventCommited message)
        {
            foreach (var tuple in _subscribedToAll)
            {
                var manager       = tuple.Item2;
                var correlationId = tuple.Item1;
                if (manager.SendQueueSize <= ConnectionQueueSizeThreshold)
                {
                    manager.SendMessage(new ClientMessage.StreamEventAppeared(correlationId,
                                                                              message.EventNumber,
                                                                              message.Prepare,
                                                                              message.CommitPosition));
                }
                else
                {
                    _pendingUnsubscribeAll.Add(tuple);
                    manager.SendMessage(new ClientMessage.SubscriptionToAllDropped(correlationId));
                }
            }

            if (_pendingUnsubscribeAll.Count > 0)
            {
                foreach (var tuple in _pendingUnsubscribeAll)
                {
                    UnsubscribeFromAllStreams(tuple.Item1, tuple.Item2);
                }
            }

            List <Tuple <Guid, TcpConnectionManager> > subscribers;
            var eventStreamId = message.Prepare.EventStreamId;

            if (_subscriptions.TryGetValue(eventStreamId, out subscribers))
            {
                foreach (var tuple in subscribers)
                {
                    var manager       = tuple.Item2;
                    var correlationId = tuple.Item1;
                    if (manager.SendQueueSize <= ConnectionQueueSizeThreshold)
                    {
                        manager.SendMessage(new ClientMessage.StreamEventAppeared(correlationId,
                                                                                  message.EventNumber,
                                                                                  message.Prepare,
                                                                                  message.CommitPosition));
                    }
                    else
                    {
                        _pendingUnsubscribe.Add(Tuple.Create(correlationId, tuple.Item2));
                        manager.SendMessage(new ClientMessage.SubscriptionDropped(correlationId, eventStreamId));
                    }
                }

                if (_pendingUnsubscribe.Count > 0)
                {
                    foreach (var tuple in _pendingUnsubscribe)
                    {
                        UnsubscribeFromStream(eventStreamId, tuple.Item1, tuple.Item2);
                    }
                }
            }
        }
Esempio n. 3
0
        public void Handle(StorageMessage.EventCommited message)
        {
            _lastSeenCommitPosition = message.CommitPosition;

            var resolvedEvent = ProcessEventCommited(AllStreamsSubscriptionId, message.CommitPosition, message.Event, null);

            ProcessEventCommited(message.Event.EventStreamId, message.CommitPosition, message.Event, resolvedEvent);

            ReissueReadsFor(AllStreamsSubscriptionId, message.CommitPosition, message.Event.EventNumber);
            ReissueReadsFor(message.Event.EventStreamId, message.CommitPosition, message.Event.EventNumber);
        }
Esempio n. 4
0
 public void Handle(StorageMessage.EventCommited message)
 {
     ProcessEventCommited(AllStreamsSubscriptionId, message);
     ProcessEventCommited(message.Event.EventStreamId, message);
     _lastResolvedPair = null;
 }