Exemple #1
0
 private static void IncreaseDegreesOfParallelism(DynamicThrottling sut)
 {
     for (int i = 0; i < 10; i++)
     {
         // increase degrees to avoid being in the minimum boundary
         sut.NotifyWorkStarted();
         sut.NotifyWorkCompleted();
     }
 }
        public void increases_on_completed_work()
        {
            using (var sut = new DynamicThrottling(100, 10, 3, 5, 1, 8000)) {
                sut.NotifyWorkStarted();
                var startingValue = sut.AvailableDegreesOfParallelism;

                sut.NotifyWorkCompleted();

                Assert.True(startingValue < sut.AvailableDegreesOfParallelism);
            }
        }
        public void increases_on_completed_work()
        {
            using (var sut = new DynamicThrottling(100, 10, 3, 5, 1, 8000))
            {
                sut.NotifyWorkStarted();
                var startingValue = sut.AvailableDegreesOfParallelism;

                sut.NotifyWorkCompleted();

                Assert.True(startingValue < sut.AvailableDegreesOfParallelism);
            }
        }
        public void decreases_on_penalize()
        {
            using (var sut = new DynamicThrottling(100, 10, 3, 5, 1, 8000)) {
                IncreaseDegreesOfParallelism(sut);

                sut.NotifyWorkStarted();
                var startingValue = sut.AvailableDegreesOfParallelism;
                sut.Penalize();

                Assert.True(startingValue > sut.AvailableDegreesOfParallelism);
            }
        }
        public void decreases_on_penalize()
        {
            using (var sut = new DynamicThrottling(100, 10, 3, 5, 1, 8000))
            {
                IncreaseDegreesOfParallelism(sut);

                sut.NotifyWorkStarted();
                var startingValue = sut.AvailableDegreesOfParallelism;
                sut.Penalize();

                Assert.True(startingValue > sut.AvailableDegreesOfParallelism);
            }
        }
Exemple #6
0
        private IEnumerable <T> GetThrottlingEnumerable <T>(IEnumerable <T> enumerable, CancellationToken cancellationToken)
        {
            foreach (var item in enumerable)
            {
                dynamicThrottling.NotifyWorkStarted();
                yield return(item);

                dynamicThrottling.WaitUntilAllowedParallelism(cancellationToken);

                if (cancellationToken.IsCancellationRequested)
                {
                    yield break;
                }
            }
        }
        private void AcceptSession(CancellationToken cancellationToken)
        {
            dynamicThrottling.WaitUntilAllowedParallelism(cancellationToken);

            if (!cancellationToken.IsCancellationRequested)
            {
                // Initialize a custom action acting as a callback whenever a non-transient exception occurs while accepting a session.
                Action <Exception> recoverAcceptSession = ex => {
                    // Just log an exception. Do not allow an unhandled exception to terminate the message receive loop abnormally.
                    Trace.TraceError("An unrecoverable error occurred while trying to accept a session in subscription {1}:\r\n{0}", ex, subscription);
                    dynamicThrottling.Penalize();

                    if (!cancellationToken.IsCancellationRequested)
                    {
                        // Continue accepting new sessions until told to stop regardless of any exceptions.
                        TaskEx.Delay(10000).ContinueWith(t => AcceptSession(cancellationToken));
                    }
                };

                receiveRetryPolicy.ExecuteAction(
                    cb => client.BeginAcceptMessageSession(AcceptSessionLongPollingTimeout, cb, null),
                    ar => {
                    // Complete the asynchronous operation. This may throw an exception that will be handled internally by retry policy.
                    try {
                        return(client.EndAcceptMessageSession(ar));
                    } catch (TimeoutException) {
                        // TimeoutException is not just transient but completely expected in this case, so not relying on Topaz to retry
                        return(null);
                    }
                },
                    session => {
                    if (session != null)
                    {
                        instrumentation.SessionStarted();
                        dynamicThrottling.NotifyWorkStarted();
                        // starts a new task to process new sessions in parallel when enough threads are available
                        Task.Factory.StartNew(() => AcceptSession(cancellationToken), cancellationToken);
                        ReceiveMessagesAndCloseSession(session, cancellationToken);
                    }
                    else
                    {
                        AcceptSession(cancellationToken);
                    }
                },
                    recoverAcceptSession);
            }
        }
        public void penalize_decreases_less_than_completed_with_error()
        {
            using (var sut1 = new DynamicThrottling(100, 10, 3, 5, 1, 8000))
            using (var sut2 = new DynamicThrottling(100, 10, 3, 5, 1, 8000))
            {
                IncreaseDegreesOfParallelism(sut1);
                IncreaseDegreesOfParallelism(sut2);

                sut1.NotifyWorkStarted();
                sut2.NotifyWorkStarted();

                sut1.Penalize();
                sut2.NotifyWorkCompletedWithError();

                Assert.True(sut1.AvailableDegreesOfParallelism > sut2.AvailableDegreesOfParallelism);
            }
        }
Exemple #9
0
        public void penalize_decreases_less_than_completed_with_error()
        {
            using (var sut1 = new DynamicThrottling(100, 10, 3, 5, 1, 8000))
                using (var sut2 = new DynamicThrottling(100, 10, 3, 5, 1, 8000))
                {
                    IncreaseDegreesOfParallelism(sut1);
                    IncreaseDegreesOfParallelism(sut2);

                    sut1.NotifyWorkStarted();
                    sut2.NotifyWorkStarted();

                    sut1.Penalize();
                    sut2.NotifyWorkCompletedWithError();

                    Assert.True(sut1.AvailableDegreesOfParallelism > sut2.AvailableDegreesOfParallelism);
                }
        }
 private static void IncreaseDegreesOfParallelism(DynamicThrottling sut)
 {
     for (int i = 0; i < 10; i++)
     {
         // increase degrees to avoid being in the minimum boundary
         sut.NotifyWorkStarted();
         sut.NotifyWorkCompleted();
     }
 }
        /// <summary>
        ///     Receives the messages in an endless asynchronous loop.
        /// </summary>
        private void ReceiveMessages(CancellationToken cancellationToken)
        {
            // Declare an action to receive the next message in the queue or end if cancelled.
            Action receiveNext = null;

            // Declare an action acting as a callback whenever a non-transient exception occurs while receiving or processing messages.
            Action <Exception> recoverReceive = null;

            // Declare an action responsible for the core operations in the message receive loop.
            Action receiveMessage = () => {
                // Use a retry policy to execute the Receive action in an asynchronous and reliable fashion.
                receiveRetryPolicy.ExecuteAction
                (
                    cb => {
                    // Start receiving a new message asynchronously.
                    client.BeginReceive(ReceiveLongPollingTimeout, cb, null);
                },
                    ar => {
                    // Complete the asynchronous operation. This may throw an exception that will be handled internally by retry policy.
                    try {
                        return(client.EndReceive(ar));
                    } catch (TimeoutException) {
                        // TimeoutException is not just transient but completely expected in this case, so not relying on Topaz to retry
                        return(null);
                    }
                },
                    msg => {
                    // Process the message once it was successfully received
                    if (processInParallel)
                    {
                        // Continue receiving and processing new messages asynchronously
                        Task.Factory.StartNew(receiveNext);
                    }

                    // Check if we actually received any messages.
                    if (msg != null)
                    {
                        var roundtripStopwatch             = Stopwatch.StartNew();
                        long schedulingElapsedMilliseconds = 0;
                        long processingElapsedMilliseconds = 0;

                        Task.Factory.StartNew(() => {
                            var releaseAction = MessageReleaseAction.AbandonMessage;

                            try {
                                instrumentation.MessageReceived();

                                schedulingElapsedMilliseconds = roundtripStopwatch.ElapsedMilliseconds;

                                // Make sure the process was told to stop receiving while it was waiting for a new message.
                                if (!cancellationToken.IsCancellationRequested)
                                {
                                    try {
                                        try {
                                            // Process the received message.
                                            releaseAction = InvokeMessageHandler(msg);

                                            processingElapsedMilliseconds = roundtripStopwatch.ElapsedMilliseconds - schedulingElapsedMilliseconds;
                                            instrumentation.MessageProcessed(releaseAction.Kind == MessageReleaseActionKind.Complete, processingElapsedMilliseconds);
                                        } catch {
                                            processingElapsedMilliseconds = roundtripStopwatch.ElapsedMilliseconds - schedulingElapsedMilliseconds;
                                            instrumentation.MessageProcessed(false, processingElapsedMilliseconds);

                                            throw;
                                        }
                                    } finally {
                                        if (roundtripStopwatch.Elapsed > TimeSpan.FromSeconds(45))
                                        {
                                            dynamicThrottling.Penalize();
                                        }
                                    }
                                }
                            } finally {
                                // Ensure that any resources allocated by a BrokeredMessage instance are released.
                                ReleaseMessage(msg, releaseAction, processingElapsedMilliseconds, schedulingElapsedMilliseconds, roundtripStopwatch);
                            }

                            if (!processInParallel)
                            {
                                // Continue receiving and processing new messages until told to stop.
                                receiveNext.Invoke();
                            }
                        });
                    }
                    else
                    {
                        dynamicThrottling.NotifyWorkCompleted();
                        if (!processInParallel)
                        {
                            // Continue receiving and processing new messages until told to stop.
                            receiveNext.Invoke();
                        }
                    }
                },
                    ex => {
                    // Invoke a custom action to indicate that we have encountered an exception and
                    // need further decision as to whether to continue receiving messages.
                    recoverReceive.Invoke(ex);
                });
            };

            // Initialize an action to receive the next message in the queue or end if cancelled.
            receiveNext = () => {
                dynamicThrottling.WaitUntilAllowedParallelism(cancellationToken);
                if (!cancellationToken.IsCancellationRequested)
                {
                    dynamicThrottling.NotifyWorkStarted();
                    // Continue receiving and processing new messages until told to stop.
                    receiveMessage.Invoke();
                }
            };

            // Initialize a custom action acting as a callback whenever a non-transient exception occurs while receiving or processing messages.
            recoverReceive = ex => {
                // Just log an exception. Do not allow an unhandled exception to terminate the message receive loop abnormally.
                Trace.TraceError("An unrecoverable error occurred while trying to receive a new message from subscription {1}:\r\n{0}", ex, subscription);
                dynamicThrottling.NotifyWorkCompletedWithError();

                if (!cancellationToken.IsCancellationRequested)
                {
                    // Continue receiving and processing new messages until told to stop regardless of any exceptions.
                    TaskEx.Delay(10000).ContinueWith(t => receiveMessage.Invoke());
                }
            };

            // Start receiving messages asynchronously.
            receiveNext.Invoke();
        }