Exemple #1
0
 IEnumerable<dynamic> GetEventsFrom(StreamEventsSlice slice)
 {
     foreach (var evnt in slice.Events)
     {
         var r = TryGetDomainEvent(evnt);
         if (r != null)
             yield return r;
     }
 }
Exemple #2
0
 public static StreamEventsSlice ToStreamEventsSlice(this ES.StreamEventsSlice slice)
 {
     return(new StreamEventsSlice(
                slice.Stream,
                slice.FromEventNumber,
                slice.ReadDirection.ToReadDirection(),
                slice.Events.ToRecordedEvents(),
                slice.NextEventNumber,
                slice.LastEventNumber,
                slice.IsEndOfStream));
 }
Exemple #3
0
        private async Task <bool> ReadEventsCallbackAsync(StreamEventsSlice slice, long?lastEventNumber)
        {
            bool shouldStopOrDone = ShouldStop || await ProcessEventsAsync(lastEventNumber, slice).ConfigureAwait(false);

            if (shouldStopOrDone && Verbose)
            {
                Log.Debug(
                    "Catch-up Subscription {0} to {1}: finished reading events, nextReadEventNumber = {2}.",
                    SubscriptionName,
                    IsSubscribedToAll ? "<all>" : StreamId,
                    _nextReadEventNumber);
            }
            return(shouldStopOrDone);
        }
        private async Task <bool> ProcessEventsAsync(long?lastEventNumber, StreamEventsSlice slice)
        {
            bool done;

            switch (slice.Status)
            {
            case SliceReadStatus.Success: {
                foreach (var e in slice.Events)
                {
                    await TryProcessAsync(e).ConfigureAwait(false);
                }

                _nextReadEventNumber = slice.NextEventNumber;
                done = lastEventNumber == null ? slice.IsEndOfStream : slice.NextEventNumber > lastEventNumber;
                break;
            }

            case SliceReadStatus.StreamNotFound: {
                if (lastEventNumber.HasValue && lastEventNumber != -1)
                {
                    throw new Exception(
                              string.Format(
                                  "Impossible: stream {0} disappeared in the middle of catching up subscription {1}.",
                                  StreamId, SubscriptionName));
                }

                done = true;
                break;
            }

            case SliceReadStatus.StreamDeleted:
                throw new StreamDeletedException(StreamId);

            default:
                throw new ArgumentOutOfRangeException(string.Format(
                                                          "Subscription {0} unexpected StreamEventsSlice.Status: {1}.",
                                                          SubscriptionName, slice.Status));
            }

            if (!done && slice.IsEndOfStream)
            {
                await Task.Delay(1).ConfigureAwait(false);                 // we are awaiting the server to flush its data
            }
            return(done);
        }
        private bool ProcessEvents(int?lastEventNumber, StreamEventsSlice slice)
        {
            bool done;

            switch (slice.Status)
            {
            case SliceReadStatus.Success:
            {
                foreach (var e in slice.Events)
                {
                    TryProcess(e);
                }
                _nextReadEventNumber = slice.NextEventNumber;
                done = lastEventNumber == null ? slice.IsEndOfStream : slice.NextEventNumber > lastEventNumber;
                break;
            }

            case SliceReadStatus.StreamNotFound:
            {
                if (lastEventNumber.HasValue && lastEventNumber != -1)
                {
                    throw new Exception(
                              string.Format("Impossible: stream {0} disappeared in the middle of catching up subscription.",
                                            StreamId));
                }
                done = true;
                break;
            }

            case SliceReadStatus.StreamDeleted:
                throw new StreamDeletedException(StreamId);

            default:
                throw new ArgumentOutOfRangeException(string.Format("Unexpected StreamEventsSlice.Status: {0}.",
                                                                    slice.Status));
            }

            if (!done && slice.IsEndOfStream)
            {
                Thread.Sleep(1); // we are waiting for server to flush its data
            }
            return(done);
        }
        private bool ProcessEvents(int? lastEventNumber, StreamEventsSlice slice)
        {
            bool done;
            switch (slice.Status)
            {
                case SliceReadStatus.Success:
                    {
                        foreach (var e in slice.Events)
                        {
                            TryProcess(e);
                        }
                        _nextReadEventNumber = slice.NextEventNumber;
                        done = lastEventNumber == null ? slice.IsEndOfStream : slice.NextEventNumber > lastEventNumber;
                        break;
                    }
                case SliceReadStatus.StreamNotFound:
                    {
                        if (lastEventNumber.HasValue && lastEventNumber != -1)
                            throw new Exception(
                                string.Format("Impossible: stream {0} disappeared in the middle of catching up subscription.",
                                    StreamId));
                        done = true;
                        break;
                    }
                case SliceReadStatus.StreamDeleted:
                    throw new StreamDeletedException(StreamId);
                default:
                    throw new ArgumentOutOfRangeException(string.Format("Unexpected StreamEventsSlice.Status: {0}.",
                        slice.Status));
            }

            if (!done && slice.IsEndOfStream)
                Thread.Sleep(1); // we are waiting for server to flush its data
            return done;
        }
 protected override void When()
 {
     _read = _conn.ReadStreamEventsForwardAsync(LinkedStreamName, 0, 1, true, null).Result;
 }