CreateQueues and Exchanges - MassTransit

Question

I'm using massTransit with RabbitMQ. Publishing messages with massTransit will create an exchange for my message type. And a masstransit consumer will create queues and bindings to an exchange. Great, make things easy.

Before looking at massTransit I used rabbitMQ's api to create queues, exchanges and binding. I would get both publisher and consumers to run the same setup code. So no matter who ran first all queues, exchanges and binding will be created no matter which part of the application ran first. This was great when running in a development environment.

I was wondering if something similar could be achieved with massTransit?

Answer 1

With MassTransit should be the same: consumers will create queues bound to the exchanges of the messages they consume (with names equal to the messages types). Publishers will create the exchanges with same names of the types of the messages they publish. Remember that if the messages published or consumed have super classes or implement interfaces, MassTransit will create the same hierarchy, creating and binding as many exchanges as your message class hierarchy has.

Answer 2

You could use HareDu 2 to achieve this with the below code. This works with both Autofac and .NET Core DI. Check the docs here: https://github.com/ahives/HareDu2

// Create a queue
var result = _container.Resolve<IBrokerObjectFactory>()
                .Object<Queue>()
                .Create(x =>
                {
                    x.Queue("fake_queue");
                    x.Configure(c =>
                    {
                        c.IsDurable();
                        c.AutoDeleteWhenNotInUse();
                        c.HasArguments(arg =>
                        {
                            arg.SetQueueExpiration(1000);
                            arg.SetPerQueuedMessageExpiration(2000);
                        });
                    });
                    x.Targeting(t =>
                    {
                        t.VirtualHost("fake_vhost");
                        t.Node("fake_node");
                    });
                });


// Create an exchange
var result = _container.Resolve<IBrokerObjectFactory>()
                .Object<Exchange>()
                .Create(x =>
                {
                    x.Exchange("fake_exchange");
                    x.Configure(c =>
                    {
                        c.IsDurable();
                        c.IsForInternalUse();
                        c.HasRoutingType(ExchangeRoutingType.Fanout);
                        c.HasArguments(arg =>
                        {
                            arg.Set("fake_arg", "fake_arg_value");
                        });
                    });
                    x.Targeting(t => t.VirtualHost("fake_vhost"));
                });

// Create a binding
var result = _container.Resolve<IBrokerObjectFactory>()
                .Object<Binding>()
                .Create(x =>
                {
                    x.Binding(b =>
                    {
                        b.Source("fake_exchange");
                        b.Destination("fake_queue");
                        b.Type(BindingType.Exchange);
                    });
                    x.Configure(c =>
                    {
                        c.HasRoutingKey("your_routing_key");
                        c.HasArguments(arg =>
                        {
                            arg.Set("your_arg", "your_arg_value");
                        });
                    });
                    x.Targeting(t => t.VirtualHost("fake_vhost"));
                });