private static async Task RunTest(SendOptions sendOptions, ReceiveOptions receiveOptions, TableControl tableControl)
{
var result = await PerformanceTest.RunTest(sendOptions, receiveOptions);
var text = $"send msgs at {sendOptions.MessageSizeKilobytes} kilobytes in size";
if (result == null)
{
Console.WriteLine($"Test failed: {text}");
}
var messagesSentPerSecond = result.MessageSentTimes.MessagesSentCounter.Value / result.MessageSentTimes.MessageSentTimePerTimePeriod.TotalSeconds;
var messagesReceivedPerSecond = result.MessageReceivedTimes.MessagesReceivedCounter.Value / result.MessageReceivedTimes.MessageRecievedTimePerTimePeriod.Elapsed.TotalSeconds;
tableControl.AddRow(new List <TableCellControl>()
{
new TableCellControl(text),
new TableCellControl($"{sendOptions.MaxDegreeOfParallelism}"),
new TableCellControl($"{messagesSentPerSecond}"),
new TableCellControl($"{receiveOptions.RebusNumberOfWorkers}"),
new TableCellControl($"{receiveOptions.RebusMaxParallelism}"),
new TableCellControl($"{messagesReceivedPerSecond}"),
});
}
public static async Task <PerformanceTestResult> RunTest(SendOptions sendOptions, ReceiveOptions receiveOptions)
{
try
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var performanceTest = new PerformanceTest();
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
var receiver = await performanceTest.Receive(receiveOptions, cancellationTokenSource.Token);
using (receiver.Worker)
{
var send = await performanceTest.Send(sendOptions, cancellationTokenSource);
stopwatch.Stop();
receiver.MessageRecievedTimePerTimePeriod.Stop();
try
{
performanceTest.PurgeQueue();
}
catch (Exception e)
{
Logger.Logger.Error(e, "Error purging queue of extra records");
}
return(new PerformanceTestResult {
MessageReceivedTimes = receiver, MessageSentTimes = send, TotalTestTimeMilliseconds = stopwatch.ElapsedMilliseconds
});
}
}
}
catch (Exception exception)
{
Logger.Logger.Error(exception, "Error running test");
}
return(null);
}
private async Task <ReceiveResult> Receive(ReceiveOptions receiveOptions, CancellationToken cancellationToken)
{
Stopwatch sw = new Stopwatch();
Counter MessagesReceivedCounter = new Counter();
var workerBuiltinHandlerActivator = new BuiltinHandlerActivator();
try
{
workerBuiltinHandlerActivator.Handle <PerformanceTestMessage>(message =>
{
try
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.CompletedTask);
}
if (Interlocked.Exchange(ref receivedMessage, 1) == 0)
{
sw.Start();
}
var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
var milliseconds = now > message.UnixTimeMilliseconds ? now - message.UnixTimeMilliseconds : message.UnixTimeMilliseconds - now;
if (milliseconds <= 0)
{
throw new Exception($"Time not correct {nameof(milliseconds)}:{milliseconds}");
}
}
catch (Exception error)
{
Logger.Logger.Error(error, "Error in PerformanceTestMessage handler");
}
finally
{
MessagesReceivedCounter.Increment();
}
return(Task.CompletedTask);
});
var worker = Configure
.With(workerBuiltinHandlerActivator)
.Logging(configurer => configurer.Serilog(Logger.Logger))
.Transport(t =>
{
// set the worker queue name
t.UseAmazonSnsAndSqs(workerQueueAddress: QueueName);
}).Routing(r =>
{
// Map the message type to the queue
r.TypeBased().Map <PerformanceTestMessage>(QueueName);
}).Options(configurer =>
{
configurer.SetMaxParallelism(receiveOptions.RebusMaxParallelism);
configurer.SetNumberOfWorkers(receiveOptions.RebusNumberOfWorkers);
}).Start();
await worker.Subscribe <PerformanceTestMessage>();
}
catch (Exception error)
{
Logger.Logger.Error(error, "Error starting up worker");
}
var result = await Task.FromResult(new ReceiveResult { Worker = workerBuiltinHandlerActivator, MessageRecievedTimePerTimePeriod = sw, MessagesReceivedCounter = MessagesReceivedCounter, ReceiveOptions = receiveOptions });
return(result);
}