/// <summary>
/// This method is used to receive message from a queue or a subscription.
/// </summary>
/// <param name="messageReceiver">The message receiver used to receive messages.</param>
/// <param name="taskId">The receiver task id.</param>
/// <param name="timeout">The receive receiveTimeout.</param>
/// <param name="filter">The filter expression is used to determine messages to move the dead-letter queue or to defer.</param>
/// <param name="moveToDeadLetterQueue">Indicates whether to move messages to the dead-letter queue.</param>
/// <param name="completeReceive">Indicates whether to complete a receive operation when ReceiveMode is equal to PeekLock.</param>
/// <param name="defer">Indicates whether to defer messages.</param>
/// <param name="logging">Indicates whether logging of message content and properties is enabled.</param>
/// <param name="verbose">Indicates whether verbose logging is enabled.</param>
/// <param name="statistics">Indicates whether to enable receiver statistics.</param>
/// <param name="receiveBatch">Indicates whether to use ReceiveBatch.</param>
/// <param name="batchSize">Indicates the batch size.</param>
/// <param name="receiverThinkTime">Indicates whether to use think time.</param>
/// <param name="thinkTime">Indicates the value of the think time in milliseconds.</param>
/// <param name="messageInspector">A BrokeredMessage inspector object.</param>
/// <param name="updateStatistics">When statistics = true, this delegate is invoked to update statistics.</param>
/// <param name="cancellationTokenSource">The cancellation token.</param>
/// <param name="traceMessage">A trace message.</param>
/// <returns>True if the method completed without exceptions, false otherwise.</returns>
public bool ReceiveMessages(MessageReceiver messageReceiver,
int taskId,
int timeout,
Filter filter,
bool moveToDeadLetterQueue,
bool completeReceive,
bool defer,
bool logging,
bool verbose,
bool statistics,
bool receiveBatch,
int batchSize,
bool receiverThinkTime,
int thinkTime,
IBrokeredMessageInspector messageInspector,
UpdateStatisticsDelegate updateStatistics,
CancellationTokenSource cancellationTokenSource,
out string traceMessage)
{
if (messageReceiver == null)
{
throw new ArgumentNullException(MessageReceiverCannotBeNull);
}
if (cancellationTokenSource == null)
{
throw new ArgumentNullException(CancellationTokenSourceCannotBeNull);
}
BrokeredMessage inboundMessage = null;
StringBuilder builder;
var isCompleted = false;
var ok = true;
var receivedFromDeadLetterQueue = messageReceiver.Path.EndsWith(DeadLetterQueue);
var readingDeferredMessages = false;
long messagesReceived = 0;
long totalReceiveElapsedTime = 0;
long totalCompleteElapsedTime = 0;
long minimumReceiveTime = long.MaxValue;
long maximumReceiveTime = 0;
long minimumCompleteTime = long.MaxValue;
long maximumCompleteTime = 0;
long fetchedMessages = 0;
long prefetchElapsedTime = 0;
string exceptionMessage = null;
var messageDeferProvider = Activator.CreateInstance(messageDeferProviderType) as IMessageDeferProvider;
try
{
MessageEncodingBindingElement element;
if (scheme == DefaultScheme)
{
element = new BinaryMessageEncodingBindingElement();
}
else
{
element = new TextMessageEncodingBindingElement();
}
var encoderFactory = element.CreateMessageEncoderFactory();
var encoder = encoderFactory.Encoder;
if (receiveBatch && batchSize > 0)
{
while (!isCompleted &&
!cancellationTokenSource.Token.IsCancellationRequested)
{
IList<BrokeredMessage> messageList = null;
try
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var messageEnumerable = messageReceiver.ReceiveBatch(batchSize, TimeSpan.FromSeconds(timeout));
stopwatch.Stop();
messageList = messageEnumerable as IList<BrokeredMessage> ?? messageEnumerable.ToList();
if (messageInspector != null)
{
messageList = messageList.Select(b => messageInspector.AfterReceiveMessage(b, writeToLog)).ToList();
}
isCompleted = messageEnumerable == null || !messageList.Any();
if (isCompleted)
{
continue;
}
if (messageReceiver.Mode == ReceiveMode.PeekLock)
{
if (completeReceive)
{
stopwatch = new Stopwatch();
stopwatch.Start();
messageReceiver.CompleteBatch(messageList.Select(b => b.LockToken));
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds > maximumCompleteTime)
{
maximumCompleteTime = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds < minimumCompleteTime)
{
minimumCompleteTime = stopwatch.ElapsedMilliseconds;
}
totalCompleteElapsedTime += stopwatch.ElapsedMilliseconds;
messagesReceived += messageList.Count;
}
}
else
{
messagesReceived += messageList.Count;
}
if (stopwatch.ElapsedMilliseconds > maximumReceiveTime)
{
maximumReceiveTime = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds < minimumReceiveTime)
{
minimumReceiveTime = stopwatch.ElapsedMilliseconds;
}
totalReceiveElapsedTime += stopwatch.ElapsedMilliseconds;
if (statistics)
{
if (messageReceiver.PrefetchCount > 0)
{
if (stopwatch.ElapsedMilliseconds == 0)
{
fetchedMessages += messageList.Count;
}
else
{
if (fetchedMessages > 0)
{
updateStatistics(fetchedMessages,
prefetchElapsedTime,
DirectionType.Receive);
fetchedMessages = messageList.Count;
}
else
{
fetchedMessages += messageList.Count;
}
prefetchElapsedTime = stopwatch.ElapsedMilliseconds;
}
}
else
{
updateStatistics(messageList.Count, stopwatch.ElapsedMilliseconds, DirectionType.Receive);
}
}
builder = new StringBuilder();
if (logging)
{
// ReSharper disable ForCanBeConvertedToForeach
for (var i = 0; i < messageList.Count; i++)
// ReSharper restore ForCanBeConvertedToForeach
{
if (messageReceiver.Mode == ReceiveMode.PeekLock &&
!completeReceive)
{
builder.AppendLine(string.Format(MessagePeekedButNotConsumed,
taskId,
string.IsNullOrWhiteSpace(messageList[i].MessageId)
? NullValue
: messageList[i].MessageId,
string.IsNullOrWhiteSpace(messageList[i].SessionId)
? NullValue
: messageList[i].SessionId,
string.IsNullOrWhiteSpace(messageList[i].Label)
? NullValue
: messageList[i].Label,
messageList[i].Size));
}
else
{
builder.AppendLine(string.Format(MessageSuccessfullyReceived,
taskId,
string.IsNullOrWhiteSpace(messageList[i].MessageId)
? NullValue
: messageList[i].MessageId,
string.IsNullOrWhiteSpace(messageList[i].SessionId)
? NullValue
: messageList[i].SessionId,
string.IsNullOrWhiteSpace(messageList[i].Label)
? NullValue
: messageList[i].Label,
messageList[i].Size,
messageList[i].DeliveryCount));
}
if (verbose)
{
GetMessageAndProperties(builder, messageList[i], encoder);
}
}
traceMessage = builder.ToString();
WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
}
catch (Exception ex)
{
if (messageList != null &&
messageList.Count > 0 &&
messageReceiver.Mode == ReceiveMode.PeekLock)
{
try
{
var stopwatch = new Stopwatch();
stopwatch.Start();
messageReceiver.CompleteBatch(messageList.Select(b => b.LockToken));
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds > maximumCompleteTime)
{
maximumCompleteTime = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds < minimumCompleteTime)
{
minimumCompleteTime = stopwatch.ElapsedMilliseconds;
}
totalCompleteElapsedTime += stopwatch.ElapsedMilliseconds;
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
}
}
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
isCompleted = true;
ok = false;
}
finally
{
if (messageList != null &&
messageList.Count > 0)
{
foreach (var message in messageList)
{
message.Dispose();
}
}
}
if (receiverThinkTime)
{
WriteToLog(string.Format(SleepingFor, thinkTime));
Thread.Sleep(thinkTime);
}
}
}
else
{
while (!isCompleted &&
!cancellationTokenSource.Token.IsCancellationRequested)
{
try
{
var stopwatch = new Stopwatch();
var movedToDeadLetterQueue = false;
var deferredMessage = false;
var readDeferredMessage = false;
if (!readingDeferredMessages)
{
stopwatch.Start();
inboundMessage = messageReceiver.Receive(TimeSpan.FromSeconds(timeout));
stopwatch.Stop();
if (inboundMessage != null && messageInspector != null)
{
inboundMessage = messageInspector.AfterReceiveMessage(inboundMessage);
}
isCompleted = inboundMessage == null &&
messageDeferProvider.Count == 0;
}
else
{
isCompleted = messageDeferProvider.Count == 0;
if (!isCompleted)
{
long sequenceNumber;
if (messageDeferProvider.Dequeue(out sequenceNumber))
{
stopwatch.Start();
inboundMessage = messageReceiver.Receive(sequenceNumber);
stopwatch.Stop();
if (inboundMessage != null && messageInspector != null)
{
inboundMessage = messageInspector.AfterReceiveMessage(inboundMessage);
}
readDeferredMessage = true;
}
}
}
if (!readingDeferredMessages)
{
readingDeferredMessages = inboundMessage == null && messageDeferProvider.Count > 0;
}
if (isCompleted ||
inboundMessage == null)
{
continue;
}
if (stopwatch.ElapsedMilliseconds > maximumReceiveTime)
{
maximumReceiveTime = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds < minimumReceiveTime)
{
minimumReceiveTime = stopwatch.ElapsedMilliseconds;
}
totalReceiveElapsedTime += stopwatch.ElapsedMilliseconds;
if (statistics)
{
if (messageReceiver.PrefetchCount > 0)
{
if (stopwatch.ElapsedMilliseconds == 0)
{
fetchedMessages++;
}
else
{
if (fetchedMessages > 0)
{
updateStatistics(fetchedMessages,
prefetchElapsedTime,
DirectionType.Receive);
fetchedMessages = 1;
}
else
{
fetchedMessages++;
}
prefetchElapsedTime = stopwatch.ElapsedMilliseconds;
}
}
else
{
updateStatistics(1, stopwatch.ElapsedMilliseconds, DirectionType.Receive);
}
}
builder = new StringBuilder();
if (defer &&
!readingDeferredMessages &&
filter != null &&
filter.Match(inboundMessage))
{
inboundMessage.Defer();
messageDeferProvider.Enqueue(inboundMessage.SequenceNumber);
deferredMessage = true;
}
if (!deferredMessage &&
moveToDeadLetterQueue &&
filter != null &&
filter.Match(inboundMessage))
{
inboundMessage.DeadLetter();
movedToDeadLetterQueue = true;
messagesReceived++;
}
if (!deferredMessage &&
!movedToDeadLetterQueue)
{
if (messageReceiver.Mode == ReceiveMode.PeekLock)
{
if (completeReceive)
{
stopwatch = new Stopwatch();
stopwatch.Start();
inboundMessage.Complete();
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds > maximumCompleteTime)
{
maximumCompleteTime = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds < minimumCompleteTime)
{
minimumCompleteTime = stopwatch.ElapsedMilliseconds;
}
totalCompleteElapsedTime += stopwatch.ElapsedMilliseconds;
messagesReceived++;
}
else
{
stopwatch = new Stopwatch();
inboundMessage.Abandon();
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds > maximumCompleteTime)
{
maximumCompleteTime = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds < minimumCompleteTime)
{
minimumCompleteTime = stopwatch.ElapsedMilliseconds;
}
totalCompleteElapsedTime += stopwatch.ElapsedMilliseconds;
}
}
else
{
messagesReceived++;
}
}
if (logging)
{
if (messageReceiver.Mode == ReceiveMode.PeekLock &&
!completeReceive &&
!deferredMessage &&
!movedToDeadLetterQueue)
{
builder.AppendLine(string.Format(MessagePeekedButNotConsumed,
taskId,
string.IsNullOrWhiteSpace(inboundMessage.MessageId)
? NullValue
: inboundMessage.MessageId,
string.IsNullOrWhiteSpace(inboundMessage.SessionId)
? NullValue
: inboundMessage.SessionId,
string.IsNullOrWhiteSpace(inboundMessage.Label)
? NullValue
: inboundMessage.Label,
inboundMessage.Size));
}
else
{
builder.AppendLine(string.Format(MessageSuccessfullyReceived,
taskId,
string.IsNullOrWhiteSpace(inboundMessage.MessageId)
? NullValue
: inboundMessage.MessageId,
string.IsNullOrWhiteSpace(inboundMessage.SessionId)
? NullValue
: inboundMessage.SessionId,
string.IsNullOrWhiteSpace(inboundMessage.Label)
? NullValue
: inboundMessage.Label,
inboundMessage.Size,
inboundMessage.DeliveryCount));
}
if (deferredMessage)
{
builder.AppendLine(MessageDeferred);
}
if (readDeferredMessage)
{
builder.AppendLine(ReadMessageDeferred);
}
if (movedToDeadLetterQueue)
{
builder.AppendLine(MessageMovedToDeadLetterQueue);
}
if (receivedFromDeadLetterQueue)
{
builder.AppendLine(MessageReadFromDeadLetterQueue);
}
if (verbose)
{
GetMessageAndProperties(builder, inboundMessage, encoder);
}
}
if (logging)
{
traceMessage = builder.ToString();
WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
}
catch (Exception ex)
{
if (inboundMessage != null &&
messageReceiver.Mode == ReceiveMode.PeekLock)
{
try
{
inboundMessage.Abandon();
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
}
}
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
isCompleted = true;
ok = false;
}
finally
{
if (inboundMessage != null)
{
inboundMessage.Dispose();
}
}
if (receiverThinkTime)
{
WriteToLog(string.Format(SleepingFor, thinkTime));
Thread.Sleep(thinkTime);
}
}
}
if (messageReceiver.PrefetchCount > 0 && fetchedMessages > 0 && prefetchElapsedTime > 0)
{
updateStatistics(fetchedMessages, prefetchElapsedTime, DirectionType.Receive);
}
}
catch (Exception ex)
{
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
if (messagesReceived == 0)
{
WriteToLog(string.Format(NoMessageWasReceived, taskId));
}
var averageReceiveTime = messagesReceived > 0 ? totalReceiveElapsedTime / messagesReceived : maximumReceiveTime;
var averageCompleteTime = messagesReceived > 0 ? totalCompleteElapsedTime / messagesReceived : maximumCompleteTime;
// ReSharper disable RedundantCast
var messagesPerSecond = totalReceiveElapsedTime > 0 ? (double)(messagesReceived * 1000) / (double)totalReceiveElapsedTime : 0;
// ReSharper restore RedundantCast
builder = new StringBuilder();
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatisticsHeader,
taskId));
if (!string.IsNullOrWhiteSpace(exceptionMessage))
{
builder.AppendLine(exceptionMessage);
}
if (messageReceiver.Mode == ReceiveMode.ReceiveAndDelete)
{
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatitiscsLine1,
messagesReceived,
messagesPerSecond,
totalReceiveElapsedTime));
}
else
{
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatitiscsWithCompleteLine1,
messagesReceived,
messagesPerSecond,
totalReceiveElapsedTime,
totalCompleteElapsedTime));
}
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatitiscsLine2,
averageReceiveTime,
minimumReceiveTime == long.MaxValue ? 0 : minimumReceiveTime,
maximumReceiveTime));
if (messageReceiver.Mode == ReceiveMode.PeekLock)
{
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatitiscsLine3,
averageCompleteTime,
minimumCompleteTime == long.MaxValue ? 0 : minimumCompleteTime,
maximumCompleteTime));
}
traceMessage = builder.ToString();
return ok;
}
/// <summary>
/// This method can be used to send multiple messages to a queue or a topic.
/// </summary>
/// <param name="messageSender">A MessageSender object used to send messages.</param>
/// <param name="messageTemplateEnumerable">A collection of message templates to use to clone messages from.</param>
/// <param name="getMessageNumber">This function returns the message number.</param>
/// <param name="messageCount">The total number of messages to send.</param>
/// <param name="taskId">The sender task id.</param>
/// <param name="updateMessageId">Indicates whether to use a unique id for each message.</param>
/// <param name="addMessageNumber">Indicates whether to add a message number property.</param>
/// <param name="oneSessionPerTask">Indicates whether to use a different session for each sender task.</param>
/// <param name="logging">Indicates whether to enable logging of message content and properties.</param>
/// <param name="verbose">Indicates whether to enable verbose logging.</param>
/// <param name="statistics">Indicates whether to enable sender statistics.</param>
/// <param name="messageInspector">A BrokeredMessage inspector object.</param>
/// <param name="updateStatistics">When statistics = true, this delegate is invoked to update statistics.</param>
/// <param name="sendBatch">Indicates whether to use SendBatch.</param>
/// <param name="isBinary">Indicates if the body is binary or not.</param>
/// <param name="senderThinkTime">Indicates whether to use think time.</param>
/// <param name="thinkTime">Indicates the value of the sender think time.</param>
/// <param name="batchSize">Indicates the batch size.</param>
/// <param name="bodyType">Contains the body type.</param>
/// <param name="cancellationTokenSource">The cancellation token.</param>
/// <param name="traceMessage">A trace message.</param>
/// <returns>True if the method completed without exceptions, false otherwise.</returns>
public bool SendMessages(MessageSender messageSender,
IEnumerable<BrokeredMessage> messageTemplateEnumerable,
Func<long> getMessageNumber,
long messageCount,
int taskId,
bool updateMessageId,
bool addMessageNumber,
bool oneSessionPerTask,
bool logging,
bool verbose,
bool statistics,
bool sendBatch,
bool isBinary,
int batchSize,
bool senderThinkTime,
int thinkTime,
BodyType bodyType,
IBrokeredMessageInspector messageInspector,
UpdateStatisticsDelegate updateStatistics,
CancellationTokenSource cancellationTokenSource,
out string traceMessage)
{
if (messageSender == null)
{
throw new ArgumentNullException(MessageSenderCannotBeNull);
}
if (messageTemplateEnumerable == null)
{
throw new ArgumentNullException(BrokeredMessageCannotBeNull);
}
if (cancellationTokenSource == null)
{
throw new ArgumentNullException(CancellationTokenSourceCannotBeNull);
}
var messageTemplateCircularList = new CircularList<BrokeredMessage>(messageTemplateEnumerable);
long messagesSent = 0;
long totalElapsedTime = 0;
long minimumSendTime = long.MaxValue;
long maximumSendTime = 0;
bool ok = true;
string exceptionMessage = null;
var wcfUri = IsCloudNamespace ?
new Uri(namespaceUri, messageSender.Path) :
new UriBuilder
{
Host = namespaceUri.Host,
Path = string.Format("{0}/{1}", namespaceUri.AbsolutePath, messageSender.Path),
Scheme = "sb"
}.Uri;
try
{
long messageNumber;
if (sendBatch && batchSize > 1)
{
var more = true;
while (!cancellationTokenSource.Token.IsCancellationRequested && more)
{
var messageList = new List<BrokeredMessage>();
var messageNumberList = new List<long>();
while (!cancellationTokenSource.Token.IsCancellationRequested &&
messageNumberList.Count < batchSize && more)
{
messageNumber = getMessageNumber();
if (messageNumber < messageCount)
{
messageNumberList.Add(messageNumber);
}
else
{
more = false;
}
}
if (messageNumberList.Count > 0)
{
long elapsedMilliseconds = 0;
RetryHelper.RetryAction(() =>
{
var useWcf = bodyType == BodyType.Wcf;
for (var i = 0; i < messageNumberList.Count; i++)
{
messageList.Add(useWcf?
CreateMessageForWcfReceiver(
messageTemplateCircularList.Next,
taskId,
updateMessageId,
oneSessionPerTask,
wcfUri) :
CreateMessageForApiReceiver(
messageTemplateCircularList.Next,
taskId,
updateMessageId,
oneSessionPerTask,
isBinary,
bodyType,
messageInspector));
if (addMessageNumber)
{
messageList[i].Properties[MessageNumber] = messageNumberList[i];
}
}
if (messageNumberList.Count > 0)
{
SendBatch(messageSender,
messageList,
taskId,
isBinary,
useWcf,
logging,
verbose,
out elapsedMilliseconds);
}
},
writeToLog);
messagesSent += messageList.Count;
if (elapsedMilliseconds > maximumSendTime)
{
maximumSendTime = elapsedMilliseconds;
}
if (elapsedMilliseconds < minimumSendTime)
{
minimumSendTime = elapsedMilliseconds;
}
totalElapsedTime += elapsedMilliseconds;
if (statistics)
{
updateStatistics(messageList.Count, elapsedMilliseconds, DirectionType.Send);
}
}
if (senderThinkTime)
{
WriteToLog(string.Format(SleepingFor, thinkTime));
Thread.Sleep(thinkTime);
}
}
}
else
{
while ((messageNumber = getMessageNumber()) < messageCount &&
!cancellationTokenSource.Token.IsCancellationRequested)
{
long elapsedMilliseconds = 0;
RetryHelper.RetryAction(() =>
{
var useWcf = bodyType == BodyType.Wcf;
var outboundMessage = useWcf
? CreateMessageForWcfReceiver(
messageTemplateCircularList.Next,
taskId,
updateMessageId,
oneSessionPerTask,
wcfUri)
: CreateMessageForApiReceiver(
messageTemplateCircularList.Next,
taskId,
updateMessageId,
oneSessionPerTask,
isBinary,
bodyType,
messageInspector);
if (addMessageNumber)
{
// ReSharper disable AccessToModifiedClosure
outboundMessage.Properties[MessageNumber] = messageNumber;
// ReSharper restore AccessToModifiedClosure
}
SendMessage(messageSender,
outboundMessage,
taskId,
isBinary,
useWcf,
logging,
verbose,
out elapsedMilliseconds);
},
writeToLog);
messagesSent++;
if (elapsedMilliseconds > maximumSendTime)
{
maximumSendTime = elapsedMilliseconds;
}
if (elapsedMilliseconds < minimumSendTime)
{
minimumSendTime = elapsedMilliseconds;
}
totalElapsedTime += elapsedMilliseconds;
if (statistics)
{
updateStatistics(1, elapsedMilliseconds, DirectionType.Send);
}
if (senderThinkTime)
{
WriteToLog(string.Format(SleepingFor, thinkTime));
Thread.Sleep(thinkTime);
}
}
}
}
catch (ServerBusyException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (MessageLockLostException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (CommunicationObjectAbortedException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (CommunicationObjectFaultedException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (CommunicationException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (TimeoutException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (Exception ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
var averageSendTime = messagesSent > 0 ? totalElapsedTime / messagesSent : maximumSendTime;
// ReSharper disable RedundantCast
var messagesPerSecond = totalElapsedTime > 0 ? (double)(messagesSent * 1000) / (double)totalElapsedTime : 0;
// ReSharper restore RedundantCast
var builder = new StringBuilder();
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatisticsHeader,
taskId));
if (!string.IsNullOrWhiteSpace(exceptionMessage))
{
builder.AppendLine(exceptionMessage);
}
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatitiscsLine1,
messagesSent,
messagesPerSecond,
totalElapsedTime));
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatitiscsLine2,
averageSendTime,
minimumSendTime == long.MaxValue ? 0 : minimumSendTime,
maximumSendTime));
traceMessage = builder.ToString();
return ok;
}
/// <summary>
/// This method is used to receive message from a queue or a subscription.
/// </summary>
/// <param name="messageReceiver">The message receiver used to receive messages.</param>
/// <param name="taskId">The receiver task id.</param>
/// <param name="timeout">The receive receiveTimeout.</param>
/// <param name="filter">The filter expression is used to determine messages to move the dead-letter queue or to defer.</param>
/// <param name="moveToDeadLetterQueue">Indicates whether to move messages to the dead-letter queue.</param>
/// <param name="completeReceive">Indicates whether to complete a receive operation when ReceiveMode is equal to PeekLock.</param>
/// <param name="defer">Indicates whether to defer messages.</param>
/// <param name="logging">Indicates whether logging of message content and properties is enabled.</param>
/// <param name="verbose">Indicates whether verbose logging is enabled.</param>
/// <param name="statistics">Indicates whether to enable receiver statistics.</param>
/// <param name="updateStatistics">When statistics = true, this delegate is invoked to update statistics.</param>
/// <param name="cancellationTokenSource">The cancellation token.</param>
/// <param name="traceMessage">A trace message.</param>
/// <returns>True if the method completed without exceptions, false otherwise.</returns>
public bool ReceiveMessages(MessageReceiver messageReceiver,
int taskId,
int timeout,
Filter filter,
bool moveToDeadLetterQueue,
bool completeReceive,
bool defer,
bool logging,
bool verbose,
bool statistics,
UpdateStatisticsDelegate updateStatistics,
CancellationTokenSource cancellationTokenSource,
out string traceMessage)
{
if (messageReceiver == null)
{
throw new ArgumentNullException(MessageReceiverCannotBeNull);
}
if (cancellationTokenSource == null)
{
throw new ArgumentNullException(CancellationTokenSourceCannotBeNull);
}
BrokeredMessage inboundMessage = null;
StringBuilder builder;
var isCompleted = false;
var ok = true;
var receivedFromDeadLetterQueue = messageReceiver.Path.EndsWith(DeadLetterQueue);
var readingDeferredMessages = false;
long messagesReceived = 0;
long totalElapsedTime = 0;
long minimumReceiveTime = long.MaxValue;
long maximumReceiveTime = 0;
string exceptionMessage = null;
MessageEncoder encoder = null;
var messageDeferProvider = Activator.CreateInstance(messageDeferProviderType) as IMessageDeferProvider;
try
{
MessageEncodingBindingElement element;
if (scheme == DefaultScheme)
{
element = new BinaryMessageEncodingBindingElement();
}
else
{
element = new TextMessageEncodingBindingElement();
}
var encoderFactory = element.CreateMessageEncoderFactory();
encoder = encoderFactory.Encoder;
while (!isCompleted &&
!cancellationTokenSource.Token.IsCancellationRequested)
{
try
{
var stopwatch = new Stopwatch();
var movedToDeadLetterQueue = false;
var deferredMessage = false;
var readDeferredMessage = false;
if (!readingDeferredMessages)
{
stopwatch.Start();
inboundMessage = messageReceiver.Receive(TimeSpan.FromSeconds(timeout));
stopwatch.Stop();
isCompleted = inboundMessage == null &&
messageDeferProvider.Count == 0;
}
else
{
isCompleted = messageDeferProvider.Count == 0;
if (!isCompleted)
{
long sequenceNumber;
if (messageDeferProvider.Dequeue(out sequenceNumber))
{
stopwatch.Start();
inboundMessage = messageReceiver.Receive(sequenceNumber);
stopwatch.Stop();
readDeferredMessage = true;
}
}
}
if (!readingDeferredMessages)
{
readingDeferredMessages = inboundMessage == null && messageDeferProvider.Count > 0;
}
if (isCompleted ||
inboundMessage == null)
{
continue;
}
if (stopwatch.ElapsedMilliseconds > maximumReceiveTime)
{
maximumReceiveTime = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds < minimumReceiveTime)
{
minimumReceiveTime = stopwatch.ElapsedMilliseconds;
}
totalElapsedTime += stopwatch.ElapsedMilliseconds;
if (statistics)
{
updateStatistics(stopwatch.ElapsedMilliseconds, DirectionType.Receive);
}
builder = new StringBuilder();
if (defer &&
!readingDeferredMessages &&
filter != null &&
filter.Match(inboundMessage))
{
inboundMessage.Defer();
messageDeferProvider.Enqueue(inboundMessage.SequenceNumber);
deferredMessage = true;
}
if (!deferredMessage &&
moveToDeadLetterQueue &&
filter != null &&
filter.Match(inboundMessage))
{
inboundMessage.DeadLetter();
movedToDeadLetterQueue = true;
messagesReceived++;
}
if (!deferredMessage &&
!movedToDeadLetterQueue)
{
if (messageReceiver.Mode == ReceiveMode.PeekLock)
{
if (completeReceive)
{
inboundMessage.Complete();
messagesReceived++;
}
else
{
inboundMessage.Abandon();
}
}
else
{
messagesReceived++;
}
}
if (logging)
{
if (messageReceiver.Mode == ReceiveMode.PeekLock &&
!completeReceive &&
!deferredMessage &&
!movedToDeadLetterQueue)
{
builder.AppendLine(string.Format(MessagePeekedButNotConsumed,
taskId,
string.IsNullOrEmpty(inboundMessage.MessageId)
? NullValue
: inboundMessage.MessageId,
string.IsNullOrEmpty(inboundMessage.SessionId)
? NullValue
: inboundMessage.SessionId,
string.IsNullOrEmpty(inboundMessage.Label)
? NullValue
: inboundMessage.Label,
inboundMessage.Size));
}
else
{
builder.AppendLine(string.Format(MessageSuccessfullyReceived,
taskId,
string.IsNullOrEmpty(inboundMessage.MessageId)
? NullValue
: inboundMessage.MessageId,
string.IsNullOrEmpty(inboundMessage.SessionId)
? NullValue
: inboundMessage.SessionId,
string.IsNullOrEmpty(inboundMessage.Label)
? NullValue
: inboundMessage.Label,
inboundMessage.Size,
inboundMessage.DeliveryCount));
}
if (deferredMessage)
{
builder.AppendLine(MessageDeferred);
}
if (readDeferredMessage)
{
builder.AppendLine(ReadMessageDeferred);
}
if (movedToDeadLetterQueue)
{
builder.AppendLine(MessageMovedToDeadLetterQueue);
}
if (receivedFromDeadLetterQueue)
{
builder.AppendLine(MessageReadFromDeadLetterQueue);
}
if (verbose)
{
GetMessageAndProperties(builder, inboundMessage, encoder);
}
}
if (logging)
{
traceMessage = builder.ToString();
WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
}
catch (Exception ex)
{
if (inboundMessage != null &&
messageReceiver.Mode == ReceiveMode.PeekLock)
{
try
{
inboundMessage.Abandon();
}
catch (Exception)
{
}
}
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
isCompleted = true;
ok = false;
}
finally
{
if (inboundMessage != null)
{
inboundMessage.Dispose();
}
}
}
}
catch (Exception ex)
{
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
if (messagesReceived == 0)
{
WriteToLog(string.Format(NoMessageWasReceived, taskId));
}
var averageReceiveTime = messagesReceived > 0 ? totalElapsedTime / messagesReceived : maximumReceiveTime;
var messagesPerSecond = totalElapsedTime > 0 ? (double)(messagesReceived * 1000) / (double)totalElapsedTime : 0;
builder = new StringBuilder();
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatisticsHeader,
taskId));
if (!string.IsNullOrEmpty(exceptionMessage))
{
builder.AppendLine(exceptionMessage);
}
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatitiscsLine1,
messagesReceived,
messagesPerSecond,
totalElapsedTime));
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
ReceiverStatitiscsLine2,
averageReceiveTime,
minimumReceiveTime == long.MaxValue ? 0 : minimumReceiveTime,
maximumReceiveTime));
traceMessage = builder.ToString();
return ok;
}
/// <summary>
/// This method can be used to send multiple messages to a queue or a topic.
/// </summary>
/// <param name="eventHubClient">An EventHubClient object used to send messages.</param>
/// <param name="eventDataTemplateEnumerable">A collection of message templates to use to clone messages from.</param>
/// <param name="getMessageNumber">This function returns the message number.</param>
/// <param name="messageCount">The total number of messages to send.</param>
/// <param name="taskId">The sender task id.</param>
/// <param name="updatePartitionKey">Indicates whether to use a unique template key for each message.</param>
/// <param name="addMessageNumber">Indicates whether to add a message number property.</param>
/// <param name="logging">Indicates whether to enable logging of message content and properties.</param>
/// <param name="verbose">Indicates whether to enable verbose logging.</param>
/// <param name="statistics">Indicates whether to enable sender statistics.</param>
/// <param name="eventDataInspector">Event Data inspector.</param>
/// <param name="updateStatistics">When statistics = true, this delegate is invoked to update statistics.</param>
/// <param name="sendBatch">Indicates whether to use SendBatch.</param>
/// <param name="senderThinkTime">Indicates whether to use think time.</param>
/// <param name="thinkTime">Indicates the value of the sender think time.</param>
/// <param name="batchSize">Indicates the batch size.</param>
/// <param name="cancellationTokenSource">The cancellation token.</param>
/// <returns>Trace message.</returns>
public async Task<string> SendEventData(EventHubClient eventHubClient,
IEnumerable<EventData> eventDataTemplateEnumerable,
Func<long> getMessageNumber,
long messageCount,
int taskId,
bool updatePartitionKey,
bool addMessageNumber,
bool logging,
bool verbose,
bool statistics,
bool sendBatch,
int batchSize,
bool senderThinkTime,
int thinkTime,
IEventDataInspector eventDataInspector,
UpdateStatisticsDelegate updateStatistics,
CancellationTokenSource cancellationTokenSource)
{
if (eventHubClient == null)
{
throw new ArgumentNullException(EventHubClientCannotBeNull);
}
if (eventDataTemplateEnumerable == null)
{
throw new ArgumentNullException(EventDataTemplateEnumerableCannotBeNull);
}
if (cancellationTokenSource == null)
{
throw new ArgumentNullException(CancellationTokenSourceCannotBeNull);
}
var eventDataCircularList = new CircularList<EventData>(eventDataTemplateEnumerable);
long messagesSent = 0;
long totalElapsedTime = 0;
long minimumSendTime = long.MaxValue;
long maximumSendTime = 0;
string exceptionMessage = null;
try
{
if (sendBatch && batchSize > 1)
{
//var more = true;
//while (!cancellationTokenSource.Token.IsCancellationRequested && more)
//{
// var eventDataList = new List<EventData>();
// var messageNumberList = new List<long>();
// while (!cancellationTokenSource.Token.IsCancellationRequested &&
// messageNumberList.Count < batchSize && more)
// {
// messageNumber = getMessageNumber();
// if (messageNumber < messageCount)
// {
// messageNumberList.Add(messageNumber);
// }
// else
// {
// more = false;
// }
// }
// if (messageNumberList.Count > 0)
// {
// long elapsedMilliseconds = 0;
// await RetryHelper.RetryActionAsync(async () =>
// {
// for (var i = 0; i < messageNumberList.Count; i++)
// {
// eventDataList.Add(eventDataInspector != null?
// eventDataInspector.BeforeSendMessage(eventDataCircularList.Next.Clone()) :
// eventDataCircularList.Next.Clone());
// if (addMessageNumber)
// {
// eventDataList[i].Properties[MessageNumber] = messageNumberList[i];
// }
// }
// if (messageNumberList.Count > 0)
// {
// elapsedMilliseconds = await SendEventDataBatch(eventHubClient,
// eventDataList,
// messageNumberList,
// taskId,
// logging,
// verbose);
// }
// },
// writeToLog);
// messagesSent += eventDataList.Count;
// if (elapsedMilliseconds > maximumSendTime)
// {
// maximumSendTime = elapsedMilliseconds;
// }
// if (elapsedMilliseconds < minimumSendTime)
// {
// minimumSendTime = elapsedMilliseconds;
// }
// totalElapsedTime += elapsedMilliseconds;
// if (statistics)
// {
// updateStatistics(eventDataList.Count, elapsedMilliseconds, DirectionType.Send);
// }
// }
// if (senderThinkTime)
// {
// WriteToLog(string.Format(SleepingFor, thinkTime));
// Thread.Sleep(thinkTime);
// }
//}
}
else
{
long messageNumber;
while ((messageNumber = getMessageNumber()) < messageCount &&
!cancellationTokenSource.Token.IsCancellationRequested)
{
long elapsedMilliseconds = 0;
long number = messageNumber;
await RetryHelper.RetryActionAsync(async () =>
{
var eventData = eventDataInspector != null ?
eventDataInspector.BeforeSendMessage(eventDataCircularList.Next.Clone()) :
eventDataCircularList.Next.Clone();
if (addMessageNumber)
{
// ReSharper disable AccessToModifiedClosure
eventData.Properties[MessageNumber] = number;
// ReSharper restore AccessToModifiedClosure
}
elapsedMilliseconds = await SendEventData(eventHubClient,
eventData,
number,
taskId,
logging,
verbose);
},
writeToLog);
messagesSent++;
if (elapsedMilliseconds > maximumSendTime)
{
maximumSendTime = elapsedMilliseconds;
}
if (elapsedMilliseconds < minimumSendTime)
{
minimumSendTime = elapsedMilliseconds;
}
totalElapsedTime += elapsedMilliseconds;
if (statistics)
{
updateStatistics(1, elapsedMilliseconds, DirectionType.Send);
}
if (senderThinkTime)
{
WriteToLog(string.Format(SleepingFor, thinkTime));
Thread.Sleep(thinkTime);
}
}
}
}
catch (ServerBusyException ex)
{
eventHubClient.Abort();
exceptionMessage = ex.Message;
}
catch (MessageLockLostException ex)
{
eventHubClient.Abort();
exceptionMessage = ex.Message;
}
catch (CommunicationObjectAbortedException ex)
{
eventHubClient.Abort();
exceptionMessage = ex.Message;
}
catch (CommunicationObjectFaultedException ex)
{
eventHubClient.Abort();
exceptionMessage = ex.Message;
}
catch (CommunicationException ex)
{
eventHubClient.Abort();
exceptionMessage = ex.Message;
}
catch (TimeoutException ex)
{
eventHubClient.Abort();
exceptionMessage = ex.Message;
}
catch (Exception ex)
{
eventHubClient.Abort();
exceptionMessage = ex.Message;
}
var averageSendTime = messagesSent > 0 ? totalElapsedTime / messagesSent : maximumSendTime;
// ReSharper disable RedundantCast
var messagesPerSecond = totalElapsedTime > 0 ? (double)(messagesSent * 1000) / (double)totalElapsedTime : 0;
// ReSharper restore RedundantCast
var builder = new StringBuilder();
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatisticsHeader,
taskId));
if (!string.IsNullOrWhiteSpace(exceptionMessage))
{
builder.AppendLine(exceptionMessage);
throw new Exception(builder.ToString());
}
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatitiscsLine1,
messagesSent,
messagesPerSecond,
totalElapsedTime));
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatitiscsLine2,
averageSendTime,
minimumSendTime == long.MaxValue ? 0 : minimumSendTime,
maximumSendTime));
return builder.ToString();
}
/// <summary>
/// This method can be used to send multiple messages to a queue or a topic.
/// </summary>
/// <param name="messageSender">A MessageSender object used to send messages.</param>
/// <param name="messageTemplate">The message template to use to clone messages from.</param>
/// <param name="getMessageNumber">This function returns the message number.</param>
/// <param name="messageCount">The total number of messages to send.</param>
/// <param name="messageText">The message text.</param>
/// <param name="taskId">The sender task id.</param>
/// <param name="updateMessageId">Indicates whether to use a unique id for each message.</param>
/// <param name="addMessageNumber">Indicates whether to add a message number property.</param>
/// <param name="oneSessionPerTask">Indicates whether to use a different session for each sender task.</param>
/// <param name="logging">Indicates whether to enable logging of message content and properties.</param>
/// <param name="verbose">Indicates whether to enable verbose logging.</param>
/// <param name="statistics">Indicates whether to enable sender statistics.</param>
/// <param name="updateStatistics">When statistics = true, this delegate is invoked to update statistics.</param>
/// <param name="bodyType">Contains the body type.</param>
/// <param name="cancellationTokenSource">The cancellation token.</param>
/// <param name="traceMessage">A trace message.</param>
/// <returns>True if the method completed without exceptions, false otherwise.</returns>
public bool SendMessages(MessageSender messageSender,
BrokeredMessage messageTemplate,
Func<long> getMessageNumber,
long messageCount,
string messageText,
int taskId,
bool updateMessageId,
bool addMessageNumber,
bool oneSessionPerTask,
bool logging,
bool verbose,
bool statistics,
BodyType bodyType,
UpdateStatisticsDelegate updateStatistics,
CancellationTokenSource cancellationTokenSource,
out string traceMessage)
{
if (messageSender == null)
{
throw new ArgumentNullException(MessageSenderCannotBeNull);
}
if (messageTemplate == null)
{
throw new ArgumentNullException(BrokeredMessageCannotBeNull);
}
if (cancellationTokenSource == null)
{
throw new ArgumentNullException(CancellationTokenSourceCannotBeNull);
}
long messagesSent = 0;
long totalElapsedTime = 0;
long minimumSendTime = long.MaxValue;
long maximumSendTime = 0;
bool ok = true;
string exceptionMessage = null;
try
{
long messageNumber;
while ((messageNumber = getMessageNumber()) < messageCount &&
!cancellationTokenSource.Token.IsCancellationRequested)
{
long elapsedMilliseconds = 0;
RetryHelper.RetryAction(() =>
{
var useWcf = bodyType == BodyType.Wcf;
var outboundMessage = useWcf
? CreateMessageForWcfReceiver(
messageTemplate,
taskId,
updateMessageId,
oneSessionPerTask,
messageText,
messageSender.Path)
: CreateMessageForApiReceiver(
messageTemplate,
taskId,
updateMessageId,
oneSessionPerTask,
messageText,
bodyType);
if (addMessageNumber)
{
outboundMessage.Properties[MessageNumber] = messageNumber;
}
SendMessage(messageSender,
outboundMessage,
messageText,
taskId,
useWcf,
logging,
verbose,
out elapsedMilliseconds);
},
writeToLog);
messagesSent++;
if (elapsedMilliseconds > maximumSendTime)
{
maximumSendTime = elapsedMilliseconds;
}
if (elapsedMilliseconds < minimumSendTime)
{
minimumSendTime = elapsedMilliseconds;
}
totalElapsedTime += elapsedMilliseconds;
if (statistics)
{
updateStatistics(elapsedMilliseconds, DirectionType.Send);
}
}
}
catch (ServerBusyException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (MessageLockLostException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (CommunicationObjectAbortedException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (CommunicationObjectFaultedException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (CommunicationException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (TimeoutException ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
catch (Exception ex)
{
messageSender.Abort();
exceptionMessage = string.Format(ExceptionOccurred, ex.Message);
ok = false;
}
var averageSendTime = messagesSent > 0 ? totalElapsedTime / messagesSent : maximumSendTime;
var messagesPerSecond = totalElapsedTime > 0 ? (double)(messagesSent * 1000) / (double)totalElapsedTime : 0;
var builder = new StringBuilder();
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatisticsHeader,
taskId));
if (!string.IsNullOrEmpty(exceptionMessage))
{
builder.AppendLine(exceptionMessage);
}
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatitiscsLine1,
messagesSent,
messagesPerSecond,
totalElapsedTime));
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
SenderStatitiscsLine2,
averageSendTime,
minimumSendTime == long.MaxValue ? 0 : minimumSendTime,
maximumSendTime));
traceMessage = builder.ToString();
return ok;
}
