def _declare_queue(target):
connection = kombu.connection.BrokerConnection(transport='memory')
# Kludge to speed up tests.
connection.transport.polling_interval = 0.0
connection.connect()
channel = connection.channel()
# work around 'memory' transport bug in 1.1.3
channel._new_queue('ae.undeliver')
if target.fanout:
exchange = kombu.entity.Exchange(name=target.topic + '_fanout',
type='fanout',
durable=False,
auto_delete=True)
queue = kombu.entity.Queue(name=target.topic + '_fanout_12345',
channel=channel,
exchange=exchange,
routing_key=target.topic)
elif target.server:
exchange = kombu.entity.Exchange(name='openstack',
type='topic',
durable=False,
auto_delete=False)
topic = '%s.%s' % (target.topic, target.server)
queue = kombu.entity.Queue(name=topic,
channel=channel,
exchange=exchange,
routing_key=topic)
else:
exchange = kombu.entity.Exchange(name='openstack',
type='topic',
durable=False,
auto_delete=False)
queue = kombu.entity.Queue(name=target.topic,
channel=channel,
exchange=exchange,
routing_key=target.topic)
queue.declare()
return connection, channel, queue
def listen(host_id, amqp_url,
notifications_exchange_name, rpc_exchange_name,
notification_queue):
"""Listen for messages from AMQP and deliver them to the
in-process queue provided.
"""
LOG.debug('%s starting to listen on %s', host_id, amqp_url)
conn_info = urlparse.urlparse(amqp_url)
connection = kombu.connection.BrokerConnection(
hostname=conn_info.hostname,
userid=conn_info.username,
password=conn_info.password,
virtual_host=conn_info.path,
port=conn_info.port,
)
connection.connect()
channel = connection.channel()
# The notifications coming from quantum/neutron.
notifications_exchange = kombu.entity.Exchange(
name=notifications_exchange_name,
type='topic',
durable=False,
auto_delete=False,
internal=False,
channel=channel,
)
# The RPC instructions coming from quantum/neutron.
agent_exchange = kombu.entity.Exchange(
name=rpc_exchange_name,
type='fanout',
durable=False,
auto_delete=True,
internal=False,
channel=channel,
)
queues = [
kombu.entity.Queue(
'akanda.notifications',
exchange=notifications_exchange,
routing_key='notifications.*',
channel=channel,
durable=False,
auto_delete=False,
),
kombu.entity.Queue(
'akanda.l3_agent',
exchange=agent_exchange,
routing_key='l3_agent',
channel=channel,
durable=False,
auto_delete=False,
),
kombu.entity.Queue(
'akanda.l3_agent.' + host_id,
exchange=agent_exchange,
routing_key='l3_agent.' + host_id,
channel=channel,
durable=False,
auto_delete=False,
),
kombu.entity.Queue(
'akanda.dhcp_agent',
exchange=agent_exchange,
routing_key='dhcp_agent',
channel=channel,
durable=False,
auto_delete=False,
),
kombu.entity.Queue(
'akanda.dhcp_agent.' + host_id,
exchange=agent_exchange,
routing_key='dhcp_agent.' + host_id,
channel=channel,
durable=False,
auto_delete=False,
),
]
for q in queues:
LOG.debug('setting up queue %s', q)
q.declare()
def _process_message(body, message):
"Send the message through the notification queue"
# LOG.debug('received %r', body)
# TODO:
# 1. Ignore notification messages that we don't care about.
# 2. Convert notification and rpc messages to a common format
# so the lower layer does not have to understand both
try:
event = _make_event_from_message(body)
if event:
LOG.debug('received message for %s', event.tenant_id)
notification_queue.put((event.tenant_id, event))
except:
LOG.exception('could not process message: %s' % unicode(body))
message.reject()
else:
message.ack()
consumer = kombu.messaging.Consumer(channel, queues)
consumer.register_callback(_process_message)
consumer.consume()
while True:
try:
connection.drain_events()
except: # noqa
LOG.exception('exception while draining events from queue')
time.sleep(1)
# FIXME(dhellmann): Make this function a class so we can
# control the loop variable and stop draining events
# before sending the shutdown to the workers.
connection.release()