Messages are published with a specific identifier called a Routing key. Queues can use Binding Keys to control which messages are delivered to them.

Routing keys have no dynamic component and can be used to publish messages

commentsKey :: Key Routing Comment
commentsKey = key "posts" & word "new"

Binding keys can contain wildcards, only used for matching messages

commentsKey :: Key Binding Comment
commentsKey = key "posts" & any1 & word "comments" & many

A specific word. Can be used to chain Routing keys or Binding keys

Start a new routing key (can also be used for bindings)

Match any one word. Equivalent to *. Converts to a Binding key and can no longer be used to publish messaages

Match zero or more words. Equivalient to #. Converts to a Binding key and can no longer be used to publish messages

Connect to the AMQP server.

conn <- connect (fromURI "amqp://guest:guest@localhost:5672")

Parses amqp standard URI of the form amqp://user:passwordhost:port/vhost and returns a ConnectionOpts for use with openConnection'' | Any of these fields may be empty and will be replaced with defaults from amqp:/guest:guest@localhost:5672@

send a message to a queue. Enforces that the message type and queue name are correct at the type level

let key = key "users" :: Key Routing User
publish conn key (User "username")

Publishing to a Binding Key results in an error

-- Compiler error! This doesn't make sense
let key = key "users" & many :: Key Binding User
publish conn key (User "username")

Create a queue to receive messages matching the Key with a name prefixed via queueName.

q <- Worker.queue conn "main" $ key "messages" & any1
Worker.worker conn def q onError onMessage

Create a queue to receive messages matching the binding key. Each queue with a unique name will be delivered a separate copy of the messsage. Workers operating on the same queue, or on queues with the same name will load balance

A queue is an inbox for messages to be delivered

Name a queue with a prefix and the binding key name. Useful for seeing at a glance which queues are receiving which messages

-- "main messages.new"
queueName "main" (key "messages" & word "new")

a parsed message from the queue

Create a worker which loops, checks for messages, and handles errors

startWorker conn queue = do
  Worker.worker conn def queue onError onMessage

  where
    onMessage :: Message User
    onMessage m = do
      putStrLn "handle user message"
      print (value m)

    onError :: WorkerException SomeException -> IO ()
    onError e = do
      putStrLn "Do something with errors"

Exceptions created while processing

Options for worker

The default value for this type.