public static async Task<List<IQueueOutputMessage>> RunAsync(IProducerQueue<SimpleMessage> queue, SimpleMessage message, IAdditionalMessageData data)
{
var returnData = new List<IQueueOutputMessage>();
Log.Logger.Information("Sending...");
returnData.Add(await queue.SendAsync(message, data));
Log.Logger.Information("Done");
return returnData;
}
public static async Task<List<IQueueOutputMessage>> RunAsync(IProducerQueue<SimpleMessage> queue, IEnumerable<SimpleMessage> messages, Func<IAdditionalMessageData> expiredDataFuture)
{
var data = new List<IQueueOutputMessage>();
Log.Logger.Information("Sending...");
foreach (var message in messages)
{
data.Add(await queue.SendAsync(message, expiredDataFuture.Invoke()));
}
Log.Logger.Information("Done");
return data;
}
/// <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 async Task <ISentMessage> HandleAsync(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
var result = await _sendQueue.SendAsync(message, data).ConfigureAwait(false);
return(result.SentMessage);
}
private async Task RunProducerInternalAsync <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 results = await queue.SendAsync(messages).ConfigureAwait(false);
Assert.False(results.HasErrors);
}
else
{
foreach (var job in jobs)
{
var data = generateData(queue.Configuration);
if (data != null)
{
var result = await queue.SendAsync(job, data).ConfigureAwait(false);
Assert.False(result.HasError);
}
else
{
var result = await queue.SendAsync(job).ConfigureAwait(false);
Assert.False(result.HasError);
}
}
}
}
public static async Task<List<IQueueOutputMessage>> RunBatchAsync(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(await queue.SendAsync(messagesWithData));
Log.Logger.Information("Done");
return data;
}
/// <inheritdoc />
public async Task <IQueueOutputMessages> SendAsync(List <QueueMessage <Expression <Action <IReceivedMessage <MessageExpression>, IWorkerNotification> >, IAdditionalMessageData> > methods, bool rawExpression = false)
{
var messages = new List <QueueMessage <MessageExpression, IAdditionalMessageData> >(methods.Count);
if (rawExpression)
{
messages.AddRange(from method in methods let message = new MessageExpression(MessageExpressionPayloads.ActionRaw, method.Message) select new QueueMessage <MessageExpression, IAdditionalMessageData>(message, method.MessageData));
}
else
{
messages.AddRange(from method in methods let message = new MessageExpression(MessageExpressionPayloads.Action, _serializer.ConvertMethodToBytes(method.Message)) select new QueueMessage <MessageExpression, IAdditionalMessageData>(message, method.MessageData));
}
return(await _queue.SendAsync(messages).ConfigureAwait(false));
}
