/// <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="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;
}
private async void btnStart_Click(object sender, EventArgs e)
{
try
{
if (btnStart.Text == StopCaption)
{
await CancelActions();
btnStart.Text = StartCaption;
return;
}
if (serviceBusHelper != null &&
ValidateParameters())
{
startLog?.Invoke();
btnStart.Enabled = false;
Cursor.Current = Cursors.WaitCursor;
//*****************************************************************************************************
// Retrieve Messaging Factory
//*****************************************************************************************************
var messagingFactory = serviceBusHelper.MessagingFactory;
//*****************************************************************************************************
// Initialize Statistics and Manager Action
//*****************************************************************************************************
actionCount = 0;
receiverMessageNumber = 0;
receiverMessagesPerSecond = 0;
receiverMinimumTime = long.MaxValue;
receiverMaximumTime = 0;
receiverAverageTime = 0;
receiverTotalTime = 0;
if (checkBoxReceiverEnableGraph.Checked)
{
chart.Series.ToList().ForEach(s => s.Points.Clear());
}
managerResetEvent = new ManualResetEventSlim(false);
Action <CancellationTokenSource> managerAction = cts =>
{
if (cts == null)
{
return;
}
try
{
managerResetEvent.Wait(cts.Token);
}
catch (OperationCanceledException)
{
}
if (!cts.IsCancellationRequested)
{
Invoke((MethodInvoker)async delegate
{
btnStart.Text = StartCaption;
await MainForm.SingletonMainForm.RefreshSelectedEntity();
});
}
};
Action updateGraphAction = () =>
{
var ok = true;
long max = 10;
while (!graphCancellationTokenSource.IsCancellationRequested && (actionCount > 1 || ok))
{
ok = true;
long receiveMessageNumber = 0;
long receiveTotalTime = 0;
while (ok && receiveMessageNumber < max)
{
ok = blockingCollection.TryTake(out var tuple, 10);
if (ok)
{
receiveMessageNumber += tuple.Item1;
receiveTotalTime += tuple.Item2;
if (receiveMessageNumber > max)
{
max = receiveMessageNumber;
}
}
}
if (receiveMessageNumber > 0)
{
var receiveTuple = new Tuple <long, long, DirectionType>(receiveMessageNumber, receiveTotalTime, DirectionType.Receive);
if (InvokeRequired)
{
Invoke(new UpdateStatisticsDelegate(InternalUpdateStatistics), receiveTuple.Item1, receiveTuple.Item2, receiveTuple.Item3);
}
else
{
InternalUpdateStatistics(receiveTuple.Item1,
receiveTuple.Item2,
receiveTuple.Item3);
}
}
}
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
};
AsyncCallback updateGraphCallback = a =>
{
var action = a.AsyncState as Action;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
blockingCollection = new BlockingCollection <Tuple <long, long, DirectionType> >();
//*****************************************************************************************************
// Receiving messages from a Subscription
//*****************************************************************************************************
var currentSubscription = subscriptionWrapper.SubscriptionDescription;
if (currentSubscription == null)
{
throw new ArgumentException(NoSubscriptionSelected);
}
var currentReceiveMode = cboReceivedMode.Text == PeekLock ?
ReceiveMode.PeekLock :
ReceiveMode.ReceiveAndDelete;
var currentMoveToDeadLetterQueue = checkBoxMoveToDeadLetter.Checked;
var currentReadFromDeadLetterQueue = checkBoxReadFromDeadLetter.Checked;
try
{
receiverCancellationTokenSource = new CancellationTokenSource();
receiverCancellationTokenSource = new CancellationTokenSource();
receiverBrokeredMessageInspector = cboReceiverInspector.SelectedIndex > 0
? Activator.CreateInstance(serviceBusHelper.BrokeredMessageInspectors[cboReceiverInspector.Text]) as IBrokeredMessageInspector
: null;
Action <int> receiverAction = taskId =>
{
var allSessionsAccepted = false;
while (!allSessionsAccepted)
{
try
{
MessageReceiver messageReceiver;
if (currentReadFromDeadLetterQueue)
{
messageReceiver =
messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(currentSubscription.TopicPath,
currentSubscription.Name),
currentReceiveMode);
}
else
{
if (currentSubscription.RequiresSession)
{
var subscriptionClient = messagingFactory.CreateSubscriptionClient(currentSubscription.TopicPath,
currentSubscription.Name,
currentReceiveMode);
messageReceiver = subscriptionClient.AcceptMessageSession(TimeSpan.FromSeconds(sessionTimeout));
}
else
{
messageReceiver = messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatSubscriptionPath(currentSubscription.TopicPath,
currentSubscription.Name),
currentReceiveMode);
}
}
messageReceiver.PrefetchCount = prefetchCount;
string traceMessage;
if (checkBoxReceiverUseTransaction.Checked)
{
using (var scope = new TransactionScope())
{
serviceBusHelper.ReceiveMessages(messageReceiver,
taskId,
receiveTimeout,
filter,
currentMoveToDeadLetterQueue,
checkBoxCompleteReceive.Checked,
checkBoxDeferMessage.Checked,
checkBoxEnableReceiverLogging.Checked,
checkBoxReceiverVerboseLogging.Checked,
checkBoxReceiverEnableStatistics.Checked,
checkBoxReceiveBatch.Checked,
receiverBatchSize,
checkBoxReceiverThinkTime.Checked,
receiverThinkTime,
receiverBrokeredMessageInspector,
UpdateStatistics,
receiverCancellationTokenSource,
out traceMessage);
var builder = new StringBuilder(traceMessage);
if (checkBoxReceiverCommitTransaction.Checked)
{
scope.Complete();
builder.AppendLine(TransactionCommitted);
}
else
{
builder.AppendLine(TransactionAborted);
}
traceMessage = builder.ToString();
}
}
else
{
serviceBusHelper.ReceiveMessages(messageReceiver,
taskId,
receiveTimeout,
filter,
currentMoveToDeadLetterQueue,
checkBoxCompleteReceive.Checked,
checkBoxDeferMessage.Checked,
checkBoxEnableReceiverLogging.Checked,
checkBoxReceiverVerboseLogging.Checked,
checkBoxReceiverEnableStatistics.Checked,
checkBoxReceiveBatch.Checked,
receiverBatchSize,
checkBoxReceiverThinkTime.Checked,
receiverThinkTime,
receiverBrokeredMessageInspector,
UpdateStatistics,
receiverCancellationTokenSource,
out traceMessage);
}
if (!string.IsNullOrWhiteSpace(traceMessage))
{
writeToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
allSessionsAccepted = !currentSubscription.RequiresSession;
}
catch (TimeoutException ex)
{
if (currentSubscription.RequiresSession)
{
writeToLog(string.Format(NoMoreSessionsToAccept, taskId));
allSessionsAccepted = true;
}
else
{
HandleException(ex);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
};
// Define Receiver AsyncCallback
AsyncCallback receiverCallback = a =>
{
var action = a.AsyncState as Action <int>;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
// Start Receiver Actions
for (var i = 0; i < receiverTaskCount; i++)
{
receiverAction.BeginInvoke(i, receiverCallback, receiverAction);
Interlocked.Increment(ref actionCount);
}
}
catch (Exception ex)
{
HandleException(ex);
}
if (actionCount > 0)
{
managerCancellationTokenSource = new CancellationTokenSource();
managerAction.BeginInvoke(managerCancellationTokenSource, null, null);
graphCancellationTokenSource = new CancellationTokenSource();
updateGraphAction.BeginInvoke(updateGraphCallback, updateGraphAction);
Interlocked.Increment(ref actionCount);
btnStart.Text = StopCaption;
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
finally
{
btnStart.Enabled = true;
Cursor.Current = Cursors.Default;
}
}
/// <summary>
/// Create a BrokeredMessage object
/// </summary>
/// <param name="messageTemplate">The message template.</param>
/// <param name="taskId">The task Id.</param>
/// <param name="updateMessageId">Indicates whether to use a unique id for each message.</param>
/// <param name="oneSessionPerTask">Indicates whether to use a different session for each sender task.</param>
/// <param name="isBinary">Indicates if the body is binary or not.</param>
/// <param name="bodyType">Contains the body type.</param>
/// <param name="messageInspector">A BrokeredMessage inspector object.</param>
/// <returns>The cloned BrokeredMessage object.</returns>
public BrokeredMessage CreateMessageForApiReceiver(BrokeredMessage messageTemplate,
int taskId,
bool updateMessageId,
bool oneSessionPerTask,
bool isBinary,
BodyType bodyType,
IBrokeredMessageInspector messageInspector)
{
if (messageTemplate == null)
{
throw new ArgumentNullException(BrokeredMessageCannotBeNull);
}
var outboundMessage = messageTemplate.Clone();
if (bodyType == BodyType.String)
{
using (var reader = new StreamReader(outboundMessage.GetBody<Stream>()))
{
outboundMessage = new BrokeredMessage(reader.ReadToEnd());
}
}
outboundMessage.MessageId = updateMessageId ? Guid.NewGuid().ToString() : messageTemplate.MessageId;
outboundMessage.SessionId = oneSessionPerTask ? taskId.ToString(CultureInfo.InvariantCulture) : messageTemplate.SessionId;
if (bodyType == BodyType.String)
{
if (!string.IsNullOrWhiteSpace(messageTemplate.Label))
{
outboundMessage.Label = messageTemplate.Label;
}
if (!string.IsNullOrWhiteSpace(messageTemplate.ContentType))
{
outboundMessage.ContentType = messageTemplate.ContentType;
}
if (!string.IsNullOrWhiteSpace(messageTemplate.CorrelationId))
{
outboundMessage.CorrelationId = messageTemplate.CorrelationId;
}
if (!string.IsNullOrWhiteSpace(messageTemplate.To))
{
outboundMessage.To = messageTemplate.To;
}
if (!string.IsNullOrWhiteSpace(messageTemplate.ReplyTo))
{
outboundMessage.ReplyTo = messageTemplate.ReplyTo;
}
if (!string.IsNullOrWhiteSpace(messageTemplate.ReplyToSessionId))
{
outboundMessage.ReplyToSessionId = messageTemplate.ReplyToSessionId;
}
foreach (var property in messageTemplate.Properties)
{
outboundMessage.Properties.Add(property.Key, property.Value);
}
outboundMessage.TimeToLive = messageTemplate.TimeToLive;
outboundMessage.ScheduledEnqueueTimeUtc = messageTemplate.ScheduledEnqueueTimeUtc;
outboundMessage.ForcePersistence = messageTemplate.ForcePersistence;
}
if (messageInspector != null)
{
outboundMessage = messageInspector.BeforeSendMessage(outboundMessage);
}
return outboundMessage;
}
private void ReadDeadletterMessagesOneAtTheTime(bool peek, bool all, int count, IBrokeredMessageInspector messageInspector)
{
try
{
var brokeredMessages = new List<BrokeredMessage>();
if (peek)
{
var messageReceiver = serviceBusHelper.MessagingFactory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(subscriptionWrapper.SubscriptionDescription.TopicPath,
subscriptionWrapper.SubscriptionDescription.Name),
ReceiveMode.PeekLock);
for (var i = 0; i < count; i++)
{
var message = messageReceiver.Peek();
if (message != null)
{
if (messageInspector != null)
{
message = messageInspector.AfterReceiveMessage(message);
}
brokeredMessages.Add(message);
}
}
writeToLog(string.Format(MessagesPeekedFromTheDeadletterQueue, brokeredMessages.Count, subscriptionWrapper.SubscriptionDescription.Name));
}
else
{
var messageReceiver = serviceBusHelper.MessagingFactory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(subscriptionWrapper.SubscriptionDescription.TopicPath,
subscriptionWrapper.SubscriptionDescription.Name),
ReceiveMode.ReceiveAndDelete);
var totalRetrieved = 0;
int retrieved;
do
{
var message = messageReceiver.Receive(TimeSpan.FromSeconds(MainForm.SingletonMainForm.ReceiveTimeout));
retrieved = message != null ? 1 : 0;
if (retrieved == 0)
{
continue;
}
totalRetrieved += retrieved;
brokeredMessages.Add(messageInspector != null ? messageInspector.AfterReceiveMessage(message) : message);
}
while (retrieved > 0 && (all || count > totalRetrieved));
writeToLog(string.Format(MessagesReceivedFromTheDeadletterQueue, brokeredMessages.Count, subscriptionWrapper.SubscriptionDescription.Name));
}
deadletterBindingList = new SortableBindingList<BrokeredMessage>(brokeredMessages)
{
AllowEdit = false,
AllowNew = false,
AllowRemove = false
};
deadletterBindingSource.DataSource = deadletterBindingList;
deadletterDataGridView.DataSource = deadletterBindingSource;
deadletterSplitContainer.SplitterDistance = deadletterSplitContainer.Width -
GrouperMessagePropertiesWith -
deadletterSplitContainer.SplitterWidth;
deadletterListTextPropertiesSplitContainer.SplitterDistance = deadletterListTextPropertiesSplitContainer.Size.Height / 2 - 8;
deadletterCustomPropertiesSplitContainer.SplitterDistance = deadletterCustomPropertiesSplitContainer.Size.Width / 2 - 8;
if (!peek)
{
if (OnRefresh != null)
{
OnRefresh();
}
}
if (mainTabControl.TabPages[DeadletterTabPage] == null)
{
EnablePage(DeadletterTabPage);
}
if (mainTabControl.TabPages[DeadletterTabPage] != null)
{
mainTabControl.SelectTab(DeadletterTabPage);
}
}
catch (TimeoutException)
{
writeToLog(string.Format(NoMessageReceivedFromTheDeadletterQueue,
MainForm.SingletonMainForm.ReceiveTimeout,
subscriptionWrapper.SubscriptionDescription.Name));
}
catch (Exception e)
{
HandleException(e);
}
}
private void GetMessages(bool peek, bool all, int count, IBrokeredMessageInspector messageInspector)
{
try
{
mainTabControl.SuspendDrawing();
mainTabControl.SuspendLayout();
tabPageMessages.SuspendDrawing();
tabPageMessages.SuspendLayout();
Cursor.Current = Cursors.WaitCursor;
var brokeredMessages = new List<BrokeredMessage>();
if (peek)
{
var subscriptionClient = serviceBusHelper.MessagingFactory.CreateSubscriptionClient(subscriptionWrapper.SubscriptionDescription.TopicPath,
subscriptionWrapper.SubscriptionDescription.Name,
ReceiveMode.PeekLock);
var totalRetrieved = 0;
while (totalRetrieved < count)
{
var messageEnumerable = subscriptionClient.PeekBatch(count);
if (messageEnumerable == null)
{
break;
}
var messageArray = messageEnumerable as BrokeredMessage[] ?? messageEnumerable.ToArray();
var partialList = messageInspector != null ?
messageArray.Select(b => messageInspector.AfterReceiveMessage(b, writeToLog)).ToList() :
new List<BrokeredMessage>(messageArray);
brokeredMessages.AddRange(partialList);
totalRetrieved += partialList.Count;
if (partialList.Count == 0)
{
break;
}
}
writeToLog(string.Format(MessagesPeekedFromTheSubscription, brokeredMessages.Count, subscriptionWrapper.SubscriptionDescription.Name));
}
else
{
MessageReceiver messageReceiver;
if (subscriptionWrapper.SubscriptionDescription.RequiresSession)
{
var subscriptionClient = serviceBusHelper.MessagingFactory.CreateSubscriptionClient(subscriptionWrapper.SubscriptionDescription.TopicPath,
subscriptionWrapper.SubscriptionDescription.Name,
ReceiveMode.ReceiveAndDelete);
messageReceiver = subscriptionClient.AcceptMessageSession(TimeSpan.FromSeconds(MainForm.SingletonMainForm.ReceiveTimeout));
}
else
{
messageReceiver = serviceBusHelper.MessagingFactory.CreateMessageReceiver(SubscriptionClient.FormatSubscriptionPath(
subscriptionWrapper.SubscriptionDescription.TopicPath,
subscriptionWrapper.SubscriptionDescription.Name),
ReceiveMode.ReceiveAndDelete);
}
var totalRetrieved = 0;
int retrieved;
do
{
var messages = messageReceiver.ReceiveBatch(all
? MainForm.SingletonMainForm.TopCount
: count - totalRetrieved,
TimeSpan.FromSeconds(MainForm.SingletonMainForm.ReceiveTimeout));
var enumerable = messages as BrokeredMessage[] ?? messages.ToArray();
retrieved = enumerable.Count();
if (retrieved == 0)
{
continue;
}
totalRetrieved += retrieved;
brokeredMessages.AddRange(messageInspector != null ? enumerable.Select(b => messageInspector.AfterReceiveMessage(b, writeToLog)) : enumerable);
} while (retrieved > 0 && (all || count > totalRetrieved));
writeToLog(string.Format(MessagesReceivedFromTheSubscription, brokeredMessages.Count, subscriptionWrapper.SubscriptionDescription.Name));
}
messageBindingList = new SortableBindingList<BrokeredMessage>(brokeredMessages)
{
AllowEdit = false,
AllowNew = false,
AllowRemove = false
};
messagesBindingSource.DataSource = messageBindingList;
messagesDataGridView.DataSource = messagesBindingSource;
messagesSplitContainer.SplitterDistance = messagesSplitContainer.Width -
GrouperMessagePropertiesWith -
messagesSplitContainer.SplitterWidth;
messageListTextPropertiesSplitContainer.SplitterDistance = messageListTextPropertiesSplitContainer.Size.Height / 2 - 8;
messagesCustomPropertiesSplitContainer.SplitterDistance = messagesCustomPropertiesSplitContainer.Size.Width / 2 - 8;
if (!peek)
{
if (OnRefresh != null)
{
OnRefresh();
}
}
if (mainTabControl.TabPages[MessagesTabPage] == null)
{
EnablePage(MessagesTabPage);
}
if (mainTabControl.TabPages[MessagesTabPage] != null)
{
mainTabControl.SelectTab(MessagesTabPage);
}
}
catch (TimeoutException)
{
writeToLog(string.Format(NoMessageReceivedFromTheSubscription,
MainForm.SingletonMainForm.ReceiveTimeout,
subscriptionWrapper.SubscriptionDescription.Name));
}
catch (NotSupportedException)
{
ReadMessagesOneAtTheTime(peek, all, count, messageInspector);
}
catch (Exception ex)
{
HandleException(ex);
}
finally
{
mainTabControl.ResumeLayout();
mainTabControl.ResumeDrawing();
tabPageMessages.ResumeLayout();
tabPageMessages.ResumeDrawing();
Cursor.Current = Cursors.Default;
}
}
private void GetDeadletterMessages(bool peek, bool all, int count, IBrokeredMessageInspector messageInspector)
{
try
{
mainTabControl.SuspendDrawing();
mainTabControl.SuspendLayout();
tabPageDeadletter.SuspendDrawing();
tabPageDeadletter.SuspendLayout();
Cursor.Current = Cursors.WaitCursor;
var brokeredMessages = new List<BrokeredMessage>();
if (peek)
{
var queueClient =
serviceBusHelper.MessagingFactory.CreateQueueClient(
QueueClient.FormatDeadLetterPath(queueDescription.Path), ReceiveMode.PeekLock);
var messageEnumerable = queueClient.PeekBatch(count);
if (messageEnumerable == null)
{
return;
}
var messageArray = messageEnumerable as BrokeredMessage[] ?? messageEnumerable.ToArray();
brokeredMessages = messageInspector != null ?
messageArray.Select(b => messageInspector.AfterReceiveMessage(b, writeToLog)).ToList() :
new List<BrokeredMessage>(messageArray);
writeToLog(string.Format(MessagesPeekedFromTheDeadletterQueue, brokeredMessages.Count,
queueDescription.Path));
}
else
{
var queueClient =
serviceBusHelper.MessagingFactory.CreateQueueClient(
QueueClient.FormatDeadLetterPath(queueDescription.Path), ReceiveMode.ReceiveAndDelete);
var totalRetrieved = 0;
int retrieved;
do
{
var messages = queueClient.ReceiveBatch(all
? MainForm.SingletonMainForm.TopCount
: count - totalRetrieved,
TimeSpan.FromSeconds(MainForm.SingletonMainForm.ReceiveTimeout));
var enumerable = messages as BrokeredMessage[] ?? messages.ToArray();
retrieved = enumerable.Count();
if (retrieved == 0)
{
continue;
}
totalRetrieved += retrieved;
brokeredMessages.AddRange(messageInspector != null ? enumerable.Select(b => messageInspector.AfterReceiveMessage(b, writeToLog)) : enumerable);
} while (retrieved > 0 && (all || count > totalRetrieved));
//if (!queueDescription.EnablePartitioning)
//{
// queueClient.CompleteBatch(brokeredMessages.Select(bm => bm.LockToken));
//}
//else
//{
// foreach (var partitionKey in brokeredMessages.Select(bm => bm.PartitionKey).Distinct())
// {
// var key = partitionKey;
// queueClient.CompleteBatch(
// brokeredMessages.Where(bm => bm.PartitionKey == key).Select(bm => bm.LockToken));
// }
//}
writeToLog(string.Format(MessagesReceivedFromTheDeadletterQueue, brokeredMessages.Count,
queueDescription.Path));
}
deadletterBindingList = new SortableBindingList<BrokeredMessage>(brokeredMessages)
{
AllowEdit = false,
AllowNew = false,
AllowRemove = false
};
deadletterBindingSource.DataSource = deadletterBindingList;
deadletterDataGridView.DataSource = deadletterBindingSource;
deadletterSplitContainer.SplitterDistance = deadletterSplitContainer.Width -
GrouperMessagePropertiesWith -
deadletterSplitContainer.SplitterWidth;
deadletterListTextPropertiesSplitContainer.SplitterDistance = deadletterListTextPropertiesSplitContainer.Size.Height / 2 - 8;
deadletterCustomPropertiesSplitContainer.SplitterDistance = deadletterCustomPropertiesSplitContainer.Size.Width / 2 - 8;
if (!peek)
{
if (OnRefresh != null)
{
OnRefresh();
}
}
if (mainTabControl.TabPages[DeadletterTabPage] == null)
{
EnablePage(DeadletterTabPage);
}
if (mainTabControl.TabPages[DeadletterTabPage] != null)
{
mainTabControl.SelectTab(DeadletterTabPage);
}
}
catch (TimeoutException)
{
writeToLog(string.Format(NoMessageReceivedFromTheDeadletterQueue,
MainForm.SingletonMainForm.ReceiveTimeout,
queueDescription.Path));
}
catch (NotSupportedException)
{
ReadDeadletterMessagesOneAtTheTime(peek, all, count, messageInspector);
}
catch (Exception ex)
{
HandleException(ex);
}
finally
{
mainTabControl.ResumeLayout();
mainTabControl.ResumeDrawing();
tabPageDeadletter.ResumeLayout();
tabPageDeadletter.ResumeDrawing();
Cursor.Current = Cursors.Default;
}
}
private async void btnStart_Click(object sender, EventArgs e)
{
try
{
if (btnStart.Text == StopCaption)
{
CancelActions();
btnStart.Text = StartCaption;
return;
}
if (serviceBusHelper != null &&
ValidateParameters())
{
btnStart.Enabled = false;
Cursor.Current = Cursors.WaitCursor;
//*****************************************************************************************************
// Retrieve Messaging Factory
//*****************************************************************************************************
var messagingFactory = serviceBusHelper.MessagingFactory;
//*****************************************************************************************************
// Initialize Statistics and Manager Action
//*****************************************************************************************************
actionCount = 0;
senderMessageNumber = 0;
senderMessagesPerSecond = 0;
senderMinimumTime = long.MaxValue;
senderMaximumTime = 0;
senderAverageTime = 0;
senderTotalTime = 0;
receiverMessageNumber = 0;
receiverMessagesPerSecond = 0;
receiverMinimumTime = long.MaxValue;
receiverMaximumTime = 0;
receiverAverageTime = 0;
receiverTotalTime = 0;
if (checkBoxSenderEnableGraph.Checked ||
checkBoxReceiverEnableGraph.Checked)
{
chart.Series.ToList().ForEach(s => s.Points.Clear());
}
managerResetEvent = new ManualResetEventSlim(false);
Action<CancellationTokenSource> managerAction = cts =>
{
if (cts == null)
{
return;
}
try
{
managerResetEvent.Wait(cts.Token);
}
catch (OperationCanceledException)
{
}
if (!cts.IsCancellationRequested)
{
Invoke((MethodInvoker)delegate { btnStart.Text = StartCaption; });
}
};
Action updateGraphAction = () =>
{
var ok = true;
long max = 10;
while (!graphCancellationTokenSource.IsCancellationRequested && (actionCount > 1 || ok))
{
ok = true;
long sendMessageNumber = 0;
long receiveMessageNumber = 0;
long sendTotalTime = 0;
long receiveTotalTime = 0;
while (ok && sendMessageNumber < max && receiveMessageNumber < max)
{
Tuple<long, long, DirectionType> tuple;
ok = blockingCollection.TryTake(out tuple, 10);
if (ok)
{
if (tuple.Item3 == DirectionType.Send)
{
sendMessageNumber += tuple.Item1;
sendTotalTime += tuple.Item2;
if (sendMessageNumber > max)
{
max = sendMessageNumber;
}
continue;
}
receiveMessageNumber += tuple.Item1;
receiveTotalTime += tuple.Item2;
if (receiveMessageNumber > max)
{
max = receiveMessageNumber;
}
}
}
if (sendMessageNumber > 0)
{
var sendTuple = new Tuple<long, long, DirectionType>(sendMessageNumber, sendTotalTime, DirectionType.Send);
if (InvokeRequired)
{
Invoke(new UpdateStatisticsDelegate(InternalUpdateStatistics),
new object[] { sendTuple.Item1,
sendTuple.Item2,
sendTuple.Item3 });
}
else
{
InternalUpdateStatistics(sendTuple.Item1,
sendTuple.Item2,
sendTuple.Item3);
}
}
if (receiveMessageNumber > 0)
{
var receiveTuple = new Tuple<long, long, DirectionType>(receiveMessageNumber, receiveTotalTime, DirectionType.Receive);
if (InvokeRequired)
{
Invoke(new UpdateStatisticsDelegate(InternalUpdateStatistics),
new object[] { receiveTuple.Item1,
receiveTuple.Item2,
receiveTuple.Item3 });
}
else
{
InternalUpdateStatistics(receiveTuple.Item1,
receiveTuple.Item2,
receiveTuple.Item3);
}
}
}
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
};
AsyncCallback updateGraphCallback = a =>
{
var action = a.AsyncState as Action;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
blockingCollection = new BlockingCollection<Tuple<long, long, DirectionType>>();
//*****************************************************************************************************
// Sending messages to a Topic
//*****************************************************************************************************
if (senderEnabledCheckBox.Checked && messageCount > 0)
{
// Create message senders. They are cached for later usage to improve performance.
if (isSenderFaulted ||
messageSenderCollection == null ||
messageSenderCollection.Count == 0 ||
messageSenderCollection.Count < senderTaskCount)
{
messageSenderCollection = new List<MessageSender>(senderTaskCount);
for (var i = 0; i < senderTaskCount; i++)
{
messageSenderCollection.Add(messagingFactory.CreateMessageSender(topic.Path));
}
isSenderFaulted = false;
}
// Get Body Type
BodyType bodyType;
if (!Enum.TryParse(cboBodyType.Text, true, out bodyType))
{
bodyType = BodyType.Stream;
}
bool isBinary = false;
// Create outbound message template list
var messageTemplateList = new List<BrokeredMessage>();
var messageTextList = new List<string>();
var partitionKey = checkBoxSenderUseTransaction.Checked ? Guid.NewGuid().ToString() : null;
if (messageTabControl.SelectedIndex == MessageTabPage)
{
messageTemplateList.Add(serviceBusHelper.CreateBrokeredMessageTemplate(txtMessageText.Text,
txtLabel.Text,
txtContentType.Text,
GetMessageId(),
txtSessionId.Text,
txtCorrelationId.Text,
partitionKey,
txtTo.Text,
txtReplyTo.Text,
txtReplyToSessionId.Text,
txtTimeToLive.Text,
txtScheduledEnqueueTimeUtc.Text,
checkBoxForcePersistence.Checked,
bindingSource.Cast<MessagePropertyInfo>()));
messageTextList.Add(txtMessageText.Text);
}
else if (messageTabControl.SelectedIndex == FilesTabPage)
{
var fileList = messageFileListView.Items.Cast<ListViewItem>()
.Where(i => i.Checked)
.Select(i => i.Text)
.ToList();
if (fileList.Count == 0)
{
writeToLog(NoMessageSelected);
return;
}
foreach (var fileName in fileList)
{
try
{
BrokeredMessage template;
if (radioButtonBinaryFile.Checked)
{
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
using (var binaryReader = new BinaryReader(fileStream))
{
var bytes = binaryReader.ReadBytes((int)fileStream.Length);
template = serviceBusHelper.CreateBrokeredMessageTemplate(new MemoryStream(bytes),
txtLabel.Text,
txtContentType.Text,
GetMessageId(),
txtSessionId.Text,
txtCorrelationId.Text,
partitionKey,
txtTo.Text,
txtReplyTo.Text,
txtReplyToSessionId.Text,
txtTimeToLive.Text,
txtScheduledEnqueueTimeUtc.Text,
checkBoxForcePersistence.Checked,
bindingSource.Cast<MessagePropertyInfo>());
messageTextList.Add(BitConverter.ToString(bytes).Replace('-', ' '));
bodyType = BodyType.Stream;
isBinary = true;
}
}
}
else
{
using (var streamReader = new StreamReader(fileName))
{
var text = await streamReader.ReadToEndAsync();
if (radioButtonTextFile.Checked)
{
template = serviceBusHelper.CreateBrokeredMessageTemplate(text,
txtLabel.Text,
txtContentType.Text,
GetMessageId(),
txtSessionId.Text,
txtCorrelationId.Text,
partitionKey,
txtTo.Text,
txtReplyTo.Text,
txtReplyToSessionId.Text,
txtTimeToLive.Text,
txtScheduledEnqueueTimeUtc.Text,
checkBoxForcePersistence.Checked,
bindingSource.Cast<MessagePropertyInfo>());
messageTextList.Add(text);
}
else if (radioButtonJsonTemplate.Checked)
{
try
{
var brokeredMessageTemplate = JsonSerializerHelper.Deserialize<BrokeredMessageTemplate>(text);
template = serviceBusHelper.CreateBrokeredMessageTemplate(brokeredMessageTemplate);
messageTextList.Add(brokeredMessageTemplate.Message);
}
catch (Exception)
{
writeToLog(string.Format(InvalidJsonTemplate, fileName));
template = serviceBusHelper.CreateBrokeredMessageTemplate(text,
txtLabel.Text,
txtContentType.Text,
GetMessageId(),
txtSessionId.Text,
txtCorrelationId.Text,
partitionKey,
txtTo.Text,
txtReplyTo.Text,
txtReplyToSessionId.Text,
txtTimeToLive.Text,
txtScheduledEnqueueTimeUtc.Text,
checkBoxForcePersistence.Checked,
bindingSource.Cast<MessagePropertyInfo>());
messageTextList.Add(text);
}
}
else // XML Template
{
try
{
var brokeredMessageTemplate = XmlSerializerHelper.Deserialize<BrokeredMessageTemplate>(text);
template = serviceBusHelper.CreateBrokeredMessageTemplate(brokeredMessageTemplate);
messageTextList.Add(brokeredMessageTemplate.Message);
}
catch (Exception)
{
writeToLog(string.Format(InvalidXmlTemplate, fileName));
template = serviceBusHelper.CreateBrokeredMessageTemplate(text,
txtLabel.Text,
txtContentType.Text,
GetMessageId(),
txtSessionId.Text,
txtCorrelationId.Text,
partitionKey,
txtTo.Text,
txtReplyTo.Text,
txtReplyToSessionId.Text,
txtTimeToLive.Text,
txtScheduledEnqueueTimeUtc.Text,
checkBoxForcePersistence.Checked,
bindingSource.Cast<MessagePropertyInfo>());
messageTextList.Add(text);
}
}
}
}
if (template != null)
{
messageTemplateList.Add(template);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
}
else // Brokered Message Generator Tab
{
try
{
brokeredMessageGenerator = brokeredMessageGeneratorPropertyGrid.SelectedObject as IBrokeredMessageGenerator;
if (brokeredMessageGenerator != null)
{
messageTemplateList = new List<BrokeredMessage>(brokeredMessageGenerator.GenerateBrokeredMessageCollection(txtMessageCount.IntegerValue, writeToLog));
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
try
{
senderCancellationTokenSource = new CancellationTokenSource();
currentIndex = 0;
senderBrokeredMessageInspector = cboSenderInspector.SelectedIndex > 0
? Activator.CreateInstance(serviceBusHelper.BrokeredMessageInspectors[cboSenderInspector.Text]) as IBrokeredMessageInspector
: null;
Func<long> getMessageNumber = () =>
{
lock (this)
{
return currentIndex++;
}
};
Action<int, IEnumerable<BrokeredMessage>, IEnumerable<String>> senderAction = (taskId, messageTemplateEnumerable, messageTextEnumerable) =>
{
try
{
string traceMessage;
bool ok;
if (checkBoxSenderUseTransaction.Checked)
{
using (var scope = new TransactionScope())
{
ok = serviceBusHelper.SendMessages(messageSenderCollection[taskId],
messageTemplateEnumerable,
getMessageNumber,
messageCount,
taskId,
checkBoxUpdateMessageId.Checked,
checkBoxAddMessageNumber.Checked,
checkBoxOneSessionPerTask.Checked,
checkBoxEnableSenderLogging.Checked,
checkBoxSenderVerboseLogging.Checked,
checkBoxSenderEnableStatistics.Checked,
checkBoxSendBatch.Checked,
isBinary,
senderBatchSize,
checkBoxSenderThinkTime.Checked,
senderThinkTime,
bodyType,
senderBrokeredMessageInspector,
UpdateStatistics,
senderCancellationTokenSource,
out traceMessage);
var builder = new StringBuilder(traceMessage);
if (checkBoxSenderCommitTransaction.Checked)
{
scope.Complete();
builder.AppendLine(TransactionCommitted);
}
else
{
builder.AppendLine(TransactionAborted);
}
traceMessage = builder.ToString();
}
}
else
{
ok = serviceBusHelper.SendMessages(messageSenderCollection[taskId],
messageTemplateEnumerable,
getMessageNumber,
messageCount,
taskId,
checkBoxUpdateMessageId.Checked,
checkBoxAddMessageNumber.Checked,
checkBoxOneSessionPerTask.Checked,
checkBoxEnableSenderLogging.Checked,
checkBoxSenderVerboseLogging.Checked,
checkBoxSenderEnableStatistics.Checked,
checkBoxSendBatch.Checked,
isBinary,
senderBatchSize,
checkBoxSenderThinkTime.Checked,
senderThinkTime,
bodyType,
senderBrokeredMessageInspector,
UpdateStatistics,
senderCancellationTokenSource,
out traceMessage);
}
if (!string.IsNullOrWhiteSpace(traceMessage))
{
writeToLog(traceMessage.Substring(0,
traceMessage.
Length - 1));
}
isSenderFaulted = !ok;
}
catch (Exception ex)
{
isSenderFaulted = true;
HandleException(ex);
}
};
// Define Sender AsyncCallback
AsyncCallback senderCallback = a =>
{
var action = a.AsyncState as Action<int, IEnumerable<BrokeredMessage>, IEnumerable<String>>;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
// Start Sender Actions
for (var i = 0; i < Math.Min(messageCount, senderTaskCount); i++)
{
senderAction.BeginInvoke(i, messageTemplateList, messageTextList, senderCallback, senderAction);
Interlocked.Increment(ref actionCount);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
//*****************************************************************************************************
// Receiving messages from a Subscription
//*****************************************************************************************************
if (receiverEnabledCheckBox.Checked)
{
var currentSubscription = subscriptionList.SingleOrDefault(s => s.Name == cboSubscriptions.Text);
if (currentSubscription == null)
{
throw new ArgumentException(NoSubscriptionSelected);
}
var currentReceiveMode = cboReceivedMode.Text == PeekLock ?
ReceiveMode.PeekLock :
ReceiveMode.ReceiveAndDelete;
var currentMoveToDeadLetterQueue = checkBoxMoveToDeadLetter.Checked;
var currentReadFromDeadLetterQueue = checkBoxReadFromDeadLetter.Checked;
try
{
receiverCancellationTokenSource = new CancellationTokenSource();
receiverBrokeredMessageInspector = cboReceiverInspector.SelectedIndex > 0
? Activator.CreateInstance(serviceBusHelper.BrokeredMessageInspectors[cboReceiverInspector.Text]) as IBrokeredMessageInspector
: null;
Action<int> receiverAction = taskId =>
{
var allSessionsAccepted = false;
while (!allSessionsAccepted)
{
try
{
MessageReceiver messageReceiver;
if (currentReadFromDeadLetterQueue)
{
messageReceiver =
messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(currentSubscription.TopicPath,
currentSubscription.Name),
currentReceiveMode);
}
else
{
if (currentSubscription.RequiresSession)
{
var subscriptionClient = messagingFactory.CreateSubscriptionClient(currentSubscription.TopicPath,
currentSubscription.Name,
currentReceiveMode);
messageReceiver = subscriptionClient.AcceptMessageSession(TimeSpan.FromSeconds(sessionTimeout));
}
else
{
messageReceiver = messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatSubscriptionPath(currentSubscription.TopicPath,
currentSubscription.Name),
currentReceiveMode);
}
}
messageReceiver.PrefetchCount = prefetchCount;
string traceMessage;
if (checkBoxReceiverUseTransaction.Checked)
{
using (var scope = new TransactionScope())
{
serviceBusHelper.ReceiveMessages(messageReceiver,
taskId,
receiveTimeout,
filter,
currentMoveToDeadLetterQueue,
checkBoxCompleteReceive.Checked,
checkBoxDeferMessage.Checked,
checkBoxEnableReceiverLogging.Checked,
checkBoxReceiverVerboseLogging.Checked,
checkBoxReceiverEnableStatistics.Checked,
checkBoxReceiveBatch.Checked,
receiverBatchSize,
checkBoxReceiverThinkTime.Checked,
receiverThinkTime,
receiverBrokeredMessageInspector,
UpdateStatistics,
receiverCancellationTokenSource,
out traceMessage);
var builder = new StringBuilder(traceMessage);
if (checkBoxReceiverCommitTransaction.Checked)
{
scope.Complete();
builder.AppendLine(TransactionCommitted);
}
else
{
builder.AppendLine(TransactionAborted);
}
traceMessage = builder.ToString();
}
}
else
{
serviceBusHelper.ReceiveMessages(messageReceiver,
taskId,
receiveTimeout,
filter,
currentMoveToDeadLetterQueue,
checkBoxCompleteReceive.Checked,
checkBoxDeferMessage.Checked,
checkBoxEnableReceiverLogging.Checked,
checkBoxReceiverVerboseLogging.Checked,
checkBoxReceiverEnableStatistics.Checked,
checkBoxReceiveBatch.Checked,
receiverBatchSize,
checkBoxReceiverThinkTime.Checked,
receiverThinkTime,
receiverBrokeredMessageInspector,
UpdateStatistics,
receiverCancellationTokenSource,
out traceMessage);
}
if (!string.IsNullOrWhiteSpace(traceMessage))
{
writeToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
allSessionsAccepted = !currentSubscription.RequiresSession;
}
catch (TimeoutException ex)
{
if (currentSubscription.RequiresSession)
{
writeToLog(string.Format(NoMoreSessionsToAccept, taskId));
allSessionsAccepted = true;
}
else
{
HandleException(ex);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
};
// Define Receiver AsyncCallback
AsyncCallback receiverCallback = a =>
{
var action = a.AsyncState as Action<int>;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
// Start Receiver Actions
for (var i = 0; i < receiverTaskCount; i++)
{
receiverAction.BeginInvoke(i, receiverCallback, receiverAction);
Interlocked.Increment(ref actionCount);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
if (actionCount > 0)
{
managerCancellationTokenSource = new CancellationTokenSource();
managerAction.BeginInvoke(managerCancellationTokenSource, null, null);
graphCancellationTokenSource = new CancellationTokenSource();
updateGraphAction.BeginInvoke(updateGraphCallback, updateGraphAction);
Interlocked.Increment(ref actionCount);
btnStart.Text = StopCaption;
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
finally
{
btnStart.Enabled = true;
Cursor.Current = Cursors.Default;
}
}
private void GetMessages(bool peek, bool all, int count, SubscriptionWrapper SW)
{
try
{
var brokeredMessages = new List <BrokeredMessage>();
if (peek)
{
var subscriptionClient = serviceBusHelper.MessagingFactory.CreateSubscriptionClient(SW.SubscriptionDescription.TopicPath,
SW.SubscriptionDescription.Name,
ReceiveMode.PeekLock);
var totalRetrieved = 0;
while (totalRetrieved < count)
{
var messageEnumerable = subscriptionClient.PeekBatch(count);
if (messageEnumerable == null)
{
break;
}
IBrokeredMessageInspector messageInspector = null;
var messageArray = messageEnumerable as BrokeredMessage[] ?? messageEnumerable.ToArray();
var partialList = new List <BrokeredMessage>(messageArray);
brokeredMessages.AddRange(partialList);
totalRetrieved += partialList.Count;
if (partialList.Count == 0)
{
break;
}
else
{
for (int iIndex = 0; iIndex < partialList.Count; iIndex++)
{
BrokeredMessage bMsg = partialList[iIndex];
int x = 0;
}
}
}
//writeToLog(string.Format(MessagesPeekedFromTheSubscription, brokeredMessages.Count, subscriptionWrapper.SubscriptionDescription.Name));
}
else
{
MessageReceiver messageReceiver;
if (SW.SubscriptionDescription.RequiresSession)
{
var subscriptionClient = serviceBusHelper.MessagingFactory.CreateSubscriptionClient(SW.SubscriptionDescription.TopicPath,
SW.SubscriptionDescription.Name,
ReceiveMode.ReceiveAndDelete);
//messageReceiver = subscriptionClient.AcceptMessageSession(TimeSpan.FromSeconds(MainForm.SingletonMainForm.ReceiveTimeout));
}
else
{
messageReceiver = serviceBusHelper.MessagingFactory.CreateMessageReceiver(SubscriptionClient.FormatSubscriptionPath(
SW.SubscriptionDescription.TopicPath,
SW.SubscriptionDescription.Name),
ReceiveMode.ReceiveAndDelete);
}
//writeToLog(string.Format(MessagesReceivedFromTheSubscription, brokeredMessages.Count, subscriptionWrapper.SubscriptionDescription.Name));
}
if (!peek)
{
/*if (OnRefresh != null)
* {
* OnRefresh();
* }*/
}
}
catch (TimeoutException)
{
/*writeToLog(string.Format(NoMessageReceivedFromTheSubscription,
* MainForm.SingletonMainForm.ReceiveTimeout,
* subscriptionWrapper.SubscriptionDescription.Name));*/
int x = 0;
}
}
private void ReadMessagesOneAtTheTime(bool peek, bool all, int count, IBrokeredMessageInspector messageInspector)
{
try
{
var brokeredMessages = new List<BrokeredMessage>();
if (peek)
{
var queueClient = serviceBusHelper.MessagingFactory.CreateQueueClient(queueDescription.Path,
ReceiveMode.PeekLock);
for (var i = 0; i < count; i++)
{
var message = queueClient.Peek();
if (message != null)
{
if (messageInspector != null)
{
message = messageInspector.AfterReceiveMessage(message);
}
brokeredMessages.Add(message);
}
}
writeToLog(string.Format(MessagesPeekedFromTheQueue, brokeredMessages.Count, queueDescription.Path));
}
else
{
MessageReceiver messageReceiver;
if (queueDescription.RequiresSession)
{
var queueClient = serviceBusHelper.MessagingFactory.CreateQueueClient(queueDescription.Path,
ReceiveMode.ReceiveAndDelete);
messageReceiver =
queueClient.AcceptMessageSession(
TimeSpan.FromSeconds(MainForm.SingletonMainForm.ServerTimeout));
}
else
{
messageReceiver = serviceBusHelper.MessagingFactory.CreateMessageReceiver(queueDescription.Path,
ReceiveMode.ReceiveAndDelete);
}
var totalRetrieved = 0;
int retrieved;
do
{
var message = messageReceiver.Receive();
retrieved = message != null ? 1 : 0;
if (retrieved == 0)
{
continue;
}
totalRetrieved += retrieved;
brokeredMessages.Add(messageInspector != null ? messageInspector.AfterReceiveMessage(message) : message);
} while (retrieved > 0 && (all || count > totalRetrieved));
writeToLog(string.Format(MessagesReceivedFromTheQueue, brokeredMessages.Count, queueDescription.Path));
}
messageBindingList = new SortableBindingList<BrokeredMessage>(brokeredMessages)
{
AllowEdit = false,
AllowNew = false,
AllowRemove = false
};
messagesBindingSource.DataSource = messageBindingList;
messagesDataGridView.DataSource = messagesBindingSource;
messagesSplitContainer.SplitterDistance = messagesSplitContainerSplitterDistance;
if (!peek)
{
if (OnRefresh != null)
{
OnRefresh();
}
}
if (mainTabControl.TabPages[MessagesTabPage] == null)
{
EnablePage(MessagesTabPage);
}
if (mainTabControl.TabPages[MessagesTabPage] != null)
{
mainTabControl.SelectTab(MessagesTabPage);
}
}
catch (Exception e)
{
HandleException(e);
}
}
private void GetMessages(bool peek, bool all, int count, IBrokeredMessageInspector messageInspector)
{
try
{
mainTabControl.SuspendDrawing();
mainTabControl.SuspendLayout();
tabPageMessages.SuspendDrawing();
tabPageMessages.SuspendLayout();
Cursor.Current = Cursors.WaitCursor;
var brokeredMessages = new List<BrokeredMessage>();
if (peek)
{
var queueClient = serviceBusHelper.MessagingFactory.CreateQueueClient(queueDescription.Path,
ReceiveMode.PeekLock);
var messageEnumerable = queueClient.PeekBatch(count);
if (messageEnumerable == null)
{
return;
}
var messageArray = messageEnumerable as BrokeredMessage[] ?? messageEnumerable.ToArray();
brokeredMessages = messageInspector != null ?
messageArray.Select(b => messageInspector.AfterReceiveMessage(b, writeToLog)).ToList() :
new List<BrokeredMessage>(messageArray);
writeToLog(string.Format(MessagesPeekedFromTheQueue, brokeredMessages.Count, queueDescription.Path));
}
else
{
MessageReceiver messageReceiver;
if (queueDescription.RequiresSession)
{
var queueClient = serviceBusHelper.MessagingFactory.CreateQueueClient(queueDescription.Path,
ReceiveMode.ReceiveAndDelete);
messageReceiver =
queueClient.AcceptMessageSession(
TimeSpan.FromSeconds(MainForm.SingletonMainForm.ServerTimeout));
}
else
{
messageReceiver = serviceBusHelper.MessagingFactory.CreateMessageReceiver(queueDescription.Path,
ReceiveMode.ReceiveAndDelete);
}
var totalRetrieved = 0;
int retrieved;
do
{
var messages = messageReceiver.ReceiveBatch(all
? MainForm.SingletonMainForm.TopCount
: count - totalRetrieved,
TimeSpan.FromSeconds(1));
var enumerable = messages as BrokeredMessage[] ?? messages.ToArray();
retrieved = enumerable.Count();
if (retrieved == 0)
{
continue;
}
totalRetrieved += retrieved;
brokeredMessages.AddRange(messageInspector != null ? enumerable.Select(b => messageInspector.AfterReceiveMessage(b, writeToLog)) : enumerable);
} while (retrieved > 0 && (all || count > totalRetrieved));
writeToLog(string.Format(MessagesReceivedFromTheQueue, brokeredMessages.Count, queueDescription.Path));
}
messageBindingList = new SortableBindingList<BrokeredMessage>(brokeredMessages)
{
AllowEdit = false,
AllowNew = false,
AllowRemove = false
};
messagesBindingSource.DataSource = messageBindingList;
messagesDataGridView.DataSource = messagesBindingSource;
messagesSplitContainer.SplitterDistance = messagesSplitContainerSplitterDistance;
if (!peek)
{
if (OnRefresh != null)
{
OnRefresh();
}
}
if (mainTabControl.TabPages[MessagesTabPage] == null)
{
EnablePage(MessagesTabPage);
}
if (mainTabControl.TabPages[MessagesTabPage] != null)
{
mainTabControl.SelectTab(MessagesTabPage);
}
}
catch (NotSupportedException)
{
ReadMessagesOneAtTheTime(peek, all, count, messageInspector);
}
catch (Exception ex)
{
HandleException(ex);
}
finally
{
mainTabControl.ResumeLayout();
mainTabControl.ResumeDrawing();
tabPageMessages.ResumeLayout();
tabPageMessages.ResumeDrawing();
Cursor.Current = Cursors.Default;
}
}
private async void btnStart_Click(object sender, EventArgs e)
{
if (string.Compare(btnStart.Text, Start, StringComparison.OrdinalIgnoreCase) == 0)
{
receiverBrokeredMessageInspector = cboReceiverInspector.SelectedIndex > 0
? Activator.CreateInstance(serviceBusHelper.BrokeredMessageInspectors[cboReceiverInspector.Text]) as IBrokeredMessageInspector
: null;
cancellationTokenSource = new CancellationTokenSource();
btnStart.Text = Stop;
blockingCollection = new BlockingCollection<Tuple<long, long, long>>();
timer = new System.Timers.Timer
{
AutoReset = true,
Enabled = true,
Interval = 1000 * txtRefreshInformation.IntegerValue
};
if (startLog != null && checkBoxLogging.Checked)
{
startLog();
}
timer.Elapsed += timer_Elapsed;
autoComplete = checkBoxAutoComplete.Checked;
logging = checkBoxLogging.Checked;
verbose = checkBoxVerbose.Checked;
tracking = checkBoxTrackMessages.Checked;
try
{
receiveMode = cboReceivedMode.SelectedIndex == 1 ? ReceiveMode.PeekLock : ReceiveMode.ReceiveAndDelete;
if (entityDescription is QueueDescription)
{
var currentQueue = entityDescription as QueueDescription;
queueClient = serviceBusHelper.MessagingFactory.CreateQueueClient(currentQueue.Path, receiveMode);
queueClient.PrefetchCount = txtPrefetchCount.IntegerValue;
if (currentQueue.RequiresSession)
{
await queueClient.RegisterSessionHandlerFactoryAsync(
new CustomMessageSessionAsyncHandlerFactory(new CustomMessageSessionAsyncHandlerConfiguration
{
Logging = logging,
Tracking = tracking,
AutoComplete = autoComplete,
MessageEncoder = encoder,
ReceiveMode = receiveMode,
GetElapsedTime = GetElapsedTime,
UpdateStatistics = UpdateStatistics,
WriteToLog = writeToLog,
MessageInspector = receiverBrokeredMessageInspector,
ServiceBusHelper = serviceBusHelper,
TrackMessage = bm => Invoke(new Action<BrokeredMessage>(m => messageCollection.Add(m)), bm)
}), GetSessionHandlerOptions());
}
else
{
#pragma warning disable 4014
Task.Run(() => queueClient.OnMessageAsync(OnMessageAsync, GetOnMessageOptions()));
#pragma warning restore 4014
}
}
if (entityDescription is SubscriptionDescription)
{
var currentSubscription = entityDescription as SubscriptionDescription;
subscriptionClient = serviceBusHelper.MessagingFactory.CreateSubscriptionClient(currentSubscription.TopicPath,
currentSubscription.Name,
receiveMode);
subscriptionClient.PrefetchCount = txtPrefetchCount.IntegerValue;
if (currentSubscription.RequiresSession)
{
await subscriptionClient.RegisterSessionHandlerFactoryAsync(
new CustomMessageSessionAsyncHandlerFactory(new CustomMessageSessionAsyncHandlerConfiguration
{
Logging = logging,
Tracking = tracking,
AutoComplete = autoComplete,
MessageEncoder = encoder,
ReceiveMode = receiveMode,
GetElapsedTime = GetElapsedTime,
UpdateStatistics = UpdateStatistics,
WriteToLog = writeToLog,
ServiceBusHelper = serviceBusHelper,
TrackMessage = bm => Invoke(new Action<BrokeredMessage>(m => messageCollection.Add(m)), bm)
}), GetSessionHandlerOptions());
}
else
{
#pragma warning disable 4014
Task.Run(() => subscriptionClient.OnMessageAsync(OnMessageAsync, GetOnMessageOptions()));
#pragma warning restore 4014
}
}
#pragma warning disable 4014
Task.Run(new Action(RefreshGraph));
#pragma warning restore 4014
GetElapsedTime();
}
catch (Exception ex)
{
HandleException(ex);
StopListener().Wait();
btnStart.Text = Start;
}
}
else
{
try
{
await StopListener();
btnStart.Text = Start;
}
catch (Exception ex)
{
HandleException(ex);
}
}
}
private void btnCreateDelete_Click(object sender, EventArgs e)
{
try
{
if (btnCreateDelete.Text == StopCaption)
{
CancelActions();
btnCreateDelete.Text = StartCaption;
return;
}
if (serviceBusHelper != null &&
ValidateParameters())
{
btnCreateDelete.Enabled = false;
Cursor.Current = Cursors.WaitCursor;
//*****************************************************************************************************
// Retrieve Messaging Factory
//*****************************************************************************************************
var messagingFactory = serviceBusHelper.MessagingFactory;
//*****************************************************************************************************
// Initialize Statistics and Manager Action
//*****************************************************************************************************
actionCount = 0;
receiverMessageNumber = 0;
receiverMessagesPerSecond = 0;
receiverMinimumTime = long.MaxValue;
receiverMaximumTime = 0;
receiverAverageTime = 0;
receiverTotalTime = 0;
if (checkBoxReceiverEnableGraph.Checked)
{
chart.Series.ToList().ForEach(s => s.Points.Clear());
}
managerResetEvent = new ManualResetEventSlim(false);
Action<CancellationTokenSource> managerAction = cts =>
{
if (cts == null)
{
return;
}
try
{
managerResetEvent.Wait(cts.Token);
}
catch (OperationCanceledException)
{
}
if (!cts.IsCancellationRequested)
{
Invoke((MethodInvoker)delegate { btnCreateDelete.Text = StartCaption; });
}
};
Action updateGraphAction = () =>
{
var ok = true;
long max = 10;
while (!graphCancellationTokenSource.IsCancellationRequested && (actionCount > 1 || ok))
{
ok = true;
long receiveMessageNumber = 0;
long receiveTotalTime = 0;
while (ok && receiveMessageNumber < max)
{
Tuple<long, long, DirectionType> tuple;
ok = blockingCollection.TryTake(out tuple, 10);
if (ok)
{
receiveMessageNumber += tuple.Item1;
receiveTotalTime += tuple.Item2;
if (receiveMessageNumber > max)
{
max = receiveMessageNumber;
}
}
}
if (receiveMessageNumber > 0)
{
var receiveTuple = new Tuple<long, long, DirectionType>(receiveMessageNumber, receiveTotalTime, DirectionType.Receive);
if (InvokeRequired)
{
Invoke(new UpdateStatisticsDelegate(InternalUpdateStatistics),
new object[] { receiveTuple.Item1,
receiveTuple.Item2,
receiveTuple.Item3 });
}
else
{
InternalUpdateStatistics(receiveTuple.Item1,
receiveTuple.Item2,
receiveTuple.Item3);
}
}
}
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
};
AsyncCallback updateGraphCallback = a =>
{
var action = a.AsyncState as Action;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
blockingCollection = new BlockingCollection<Tuple<long, long, DirectionType>>();
//*****************************************************************************************************
// Receiving messages from a Subscription
//*****************************************************************************************************
var currentSubscription = subscriptionWrapper.SubscriptionDescription;
if (currentSubscription == null)
{
throw new ArgumentException(NoSubscriptionSelected);
}
var currentReceiveMode = cboReceivedMode.Text == PeekLock ?
ReceiveMode.PeekLock :
ReceiveMode.ReceiveAndDelete;
var currentMoveToDeadLetterQueue = checkBoxMoveToDeadLetter.Checked;
var currentReadFromDeadLetterQueue = checkBoxReadFromDeadLetter.Checked;
try
{
receiverCancellationTokenSource = new CancellationTokenSource();
receiverCancellationTokenSource = new CancellationTokenSource();
receiverBrokeredMessageInspector = cboReceiverInspector.SelectedIndex > 0
? Activator.CreateInstance(serviceBusHelper.BrokeredMessageInspectors[cboReceiverInspector.Text]) as IBrokeredMessageInspector
: null;
Action<int> receiverAction = taskId =>
{
var allSessionsAccepted = false;
while (!allSessionsAccepted)
{
try
{
MessageReceiver messageReceiver;
if (currentReadFromDeadLetterQueue)
{
messageReceiver =
messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(currentSubscription.TopicPath,
currentSubscription.Name),
currentReceiveMode);
}
else
{
if (currentSubscription.RequiresSession)
{
var subscriptionClient = messagingFactory.CreateSubscriptionClient(currentSubscription.TopicPath,
currentSubscription.Name,
currentReceiveMode);
messageReceiver = subscriptionClient.AcceptMessageSession(TimeSpan.FromSeconds(sessionTimeout));
}
else
{
messageReceiver = messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatSubscriptionPath(currentSubscription.TopicPath,
currentSubscription.Name),
currentReceiveMode);
}
}
messageReceiver.PrefetchCount = prefetchCount;
string traceMessage;
if (checkBoxReceiverUseTransaction.Checked)
{
using (var scope = new TransactionScope())
{
serviceBusHelper.ReceiveMessages(messageReceiver,
taskId,
receiveTimeout,
filter,
currentMoveToDeadLetterQueue,
checkBoxCompleteReceive.Checked,
checkBoxDeferMessage.Checked,
checkBoxEnableReceiverLogging.Checked,
checkBoxReceiverVerboseLogging.Checked,
checkBoxReceiverEnableStatistics.Checked,
checkBoxReceiveBatch.Checked,
receiverBatchSize,
checkBoxReceiverThinkTime.Checked,
receiverThinkTime,
receiverBrokeredMessageInspector,
UpdateStatistics,
receiverCancellationTokenSource,
out traceMessage);
var builder = new StringBuilder(traceMessage);
if (checkBoxReceiverCommitTransaction.Checked)
{
scope.Complete();
builder.AppendLine(TransactionCommitted);
}
else
{
builder.AppendLine(TransactionAborted);
}
traceMessage = builder.ToString();
}
}
else
{
serviceBusHelper.ReceiveMessages(messageReceiver,
taskId,
receiveTimeout,
filter,
currentMoveToDeadLetterQueue,
checkBoxCompleteReceive.Checked,
checkBoxDeferMessage.Checked,
checkBoxEnableReceiverLogging.Checked,
checkBoxReceiverVerboseLogging.Checked,
checkBoxReceiverEnableStatistics.Checked,
checkBoxReceiveBatch.Checked,
receiverBatchSize,
checkBoxReceiverThinkTime.Checked,
receiverThinkTime,
receiverBrokeredMessageInspector,
UpdateStatistics,
receiverCancellationTokenSource,
out traceMessage);
}
if (!string.IsNullOrWhiteSpace(traceMessage))
{
writeToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
allSessionsAccepted = !currentSubscription.RequiresSession;
}
catch (TimeoutException ex)
{
if (currentSubscription.RequiresSession)
{
writeToLog(string.Format(NoMoreSessionsToAccept, taskId));
allSessionsAccepted = true;
}
else
{
HandleException(ex);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
};
// Define Receiver AsyncCallback
AsyncCallback receiverCallback = a =>
{
var action = a.AsyncState as Action<int>;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
// Start Receiver Actions
for (var i = 0; i < receiverTaskCount; i++)
{
receiverAction.BeginInvoke(i, receiverCallback, receiverAction);
Interlocked.Increment(ref actionCount);
}
}
catch (Exception ex)
{
HandleException(ex);
}
if (actionCount > 0)
{
managerCancellationTokenSource = new CancellationTokenSource();
managerAction.BeginInvoke(managerCancellationTokenSource, null, null);
graphCancellationTokenSource = new CancellationTokenSource();
updateGraphAction.BeginInvoke(updateGraphCallback, updateGraphAction);
Interlocked.Increment(ref actionCount);
btnCreateDelete.Text = StopCaption;
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
finally
{
btnCreateDelete.Enabled = true;
Cursor.Current = Cursors.Default;
}
}
