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 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 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");
}
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>
/// Initializes a new instance of the <see cref="ProducerMethodQueue" /> class.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public ProducerMethodQueue(IProducerQueue <MessageExpression> queue,
IExpressionSerializer serializer,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => queue, queue);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_queue = queue;
_serializer = serializer;
_compositeSerialization = compositeSerialization;
}
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);
}
});
}
}
private static async Task EnqueueLoopAsync(IProducerQueue<int> queue, CancellationToken token)
{
await Task.Yield();
int i = 0;
while (!token.IsCancellationRequested)
{
++i;
queue.Enqueue(i);
await Task.Delay(1);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ProducerMethodQueue" /> class.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public ProducerMethodQueue(IProducerQueue<MessageExpression> queue,
IExpressionSerializer serializer,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => queue, queue);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_queue = queue;
_serializer = serializer;
_compositeSerialization = compositeSerialization;
}
private static async Task EnqueueLoopAsync(IProducerQueue <int> queue, CancellationToken token)
{
await Task.Yield();
int i = 0;
while (!token.IsCancellationRequested)
{
++i;
queue.Enqueue(i);
await Task.Delay(1);
}
}
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;
}
private async Task RunProducerAsync <TMessage>(
IProducerQueue
<TMessage> queue,
string queueName,
long messageCount,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <string, string, QueueProducerConfiguration, long, ICreationScope> verify, bool sendViaBatch,
ICreationScope scope)
where TMessage : class
{
await RunProducerInternalAsync(queue, messageCount, generateData, sendViaBatch).ConfigureAwait(false);
LoggerShared.CheckForErrors(queueName);
verify(queueName, queue.Configuration.TransportConfiguration.ConnectionInfo.ConnectionString, queue.Configuration, messageCount, scope);
}
private void RunProducer <TMessage>(
IProducerQueue
<TMessage> queue,
QueueConnection queueConnection,
long messageCount,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <QueueConnection, QueueProducerConfiguration, long, ICreationScope> verify,
bool sendViaBatch,
ICreationScope scope)
where TMessage : class
{
RunProducerInternal(queue, messageCount, generateData, sendViaBatch);
LoggerShared.CheckForErrors(queueConnection.Queue);
verify(queueConnection, queue.Configuration, messageCount, scope);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageProcessingRpcSend{TSendMessage}" /> class.
/// </summary>
/// <param name="sendQueue">The send queue.</param>
/// <param name="rpcTimeoutFactory">The RPC timeout factory.</param>
/// <param name="headers">The headers.</param>
/// <param name="connectionInformation">The connection information.</param>
public MessageProcessingRpcSend(
IProducerQueue <TSendMessage> sendQueue,
IRpcTimeoutFactory rpcTimeoutFactory,
IHeaders headers,
IConnectionInformation connectionInformation)
{
Guard.NotNull(() => sendQueue, sendQueue);
Guard.NotNull(() => rpcTimeoutFactory, rpcTimeoutFactory);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => connectionInformation, connectionInformation);
_sendQueue = sendQueue;
_rpcTimeoutFactory = rpcTimeoutFactory;
_headers = headers;
_connectionInformation = connectionInformation;
}
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);
}
}
}
}
/// <inheritdoc />
public SynchronizedProducerQueue(ThreadQueueMode mode, [NotNull] ProducerConsumerQueueOptions <T> options, CancellationToken token = default(CancellationToken))
{
_queue = ProducerConsumerQueue.Create(mode, options, token);
_producerQueue = _queue as IProducerQueue <TQueue, T> ?? throw new NotSupportedException();
}
public static void RunLoop(IProducerQueue<SimpleMessage> queue, Func<IAdditionalMessageData> expiredDataInstant, Func<IAdditionalMessageData> expiredDataFuture,
Func<int, IAdditionalMessageData> delayProcessing)
{
var keepRunning = true;
while (keepRunning)
{
Console.WriteLine(@"To test heartbeat recovery, force kill your consumer after starting to process record(s)
To test rollbacks, cancel the consumer by pressing any button. Easier to test with longer running jobs.
Sync
a) Send 10 jobs
b) Send 500 jobs
c) Send 1000 jobs
d) Send 1 job with 20 second processing time
e) Send 1 job with 60 second processing time
f) Send 100 random jobs
g) Test error
h) Test retry-able error and finish after some retries
i) Test retry-able error and fail after some retries
j) Test expire
Async
k) Send 10 jobs
l) Send 500 jobs
m) Send 1000 jobs
n) Send 1 job with 20 second processing time
o) Send 1 job with 60 second processing time
p) Send 100 random jobs
r) Test error
s) Test retry-able error and finish after some retries
t) Test retry-able error and fail after some retries
u) Test expire
Batch
v) Send 100 random jobs
w) Send 1000 random jobs
x) Send Async 100 random jobs
y) Send Async 1000 random jobs
Long Running
z) Send 1 job with a 600 second processing time
Delayed Processing
1) Send 1 job with a 10 second processing delay
2) Send 10 jobs with a 30 second processing delay
q) Quit");
var key = char.ToLower(Console.ReadKey(true).KeyChar);
switch (key)
{
case 'a':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(10, 500, 1000), expiredDataFuture),
Log.Logger);
break;
case 'b':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(100, 500, 500), expiredDataFuture),
Log.Logger);
break;
case 'c':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(1000, 100, 50), expiredDataFuture),
Log.Logger);
break;
case 'd':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(1, 20000, 100000), expiredDataFuture),
Log.Logger);
break;
case 'e':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(1, 60000, 10), expiredDataFuture),
Log.Logger);
break;
case 'f':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessageRandom(100), expiredDataFuture),
Log.Logger);
break;
case 'g':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessageError(1000, 0), expiredDataFuture), Log.Logger);
break;
case 'h':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessageRetryError(1000, false), expiredDataFuture), Log.Logger);
break;
case 'i':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessageRetryError(1000, true), expiredDataFuture), Log.Logger);
break;
case 'j':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleExpiredMessage(), expiredDataInstant.Invoke()), Log.Logger);
break;
case 'z':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(1, 600000, 10), expiredDataFuture),
Log.Logger);
break;
//async
case 'k':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessage(10, 500, 1000), expiredDataFuture).Result,
Log.Logger);
break;
case 'l':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessage(100, 500, 500), expiredDataFuture).Result,
Log.Logger);
break;
case 'm':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessage(1000, 100, 50), expiredDataFuture).Result,
Log.Logger);
break;
case 'n':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessage(1, 20000, 100000), expiredDataFuture).Result,
Log.Logger);
break;
case 'o':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessage(1, 60000, 10), expiredDataFuture).Result,
Log.Logger);
break;
case 'p':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessageRandom(100), expiredDataFuture).Result,
Log.Logger);
break;
case 'r':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessageError(1000, 0), expiredDataFuture).Result, Log.Logger);
break;
case 's':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessageRetryError(1000, false), expiredDataFuture).Result, Log.Logger);
break;
case 't':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleMessageRetryError(1000, true), expiredDataFuture).Result, Log.Logger);
break;
case 'u':
HandleResults.Handle(RunProducer.RunAsync(queue, Messages.CreateSimpleExpiredMessage(), expiredDataInstant.Invoke()).Result, Log.Logger);
break;
//batch
case 'v':
HandleResults.Handle(RunProducer.RunBatch(queue, Messages.CreateSimpleMessageRandomList(100), expiredDataFuture),
Log.Logger);
break;
case 'w':
HandleResults.Handle(RunProducer.RunBatch(queue, Messages.CreateSimpleMessageRandomList(1000), expiredDataFuture),
Log.Logger);
break;
case 'x':
HandleResults.Handle(RunProducer.RunBatchAsync(queue, Messages.CreateSimpleMessageRandomList(100), expiredDataFuture).Result,
Log.Logger);
break;
case 'y':
HandleResults.Handle(RunProducer.RunBatchAsync(queue, Messages.CreateSimpleMessageRandomList(1000), expiredDataFuture).Result,
Log.Logger);
break;
case '1':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(1, 500, 1000), () => delayProcessing(10)),
Log.Logger);
break;
case '2':
HandleResults.Handle(RunProducer.Run(queue, Messages.CreateSimpleMessage(10, 500, 1000), () => delayProcessing(30)),
Log.Logger);
break;
case 'q':
Console.WriteLine("Quitting");
keepRunning = false;
break;
}
}
}
