private async Task BasicPubSub(int concurrency, int subscribers)
{
// arrange
var pingConsumer = new PingConsumer();
MessageBusBuilder
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f == typeof(PingConsumer))
{
return(pingConsumer);
}
throw new InvalidOperationException();
}));
var messageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var producedMessages = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new PingMessage {
Counter = i, Value = Guid.NewGuid()
})
.ToList();
var messageTasks = producedMessages.Select(m => messageBus.Publish(m));
// wait until all messages are sent
await Task.WhenAll(messageTasks).ConfigureAwait(false);
stopwatch.Stop();
Log.InfoFormat(CultureInfo.InvariantCulture, "Published {0} messages in {1}", producedMessages.Count, stopwatch.Elapsed);
// consume
stopwatch.Restart();
var consumersReceivedMessages = await ConsumeAll(pingConsumer, subscribers *producedMessages.Count);
stopwatch.Stop();
Log.InfoFormat(CultureInfo.InvariantCulture, "Consumed {0} messages in {1}", consumersReceivedMessages.Count, stopwatch.Elapsed);
// assert
// ensure number of instances of consumers created matches
consumersReceivedMessages.Count.Should().Be(subscribers * producedMessages.Count);
// ensure all messages arrived
// ... the count should match
consumersReceivedMessages.Count.Should().Be(subscribers * producedMessages.Count);
// ... the content should match
foreach (var producedMessage in producedMessages)
{
var messageCopies = consumersReceivedMessages.Count(x => x.Counter == producedMessage.Counter && x.Value == producedMessage.Value);
messageCopies.Should().Be(subscribers);
}
}
private async Task BasicPubSub(int concurrency, int subscribers, int expectedMessageCopies)
{
// arrange
var consumersCreated = new ConcurrentBag <PingConsumer>();
var consumedMessages = new List <(PingMessage Message, string MessageId)>();
MessageBusBuilder
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f != typeof(PingConsumer))
{
throw new InvalidOperationException();
}
var pingConsumer = new PingConsumer(_loggerFactory.CreateLogger <PingConsumer>(), consumedMessages);
consumersCreated.Add(pingConsumer);
return(pingConsumer);
}));
var messageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var producedMessages = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new PingMessage {
Counter = i, Value = Guid.NewGuid()
})
.ToList();
var messageTasks = producedMessages.Select(m => messageBus.Publish(m));
// wait until all messages are sent
await Task.WhenAll(messageTasks).ConfigureAwait(false);
stopwatch.Stop();
_logger.LogInformation("Published {0} messages in {1}", producedMessages.Count, stopwatch.Elapsed);
// consume
stopwatch.Restart();
await WaitUntilArriving(consumedMessages);
stopwatch.Stop();
// assert
// ensure number of instances of consumers created matches
consumersCreated.Count.Should().Be(producedMessages.Count * expectedMessageCopies);
consumedMessages.Count.Should().Be(producedMessages.Count * expectedMessageCopies);
// ... the content should match
foreach (var producedMessage in producedMessages)
{
var messageCopies = consumedMessages.Count(x => x.Message.Counter == producedMessage.Counter && x.Message.Value == producedMessage.Value && x.MessageId == GetMessageId(x.Message));
messageCopies.Should().Be(expectedMessageCopies);
}
}
private async Task BasicReqResp()
{
// arrange
var consumersCreated = new ConcurrentBag <EchoRequestHandler>();
MessageBusBuilder
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f != typeof(EchoRequestHandler))
{
throw new InvalidOperationException();
}
var consumer = new EchoRequestHandler();
consumersCreated.Add(consumer);
return(consumer);
}));
var messageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var requests = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new EchoRequest {
Index = i, Message = $"Echo {i}"
})
.ToList();
var responses = new List <Tuple <EchoRequest, EchoResponse> >();
var responseTasks = requests.Select(async req =>
{
var resp = await messageBus.Send(req).ConfigureAwait(false);
lock (responses)
{
responses.Add(Tuple.Create(req, resp));
}
});
await Task.WhenAll(responseTasks).ConfigureAwait(false);
stopwatch.Stop();
Log.InfoFormat(CultureInfo.InvariantCulture, "Published and received {0} messages in {1}", responses.Count, stopwatch.Elapsed);
// assert
// all messages got back
responses.Count.Should().Be(NumberOfMessages);
responses.All(x => x.Item1.Message == x.Item2.Message).Should().BeTrue();
}
public static MessageBusBuilder WithDependencyResolverAsServiceLocator(this MessageBusBuilder builder)
{
return(builder.WithDependencyResolver(new ServiceLocatorMessageBusDependencyResolver()));
}
public static MessageBusBuilder WithDependencyResolverAsUnity(this MessageBusBuilder builder)
{
return(builder.WithDependencyResolver(new UnityMessageBusDependencyResolver()));
}
public static MessageBusBuilder WithDependencyResolverAsAutofac(this MessageBusBuilder builder)
{
return(builder.WithDependencyResolver(new AutofacMessageBusDependencyResolver()));
}
