The nova.openstack.common.rpc.impl_kombu Module

class Connection(conf, server_params=None)

Bases: object

Connection object.

cancel_consumer_thread()

Cancel a consumer thread

close()

Close/release this connection

consume(limit=None)

Consume from all queues/consumers

consume_in_thread()

Consumer from all queues/consumers in a greenthread

create_consumer(topic, proxy, fanout=False)

Create a consumer that calls a method in a proxy object

create_worker(topic, proxy, pool_name)

Create a worker that calls a method in a proxy object

declare_consumer(consumer_cls, topic, callback)

Create a Consumer using the class that was passed in and add it to our list of consumers

declare_direct_consumer(topic, callback)

Create a ‘direct’ queue. In nova’s use, this is generally a msg_id queue used for responses for call/multicall

declare_fanout_consumer(topic, callback)

Create a ‘fanout’ consumer

declare_topic_consumer(topic, callback=None, queue_name=None, exchange_name=None)

Create a ‘topic’ consumer.

direct_send(msg_id, msg)

Send a ‘direct’ message

ensure(error_callback, method, *args, **kwargs)

fanout_send(topic, msg)

Send a ‘fanout’ message

get_channel()

Convenience call for bin/clear_rabbit_queues

iterconsume(limit=None, timeout=None)

Return an iterator that will consume from all queues/consumers

join_consumer_pool(callback, pool_name, topic, exchange_name=None)

Register as a member of a group of consumers for a given topic from the specified exchange.

Exactly one member of a given pool will receive each message.

A message will be delivered to multiple pools, if more than one is created.

notify_send(topic, msg, **kwargs)

Send a notify message on a topic

pool = None

publisher_send(cls, topic, msg, timeout=None, **kwargs)

Send to a publisher based on the publisher class

reconnect()

Handles reconnecting and re-establishing queues. Will retry up to self.max_retries number of times. self.max_retries = 0 means to retry forever. Sleep between tries, starting at self.interval_start seconds, backing off self.interval_stepping number of seconds each attempt.

reset()

Reset a connection so it can be used again

topic_send(topic, msg, timeout=None)

Send a ‘topic’ message

wait_on_proxy_callbacks()

Wait for all proxy callback threads to exit.

class ConsumerBase(channel, callback, tag, **kwargs)

Bases: object

Consumer base class.

cancel()

Cancel the consuming from the queue, if it has started

consume(*args, **kwargs)

Actually declare the consumer on the amqp channel. This will start the flow of messages from the queue. Using the Connection.iterconsume() iterator will process the messages, calling the appropriate callback.

If a callback is specified in kwargs, use that. Otherwise, use the callback passed during __init__()

If kwargs[‘nowait’] is True, then this call will block until a message is read.

Messages will automatically be acked if the callback doesn’t raise an exception

reconnect(channel)

Re-declare the queue after a rabbit reconnect

class DirectConsumer(conf, channel, msg_id, callback, tag, **kwargs)

Bases: nova.openstack.common.rpc.impl_kombu.ConsumerBase

Queue/consumer class for ‘direct’

class DirectPublisher(conf, channel, msg_id, **kwargs)

Bases: nova.openstack.common.rpc.impl_kombu.Publisher

Publisher class for ‘direct’

class FanoutConsumer(conf, channel, topic, callback, tag, **kwargs)

Bases: nova.openstack.common.rpc.impl_kombu.ConsumerBase

Consumer class for ‘fanout’

class FanoutPublisher(conf, channel, topic, **kwargs)

Bases: nova.openstack.common.rpc.impl_kombu.Publisher

Publisher class for ‘fanout’

class NotifyPublisher(conf, channel, topic, **kwargs)

Bases: nova.openstack.common.rpc.impl_kombu.TopicPublisher

Publisher class for ‘notify’

reconnect(channel)

class Publisher(channel, exchange_name, routing_key, **kwargs)

Bases: object

Base Publisher class

reconnect(channel)

Re-establish the Producer after a rabbit reconnection

send(msg, timeout=None)

Send a message

class TopicConsumer(conf, channel, topic, callback, tag, name=None, exchange_name=None, **kwargs)

Bases: nova.openstack.common.rpc.impl_kombu.ConsumerBase

Consumer class for ‘topic’

class TopicPublisher(conf, channel, topic, **kwargs)

Bases: nova.openstack.common.rpc.impl_kombu.Publisher

Publisher class for ‘topic’

call(conf, context, topic, msg, timeout=None)

Sends a message on a topic and wait for a response.

cast(conf, context, topic, msg)

Sends a message on a topic without waiting for a response.

cast_to_server(conf, context, server_params, topic, msg)

Sends a message on a topic to a specific server.

cleanup()

create_connection(conf, new=True)

Create a connection

fanout_cast(conf, context, topic, msg)

Sends a message on a fanout exchange without waiting for a response.

fanout_cast_to_server(conf, context, server_params, topic, msg)

Sends a message on a fanout exchange to a specific server.

multicall(conf, context, topic, msg, timeout=None)

Make a call that returns multiple times.

notify(conf, context, topic, msg, envelope)

Sends a notification event on a topic.