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);
}
}
/// <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();
}