carrot 0.4.2

Introduction

carrot is an AMQP messaging queue framework. AMQP is the Advanced Message Queuing Protocol, an open standard protocol for message orientation, queuing, routing, reliability and security.

The aim of carrot is to make messaging in Python as easy as possible by providing a high-level interface for producing and consuming messages. At the same time it is a goal to re-use what is already available as much as possible.

carrot has pluggable messaging back-ends, so it is possible to support several messaging systems. At the time of release, the py-amqplib based backend is considered suitable for production use.

Several AMQP message broker implementations exists, including RabbitMQ, ZeroMQ and Apache ActiveMQ. You’ll need to have one of these installed, personally we’ve been using RabbitMQ.

Before you start playing with carrot, you should probably read up on AMQP, and you could start with the excellent article about using RabbitMQ under Python, Rabbits and warrens. For more detailed information, you can refer to the Wikipedia article about AMQP.

Documentation

Carrot is using Sphinx, and the latest documentation is available at GitHub:

http://github.com/ask/carrot/

$ pip install carrot

$ easy_install carrot

$ python setup.py build
# python setup.py install # as root

Creating a connection

You can set up a connection by creating an instance of carrot.messaging.AMQPConnection, with the appropriate options for your AMQP server:

>>> from carrot.connection import AMQPConnection
>>> amqpconn = AMQPConnection(hostname="localhost", port=5672,
...                           userid="test", password="test",
...                           vhost="test")

If you’re using Django you can use the carrot.connection.DjangoAMQPConnection class instead, which loads the connection settings from your settings.py:

AMQP_SERVER = "localhost"
AMQP_PORT = 5672
AMQP_USER = "test"
AMQP_PASSWORD = "secret"
AMQP_VHOST = "/test"

Then create a connection by doing:

>>> from carrot.connection import DjangoAMQPConnection
>>> amqpconn = DjangoAMQPConnection()

Receiving messages using a Consumer

First we open up a Python shell and start a message consumer.

This consumer declares a queue named "feed", receiving messages with the routing key "importer" from the "feed" exchange.

The example then uses the consumers wait() method to go into consume mode, where it continuously polls the queue for new messages, and when a message is received it passes the message to all registered callbacks.

>>> from carrot.messaging import Consumer
>>> consumer = Consumer(connection=amqpconn, queue="feed",
...                     exchange="feed", routing_key="importer")
>>> def import_feed_callback(message_data, message)
...     feed_url = message_data["import_feed"]
...     print("Got feed import message for: %s" % feed_url)
...     # something importing this feed url
...     # import_feed(feed_url)
...     message.ack()
>>> consumer.register_callback(import_feed_callback)
>>> consumer.wait() # Go into the consumer loop.

Sending messages using a Publisher

Then we open up another Python shell to send some messages to the consumer defined in the last section.

>>> from carrot.messaging import Publisher
>>> publisher = Publisher(connection=amqpconn,
...                       exchange="feed", routing_key="importer")
>>> publisher.send({"import_feed": "http://cnn.com/rss/edition.rss"})
>>> publisher.close()

Look in the first Python shell again (where consumer.wait() is running), where the following text has been printed to the screen:

Got feed import message for: http://cnn.com/rss/edition.rss

By default every message is encoded using JSON, so sending Python data structures like dictionaries and lists works. If you want to support more complicated data, you might want to configure the publisher and consumer to use something like pickle, by providing them with an encoder and decoder respectively.

Receiving messages without a callback

You can also poll the queue manually, by using the fetch method. This method returns a Message object, from where you can get the message body, de-serialize the body to get the data, acknowledge, reject or re-queue the message.

>>> consumer = Consumer(connection=amqpconn, queue="feed",
...                     exchange="feed", routing_key="importer")
>>> message = consumer.fetch()
>>> if message:
...    message_data = message.decode()
...    message.ack()
... else:
...     # No messages waiting on the queue.
>>> consumer.close()

Sub-classing the messaging classes

The Consumer, and Publisher classes can also be subclassed. Thus you can define the above publisher and consumer like so:

>>> from carrot.messaging import Publisher, Consumer

>>> class FeedPublisher(Publisher):
...     exchange = "feed"
...     routing_key = "importer"
...
...     def feed_import(feed_url):
...         return self.send({"action": "import_feed",
...                           "feed_url": feed_url})

>>> class FeedConsumer(Consumer):
...     queue = "feed"
...     exchange = "feed"
...     routing_key = "importer"
...
...     def receive(self, message_data, message):
...         action = message_data["action"]
...         if action == "import_feed":
...             # something importing this feed
...             # import_feed(message_data["feed_url"])
                message.ack()
...         else:
...             raise Exception("Unknown action: %s" % action)

>>> publisher = FeedPublisher(connection=amqpconn)
>>> publisher.import_feed("http://cnn.com/rss/edition.rss")
>>> publisher.close()

>>> consumer = FeedConsumer(connection=amqpconn)
>>> consumer.wait() # Go into the consumer loop.