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:

npm run rabbit:start

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 src/server/index.ts, after opening the RabbitMQ connect, create a new confirm channel using the .createConfirmChannel method on the connection.

The ConfirmChannel type from the amqplib package is a wrapper around the standard Channel type, but with additional functionality for confirming message delivery, via a callback.

Create a new directory: src/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 src/internal/pubsub. Here's its signature:

function publishJSON<T>(
  ch: ConfirmChannel,
  exchange: string,
  routingKey: string,
  value: T,
): Promise<void>;

In publishJSON:
1. Serialize the value to JSON bytes.
2. Use the channel's .publish method to publish the message to the exchange with the routing key.
  1. In the content parameter, send the new buffer created from the JSON bytes.
  2. For the options object, set the contentType to "application/json"

Run npm i --save-dev @types/node if it isn't already installed, as it provides the type definitions for Node.js, including the Buffer type.

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 ExchangePerilDirect string in src/internal/routing/routing.ts for the exchange.
3. Use the PauseKey string in src/internal/routing/routing.ts for the routing key.
4. The data to send is the JSON-marshaled PlayingState object from src/internal/gamelogic/gamestate.ts, 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:

npm run 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.