This lesson's interactive features are locked, please to keep using them

Exchanges and Queues

In RabbitMQ, an exchange is where publishers send messages, typically with a routing key.

The exchange takes the message, uses the routing key as a filter, and sends the message to any queues that are listening for that routing key.

Publishers don't know about queues at all. They just send messages to exchanges, sometimes with a routing key.

Terminology

Exchange: A routing agent that sends messages to queues.
Binding: A link between an exchange and a queue that uses a routing key to decide which messages go to the queue.
Queue: A buffer in the RabbitMQ server that holds messages until they are consumed.
Channel: A virtual connection inside a connection that allows you to create queues, exchanges, and publish messages.
Connection: A TCP connection to the RabbitMQ server.

Rabbit Script

Start RabbitMQ in the background with the provided script, if it isn't already running:

./rabbit.sh start

You can stop it with ./rabbit.sh stop and view the logs of the server with ./rabbit.sh logs.

Assignment

Let's update our server to publish pause/resume messages to an exchange on a specific routing key. The server can then communicate with all the various players of the game to let them know when the game is paused or resumed. We'll handle the queues and consumption of the messages later.

In cmd/server/main.go, after opening the RabbitMQ connection, create a new channel using the .Channel method on the connection.
Create a new package: internal/pubsub. This is where we'll put reusable code for interacting with RabbitMQ, that way we can use it in both the server and client.
Create an exported PublishJSON function in the internal/pubsub package. Here's its signature:

func PublishJSON[T any](ch *amqp.Channel, exchange, key string, val T) error

In PublishJSON :
1. Marshal the val to JSON bytes
2. Use the channel's .PublishWithContext method to publish the message to the exchange with the routing key. Some configurations:
  1. Set ctx to context.Background()
  2. Set mandatory to false.
  3. Set immediate to false.
  4. In the amqp.Publishing struct, you only need to set two fields:
    1. ContentType to "application/json".
    2. Body to the JSON bytes.
Back in the server code, use the PublishJSON function to publish a message to the exchange!
1. Use the channel you created.
2. Use the internal/routing package's ExchangePerilDirect string for the exchange.
3. Use the internal/routing package's PauseKey string for the routing key.
4. The data to send is the JSON-marshaled internal/routing's PlayingState struct, with the IsPaused field set to true.
Make sure the RabbitMQ Docker container is running in the background, if it's not run ./rabbit.sh start.
Run your server with:

go run ./cmd/server

Watch the logs (./rabbit.sh logs) of the RabbitMQ server... you should see an error like this:

no exchange 'peril_direct' in vhost '/'

Go to the RabbitMQ management UI at http://localhost:15672 and navigate to the "Exchanges" tab. Create a new exchange called peril_direct with the type direct.
Rerun the server. You should see the message get published without any errors in the RabbitMQ logs.

While there are no hard errors, the message will be "unroutable" because there are no queues bound to the exchange yet, but we'll fix that later.

Run and submit the CLI tests.