private void RunProducerInternal <TMessage>(
IProducerQueue
<TMessage> queue, long messageCount, Func <QueueProducerConfiguration, AdditionalMessageData> generateData, bool sendViaBatch)
where TMessage : class
{
var numberOfJobs = Convert.ToInt32(messageCount);
var jobs = Enumerable.Range(0, numberOfJobs)
.Select(i => GenerateMessage.Create <TMessage>());
if (sendViaBatch)
{
var messages = new List <QueueMessage <TMessage, IAdditionalMessageData> >(numberOfJobs);
messages.AddRange(from job in jobs let data = generateData(queue.Configuration) select data != null ? new QueueMessage <TMessage, IAdditionalMessageData>(job, data) : new QueueMessage <TMessage, IAdditionalMessageData>(job, null));
var result = queue.Send(messages);
var errorList = result.Where(p => result.Any(l => p.SendingException != null))
.ToList();
if (result.HasErrors)
{
Assert.False(result.HasErrors, errorList[0].SendingException.ToString());
}
else
{
Assert.False(result.HasErrors);
}
}
else
{
Parallel.ForEach(jobs, job =>
{
var data = generateData(queue.Configuration);
if (data != null)
{
var result = queue.Send(job, data);
var message = string.Empty;
if (result.SendingException != null)
{
message = result.SendingException.ToString();
}
Assert.False(result.HasError, message);
}
else
{
var result = queue.Send(job);
var message = string.Empty;
if (result.SendingException != null)
{
message = result.SendingException.ToString();
}
Assert.False(result.HasError, message);
}
});
}
}
public static IEnumerable <IQueueOutputMessage> Run(IProducerQueue <SimpleMessage> queue, SimpleMessage message, IAdditionalMessageData data)
{
Log.Logger.Information("Sending...");
yield return(queue.Send(message, data));
Log.Logger.Information("Done");
}
public static IEnumerable<IQueueOutputMessage> Run(IProducerQueue<SimpleMessage> queue, IEnumerable<SimpleMessage> messages, Func<IAdditionalMessageData> expiredDataFuture)
{
Log.Logger.Information("Sending...");
foreach (var message in messages)
{
yield return queue.Send(message, expiredDataFuture.Invoke());
}
Log.Logger.Information("Done");
}
/// <summary>
/// Handles the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="data">The additional message data.</param>
/// <param name="timeOut">The time out.</param>
/// <returns></returns>
public ISentMessage Handle(TSendMessage message, IAdditionalMessageData data, TimeSpan timeOut)
{
//store the destination queue as a header
data.SetHeader(_headers.StandardHeaders.RpcConnectionInfo, _connectionInformation.Clone());
//store the timeout as a header
data.SetHeader(_headers.StandardHeaders.RpcTimeout, _rpcTimeoutFactory.Create(timeOut));
//send the request
return(_sendQueue.Send(message, data).SentMessage);
}
public static List<IQueueOutputMessage> RunBatch(IProducerQueue<SimpleMessage> queue,
List<SimpleMessage> messages, Func<IAdditionalMessageData> expiredDataFuture)
{
var messagesWithData = new List<QueueMessage<SimpleMessage, IAdditionalMessageData>>(messages.Count);
foreach (var message in messages)
{
messagesWithData.Add(new QueueMessage<SimpleMessage, IAdditionalMessageData>(message, expiredDataFuture.Invoke()));
}
var data = new List<IQueueOutputMessage>();
Log.Logger.Information("Sending...");
data.AddRange(queue.Send(messagesWithData));
Log.Logger.Information("Done");
return data;
}
/// <inheritdoc />
public IQueueOutputMessages Send(List <QueueMessage <Expression <Action <IReceivedMessage <MessageExpression>, IWorkerNotification> >, IAdditionalMessageData> > methods, bool rawExpression = false)
{
var messages = new List <QueueMessage <MessageExpression, IAdditionalMessageData> >(methods.Count);
foreach (var method in methods)
{
if (rawExpression)
{
var message = new MessageExpression(MessageExpressionPayloads.ActionRaw, method.Message);
messages.Add(new QueueMessage <MessageExpression, IAdditionalMessageData>(message, method.MessageData));
}
else
{
var message = new MessageExpression(MessageExpressionPayloads.Action, _serializer.ConvertMethodToBytes(method.Message));
messages.Add(new QueueMessage <MessageExpression, IAdditionalMessageData>(message, method.MessageData));
}
}
return(_queue.Send(messages));
}