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

Consumers

So as of right now, we have the following setup:

A publisher publishes a message
The message arrives in an exchange
The message is routed to queue(s)
???
Profit

In all seriousness, nothing happens after the message arrives in the queue!

This is where consumers come in. Consumers are programs (like our "client" program) that connect to queues and pull the messages out of them.

Assignment

Let's configure our client consumers to process the "pause messages" and update their local game state.

In your internal/pubsub package, create a new function called SubscribeJSON, here's my function signature:

func SubscribeJSON[T any](
    conn *amqp.Connection,
    exchange,
    queueName,
    key string,
    queueType SimpleQueueType, // an enum to represent "durable" or "transient"
    handler func(T),
) error

In SubscribeJSON:
1. Call DeclareAndBind to make sure that the given queue exists and is bound to the exchange
2. Get a new chan of amqp.Delivery structs by using the channel.Consume method.
  1. Use an empty string for the consumer name so that it will be auto-generated
  2. Set all other parameters to false/nil
3. Start a goroutine that ranges over the channel of deliveries, and for each message:
  1. Unmarshal the body (raw bytes) of each message delivery into the (generic) T type.
  2. Call the given handler function with the unmarshaled message
  3. Acknowledge the message with delivery.Ack(false) to remove it from the queue
Create a new function called handlerPause in the cmd/client application package. It accepts a game state struct and returns a new handler function that accepts a routing.PlayingState struct. This will be the handler we pass into SubscribeJSON that will be called each time a new message is consumed. Here's my signature:
```
func handlerPause(gs *gamelogic.GameState) func(routing.PlayingState)
```
1. In the handler function that handlerPause returns:
  1. Use defer fmt.Print("> ") to display a new prompt (> ) when the function exits.
  2. Use the game state's HandlePause method to pause the game for the client.
In the cmd/client package's main function, after creating the game state, replace your previous DeclareAndBind call with pubsub.SubscribeJSON. Use the following parameters:
1. The connection
2. The direct exchange (constant can be found in internal/routing)
3. A queue named pause.username where username is the username of the player
4. The routing key pause (constant can be found in internal/routing)
5. Transient queue type
6. The new handler we just created.
Test the New Code
1. Start an instance of the server and the client in separate terminals. Use washington as the username for the client.
2. Spawn a unit using the client: spawn europe infantry
3. Pause the game using the server. You should see the client detect (consume) the pause message
4. Try to move a unit, the client should not allow it because the game is paused
5. Resume the game using the server. You should see the client detect (consume) the resume message
6. Try to move a unit, the client should allow it

Run and submit the CLI tests with the server and client still running.