public void BasicReqResp()
{
// arrange
// ensure the topic has 2 partitions
var topic = $"test-echo";
var echoRequestHandler = new EchoRequestHandler();
MessageBusBuilder
.Publish <EchoRequest>(x =>
{
x.DefaultTopic(topic);
})
.Handle <EchoRequest, EchoResponse>(x => x.Topic(topic)
.Group("handler") // ensure consumer group exists on the event hub
.WithHandler <EchoRequestHandler>()
.Instances(2))
.ExpectRequestResponses(x =>
{
x.ReplyToTopic("test-echo-resp");
x.Group("response-reader"); // ensure consumer group exists on the event hub
x.DefaultTimeout(TimeSpan.FromSeconds(30));
})
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f == typeof(EchoRequestHandler))
{
return(echoRequestHandler);
}
throw new InvalidOperationException();
}));
var kafkaMessageBus = MessageBus.Value;
// act
var requests = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new EchoRequest {
Index = i, Message = $"Echo {i}"
})
.ToList();
var responses = new List <Tuple <EchoRequest, EchoResponse> >();
requests.AsParallel().ForAll(req =>
{
var resp = kafkaMessageBus.Send(req).Result;
lock (responses)
{
responses.Add(Tuple.Create(req, resp));
}
});
// assert
// all messages got back
responses.Count.Should().Be(NumberOfMessages);
responses.All(x => x.Item1.Message == x.Item2.Message).Should().BeTrue();
}
public void BasicPubSub()
{
// arrange
var topic = $"test-ping";
var pingConsumer = new PingConsumer();
MessageBusBuilder
.Publish <PingMessage>(x =>
{
x.DefaultTopic(topic);
})
.SubscribeTo <PingMessage>(x => x.Topic(topic)
.Group("subscriber") // ensure consumer group exists on the event hub
.WithSubscriber <PingConsumer>()
.Instances(2))
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f == typeof(PingConsumer))
{
return(pingConsumer);
}
throw new InvalidOperationException();
}));
var kafkaMessageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var messages = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new PingMessage {
Counter = i, Timestamp = DateTime.UtcNow
})
.ToList();
messages
.AsParallel()
.ForAll(m => kafkaMessageBus.Publish(m).Wait());
stopwatch.Stop();
Log.InfoFormat("Published {0} messages in {1}", messages.Count, stopwatch.Elapsed);
// consume
stopwatch.Restart();
var messagesReceived = ConsumeFromTopic(pingConsumer);
stopwatch.Stop();
Log.InfoFormat("Consumed {0} messages in {1}", messagesReceived.Count, stopwatch.Elapsed);
// assert
// all messages got back
messagesReceived.Count.Should().Be(messages.Count);
}
static void Main(string[] args)
{
Console.WriteLine("Setting up MessageBus");
var messageBus = new MessageBusBuilder().UseLogger(new DelegateLogger(Console.WriteLine)).Build();
var t1 = messageBus.InitializeRabbitMq("host=vboxguest.asinetwork.local;username=guest;password=guest");
// Messages from local, with topic "send" are sent to rabbit
var t2 = messageBus.Subscribe <MyTestPayload>(b => b
.WithTopic("send")
.ForwardToRabbitMq(r => r.UseDefaultQueue())
.OnWorker()
);
messageBus.Subscribe <MyTestPayload>(b => b
.WithTopic("send")
.Invoke(s => Console.WriteLine("Sending: " + s.Text)));
// Subscript to "send" topic on rabbit, and forward those messages locally on the "received" topic
var t3 = messageBus.PullRabbitMqToLocal <MyTestPayload>(r => r
.ForAllRemoteTopics()
.ReceiveDefaultFormat()
.ForwardToLocalTopic("received")
.UseSharedQueueName()
.AutoExpireQueue());
// Messages from rabbit, with topic "received" get printed on the console
var t4 = messageBus.Subscribe <MyTestPayload>(b => b
.WithTopic("received")
.InvokeEnvelope(m =>
{
Console.WriteLine("Received: " + m.Payload.Text);
}));
//Console.WriteLine("Sending message (should print 'whatever' if successful)");
for (int i = 0; i < 100; i++)
{
messageBus.Publish("send", new MyTestPayload
{
Text = "test message " + i
});
Thread.Sleep(1000);
}
Console.WriteLine("Press any key to continue");
Console.ReadKey();
messageBus.Dispose();
Environment.Exit(0);
}
public void BasicPubSub()
{
// arrange
// ensure the topic has 2 partitions
var topic = $"test-ping";
var pingConsumer = new PingConsumer();
MessageBusBuilder
.Publish <PingMessage>(x =>
{
x.DefaultTopic(topic);
// Partition #0 for even counters
// Partition #1 for odd counters
x.PartitionProvider((m, t) => m.Counter % 2);
})
.SubscribeTo <PingMessage>(x => x.Topic(topic)
.Group("subscriber")
.WithSubscriber <PingConsumer>()
.Instances(2))
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f == typeof(PingConsumer))
{
return(pingConsumer);
}
throw new InvalidOperationException();
}));
var kafkaMessageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var messages = Enumerable.Range(0, NumberOfMessages).Select(i => new PingMessage {
Counter = i, Timestamp = DateTime.UtcNow
}).ToList();
messages.AsParallel().ForAll(m => MessageBus.Value.Publish(m).Wait());
stopwatch.Stop();
Log.InfoFormat("Published {0} messages in {1}", messages.Count, stopwatch.Elapsed);
// consume
stopwatch.Restart();
var messagesReceived = ConsumeFromTopic(pingConsumer);
stopwatch.Stop();
Log.InfoFormat("Consumed {0} messages in {1}", messagesReceived.Count, stopwatch.Elapsed);
// assert
// all messages got back
messagesReceived.Count.ShouldBeEquivalentTo(messages.Count);
// Partition #0 => Messages with even counter
messagesReceived
.Where(x => x.Item2 == 0)
.All(x => x.Item1.Counter % 2 == 0)
.Should().BeTrue();
// Partition #1 => Messages with odd counter
messagesReceived
.Where(x => x.Item2 == 1)
.All(x => x.Item1.Counter % 2 == 1)
.Should().BeTrue();
}
