예제 #1
0
        /// <summary>
        /// Creates a new subscription which will handle all the transactions after the given checkpoint.
        /// Waits asynchronously for the subscription to process all the transactions that are already in the event source.
        /// If the given <paramref name="lastProcessedCheckpoint"/> is ahead of the event source
        /// and that is ignored by the handler,
        /// waits asynchronously for a replacement subscription to be created
        /// and to process all the transactions that are already in the event source.
        /// The replacement subscription is not returned.
        /// The code that creates the replacement subscription is responsible for cancelling it.
        /// </summary>
        /// <param name="lastProcessedCheckpoint">
        /// If has value, only the transactions with checkpoints greater than the given value will be processed.
        /// </param>
        /// <param name="subscriber">The <see cref="Subscriber"/> which will handle the transactions.</param>
        /// <param name="subscriptionId">An arbitrary string identifying the subscription.</param>
        /// <returns>
        /// A task that returns an object implementing the <see cref="IDisposable"/> interface.
        /// Disposing the object will cancel the subscription asynchronously.
        /// </returns>
        public async Task <IDisposable> SubscribeAsync(long?lastProcessedCheckpoint, Subscriber subscriber, string subscriptionId)
        {
            MemorySubscription subscription = SubscribeWithoutWaitingInternal(lastProcessedCheckpoint, subscriber, subscriptionId);

            try
            {
                await subscription.WaitForCheckingWhetherItIsAhead().ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                // Do nothing.
            }

            long checkpointAtStart;

            lock (syncRoot)
            {
                checkpointAtStart = lastHistoryCheckpoint;
            }

            try
            {
                await subscription.WaitUntilCheckpoint(checkpointAtStart).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                // Do nothing.
            }

            return(subscription);
        }
예제 #2
0
 /// <summary>
 /// Checks whether the event source has a non-cancelled subscription with the given identifier.
 /// </summary>
 /// <param name="subscriptionId">
 /// The identifier of the subscription which was specified when the subscription was created.
 /// </param>
 public bool HasSubscriptionForId(string subscriptionId)
 {
     lock (syncRoot)
     {
         MemorySubscription subscription = subscriptions.SingleOrDefault(aSubscription => aSubscription.Id == subscriptionId);
         return((subscription != null) && !subscription.IsDisposed);
     }
 }
예제 #3
0
        private MemorySubscription SubscribeWithoutWaitingInternal(long?lastProcessedCheckpoint, Subscriber subscriber, string subscriptionId)
        {
            var subscription = new MemorySubscription(lastProcessedCheckpoint ?? 0, batchSize, subscriber, subscriptionId, this);

            lock (syncRoot)
            {
                subscriptions.Add(subscription);
            }

            subscription.Start();
            return(subscription);
        }