OpenStack建立实例完整过程源码详细分析（14）----依据AMQP通信架构实现消息接收机制解析之一
拓拔稳
感谢朋友支持本博客，欢迎共同探讨交流，由于能力和时间有限，错误之处在所难免，欢迎指正！
如果转载，请保留作者信息。
博客地址：http://blog.csdn.net/gaoxingnengjisuan
邮箱地址：dong.liu@siat.ac.cn
这篇博文开始解析NOVA中的AMQP架构下消息的消费者如何从特定的消息队列中读取发送给自己的消息，并进行执行操作。
总体来讲，Nova中的各个服务在启动的时候就会初始化会用到的队列，而且会启动一个绿色线程，不断的循环验证新的消息的到来，一旦有新的消息，将会由合适的consumer进行读取，并进一步进行消息的解析和执行操作。
下面，我将会以compute服务的启动作为实例，重点解析AMQP架构下消息的消费操作。
1.kombu consumer代码示例
kombu中消息接收消费机制的简单实现如示例所示：
#!/usr/bin/python
from kombu.entity import Exchange, Queue
from kombu.messaging import Consumer
from kombu.connection import Connection
def process_media(body, message):
print body
message.ack()
connection = Connection('amqp://guest:bupt@172.16.4.1:5672//')
channel = connection.channel()
media_exchange = Exchange('media', 'direct', channel)
video_queue = Queue('video', exchange=media_exchange, routing_key='video', channel=channel)
consumer = Consumer(channel, queues=[video_queue], callbacks=[process_media])
consumer.consume()
while True:
connection.drain_events()
consumer.cancel() （1）创建连接；
（2）获取channel；
（3）创建exchange；
（4）创建队列并与exchange绑定；
（5）创建Consumer；
（6）consume()向server注册，表明可以接受消息了；
（7）drain_enents阻塞程序，等待消息到来；
（8）cancel（）通知server不要向该consumer发送任何消息了；
在nova中，当然不能实现的这么简便，而是进行了一系列的封装操作，但是基本的实现思路是一致的。
2.以nova-compute服务启动为例，解析AMQP架构下消息的消费操作
首先来看nova-compute服务启动脚本代码：
"""
Nova Compute的启动脚本；
"""
import eventlet
import os
if os.name == 'nt':
eventlet.monkey_patch(os=False)
else:
eventlet.monkey_patch()
import os
import sys
import traceback
from oslo.config import cfg
POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
os.pardir,
os.pardir))
if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'nova', '__init__.py')):
sys.path.insert(0, POSSIBLE_TOPDIR)
from nova import config
import nova.db.api
from nova import exception
from nova.openstack.common import log as logging
from nova import service
from nova import utils
CONF = cfg.CONF
CONF.import_opt('compute_topic', 'nova.compute.rpcapi')
CONF.import_opt('use_local', 'nova.conductor.api', group='conductor')
LOG = logging.getLogger('nova.compute')
def block_db_access():
class NoDB(object):
def __getattr__(self, attr):
return self
def __call__(self, *args, **kwargs):
stacktrace = "".join(traceback.format_stack())
LOG.error('No db access allowed in nova-compute: %s' % stacktrace)
raise exception.DBNotAllowed('nova-compute')
nova.db.api.IMPL = NoDB()
if __name__ == '__main__':
config.parse_args(sys.argv)
logging.setup('nova')
utils.monkey_patch()
if not CONF.conductor.use_local:
block_db_access()
# 初始化Service这个类，并且获取其实例化对象；
server = service.Service.create(binary='nova-compute',
topic=CONF.compute_topic,
db_allowed=False)
service.serve(server)
service.wait()
def serve(server, workers=None):
global _launcher
if _launcher:
raise RuntimeError(_('serve() can only be called once'))
if workers:
_launcher = ProcessLauncher()
_launcher.launch_server(server, workers=workers)
else:
_launcher = ServiceLauncher()
_launcher.launch_server(server)def launch_server(self, server):
"""
加载并启动给定的服务；
"""
if self.backdoor_port is not None:
server.backdoor_port = self.backdoor_port
gt = eventlet.spawn(self.run_server, server)
self._services.append(gt)def run_server(server):
"""
启动并等待一个服务的运行的结束；
"""
server.start()
server.wait()
def start(self):
verstr = version.version_string_with_package()
LOG.audit(_('Starting %(topic)s node (version %(version)s)'),
{'topic': self.topic, 'version': verstr})
# 在进程开始之前执行基本配置的检测；
self.basic_config_check()
self.manager.init_host()
self.model_disconnected = False
# 获取上下文信息；
ctxt = context.get_admin_context()
try:
# 查询数据库获取topic、host、binary类型指定的所有的服务；
self.service_ref = self.conductor_api.service_get_by_args(ctxt, self.host, self.binary)
# 获取这些服务的ID值；
self.service_id = self.service_ref['id']
except exception.NotFound:
# 如果没有合适的服务存在，则根据上下文要求建立一个服务环境；
self.service_ref = self._create_service_ref(ctxt)
if self.backdoor_port is not None:
self.manager.backdoor_port = self.backdoor_port
# 建立一个到用于RPC的消息总线的连接；
# 建立获取到RabbitMQ的连接；
# 创建连接，默认是kombu实现；
self.conn = rpc.create_connection(new=True)
LOG.debug(_("Creating Consumer connection for Service %s") %
self.topic)
# 更新现有资源；
# 读取系统的总共资源以及可用的资源，更新资源，算出已经使用的资源；
self.manager.pre_start_hook(rpc_connection=self.conn)
# 获取RPC调度器；
# 初始化RPC调度器；
rpc_dispatcher = self.manager.create_rpc_dispatcher()
# 建立不同的消息消费者；
# 创建以服务的topic为路由键的消费者；
self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=False)
# 创建以服务的topic和本机名为路由键的消费者（基于topic&host，可用来接收定向消息）;
node_topic = '%s.%s' % (self.topic, self.host)
self.conn.create_consumer(node_topic, rpc_dispatcher, fanout=False)
# fanout直接投递消息，不进行匹配，速度最快（fanout类型，可用于接收广播消息）；
self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=True)
# 启动消费者线程；
# consume_in_thread用evelent.spawn创建一个协程一直运行；
# 等待消息，在有消费到来时会创建新的协程运行远程调用的函数；
self.conn.consume_in_thread()
# 在启动服务之后，并能够通过RPC接收消息之后，广播通知每个节点更新capabilities属性值，由控制器获取每个节点上的这个属性值；
self.manager.post_start_hook()
LOG.debug(_("Join ServiceGroup membership for this service %s")
% self.topic)
# 添加服务到服务成员组；
pulse = self.servicegroup_api.join(self.host, self.topic, self)
if pulse:
self.timers.append(pulse)
if self.periodic_enable:
if self.periodic_fuzzy_delay:
initial_delay = random.randint(0, self.periodic_fuzzy_delay)
else:
initial_delay = None
periodic = utils.DynamicLoopingCall(self.periodic_tasks)
periodic.start(initial_delay=initial_delay,
periodic_interval_max=self.periodic_interval_max)
self.timers.append(periodic)2.1 语句self.conn = rpc.create_connection(new=True)的解析
这条语句实现了建立获取到RabbitMQ的连接，具体来看方法create_connection的代码实现：
def create_connection(new=True):
"""
建立一个到用于RPC的消息总线的连接；
建立获取到RabbitMQ的连接；
"""
return _get_impl().create_connection(CONF, new=new)def create_connection(conf, new=True):
"""
建立获取到RabbitMQ的连接；
"""
# get_connection_pool：获取到RabbitMQ的连接池，并返回这个连接池的对象；
# Connection：连接到RabbitMQ的实现类；
return rpc_amqp.create_connection(
conf, new,
rpc_amqp.get_connection_pool(conf, Connection))
def create_connection(conf, new, connection_pool):
"""
建立连接；
"""
return ConnectionContext(conf, connection_pool, pooled=not new)class ConnectionContext(rpc_common.Connection):
"""
这个类是对连接功能的一个封装；
这个类提供方法建立新的连接，也可以实现从连接池中直接获取一个连接；
当然，也有方法可以实现对连接的删除，当连接删除之后，如果是从连接池获取的连接会把连接返回连接池；
"""
def __init__(self, conf, connection_pool, pooled=True, server_params=None):
"""
建立一个新的连接，或者从连接池中获取一个连接；
"""
self.connection = None
self.conf = conf
self.connection_pool = connection_pool
# 如果已经获取连接池对象，直接从连接池中获取一个连接；
if pooled:
self.connection = connection_pool.get()
else:
self.connection = connection_pool.connection_cls(conf, server_params=server_params)
self.pooled = pooled2.2 语句self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=False)的解析
这里有三条相似的语句，如下：
# 建立不同的消息消费者；
# 创建以服务的topic为路由键的消费者；
self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=False)
# 创建以服务的topic和本机名为路由键的消费者（基于topic&host，可用来接收定向消息）;
node_topic = '%s.%s' % (self.topic, self.host)
self.conn.create_consumer(node_topic, rpc_dispatcher, fanout=False)
# fanout直接投递消息，不进行匹配，速度最快（fanout类型，可用于接收广播消息）；
self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=True)这里现以语句self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=False)作为示例进行解析。
首先来看方法create_consumer，实现了消息消费者的建立，具体来看代码的实现：
def create_consumer(self, topic, proxy, fanout=False):
"""
根据参数建立具体的消息消费者；
"""
# Connection：连接到RabbitMQ的实现类；
# get_connection_pool：获取到RabbitMQ的连接池，并返回这个连接池的对象；
# connection_cls：是一个连接类的对象；
# 获取ProxyCallback类的初始化实例对象；
proxy_cb = rpc_amqp.ProxyCallback(
self.conf, proxy,
rpc_amqp.get_connection_pool(self.conf, Connection))
self.proxy_callbacks.append(proxy_cb)
if fanout:
# 建立一个广播类型的消费者；
# 声明队列和交换器，通过routing key绑定队列到交换器；
self.declare_fanout_consumer(topic, proxy_cb)
else:
# declare_topic_consumer：建立一个主题式的信息消费者；
# 声明队列和交换器，通过routing key绑定队列到交换器；
self.declare_topic_consumer(topic, proxy_cb)
class ProxyCallback(_ThreadPoolWithWait):
def __init__(self, conf, proxy, connection_pool):
# 这个类实现了启动一个用于处理传入信息的绿色线程；
super(ProxyCallback, self).__init__(
conf=conf,
connection_pool=connection_pool,
)
self.proxy = proxy
self.msg_id_cache = _MsgIdCache()
def __call__(self, message_data):
if hasattr(local.store, 'context'):
del local.store.context
# 记录日志，但是一些敏感信息，像创建虚拟机时的密码等信息不会
# 显示在日志中，面是替换为"<SANITIZED>"
rpc_common._safe_log(LOG.debug, _('received %s'), message_data)
# 重复消息检测；
# ack返回前，AMQP消费者可能会出现两次读取相同信息的异常，这个方法可以防止这样的情况出现；
self.msg_id_cache.check_duplicate_message(message_data)
# 从message_data中解析出上下文信息；
ctxt = unpack_context(self.conf, message_data)
# 从message_data中获取要执行的方法method；
method = message_data.get('method')
# 从message_data中获取相关参数args；
args = message_data.get('args', {})
# 从message_data中获取版本的相关信息；
version = message_data.get('version', None)
if not method:
LOG.warn(_('no method for message: %s') % message_data)
ctxt.reply(_('No method for message: %s') % message_data,
connection_pool=self.connection_pool)
return
# 建立一个新的绿色线程来执行方法method；
self.pool.spawn_n(self._process_data, ctxt, version, method, args)class _ThreadPoolWithWait(object):
"""
这个类实现了启动一个用于处理传入信息的绿色线程；
"""
def __init__(self, conf, connection_pool):
self.pool = greenpool.GreenPool(conf.rpc_thread_pool_size)
self.connection_pool = connection_pool
self.conf = conf这里的_call_方法是非常非常重要的，当然这里我只是拿出来给大家看一下，这里还没有调用这个方法，这个方法就是执行了对获取的消息进行最终处理的过程。其实nova中调用这个方法真的是辗转挪移，七拐八拐，不留意的话很难看到这个方法的调用，后面我会专门进行解析说明这个方法是怎么被调用的。
2.2.2 语句self.declare_topic_consumer(topic, proxy_cb)的解析
这条语句实现了建立一个主题式的消息消费者，具体来看方法declare_topic_consumer的代码：
def declare_topic_consumer(self, topic, callback=None, queue_name=None,
exchange_name=None):
"""
建立一个主题式的信息消费者；
声明队列和交换器，通过routing key绑定队列到交换器；
"""
# 根据传入的类建立信息消费者，把建立好的消费者对象加入到consumers列表中；
self.declare_consumer(functools.partial(TopicConsumer,
name=queue_name,
exchange_name=exchange_name,
),
topic, callback)
def declare_consumer(self, consumer_cls, topic, callback):
"""
根据传入的类建立信息消费者，把建立好的消费者对象加入到consumers列表中；
"""
def _connect_error(exc):
log_info = {'topic': topic, 'err_str': str(exc)}
LOG.error(_("Failed to declare consumer for topic '%(topic)s': "
"%(err_str)s") % log_info)
def _declare_consumer():
# 传递进来的类consumer_cls应该是TopicConsumer；
# 声明队列和交换器，通过routing key绑定队列到交换器；
consumer = consumer_cls(self.conf, self.channel, topic, callback,
self.consumer_num.next())
self.consumers.append(consumer)
return consumer
return self.ensure(_connect_error, _declare_consumer)下面对类TopicConsumer的初始化过程进行比较细致的解析，来看代码的实现：
class TopicConsumer(ConsumerBase):
"""
主题式消息消费者类；
"""
def __init__(self, conf, channel, topic, callback, tag, name=None,
exchange_name=None, **kwargs):
# 默认选项的设置；
# rabbit_durable_queues：这个参数定义了在RabbitMQ中是否使用持久性的队列；
# 参数的默认值为False；
options = {'durable': conf.rabbit_durable_queues,
'queue_arguments': _get_queue_arguments(conf),
'auto_delete': False,
'exclusive': False}
options.update(kwargs)
# 获取交换器的名称；
exchange_name = exchange_name or rpc_amqp.get_control_exchange(conf)
# 根据相关的配置参数声明产生一个交换器；
exchange = kombu.entity.Exchange(name=exchange_name,
type='topic',
durable=options['durable'],
auto_delete=options['auto_delete'])
# 重连接到channel；
# 声明队列和交换器，通过routing key绑定队列到交换器；
super(TopicConsumer, self).__init__(channel,
callback,
tag,
name=name or topic,
exchange=exchange,
routing_key=topic,
**options)
class Exchange(MaybeChannelBound):
"""
交换器声明；
"""
# 短暂性消息传递方式；
TRANSIENT_DELIVERY_MODE = TRANSIENT_DELIVERY_MODE
# 持久性消息传递方式；
PERSISTENT_DELIVERY_MODE = PERSISTENT_DELIVERY_MODE
# 交换器名称；
name = ""
# 如果没有定义交换器类型，默认的交换器类型（直接式交换器），但是这里面已经定义为主题式交换器；
type = "direct"
# 默认交换器是持久类型的；
durable = True
auto_delete = False
# 持久性消息传递方式；
delivery_mode = PERSISTENT_DELIVERY_MODE
attrs = (("name", None),
("type", None),
("arguments", None),
("durable", bool),
("auto_delete", bool),
("delivery_mode", lambda m: DELIVERY_MODES.get(m) or m))
def __init__(self, name="", type="", channel=None, **kwargs):
super(Exchange, self).__init__(**kwargs)
self.name = name or self.name
self.type = type or self.type
# maybe_bind：如果没有绑定，则绑定实例到channel；
self.maybe_bind(channel)def maybe_bind(self, channel):
"""
如果没有绑定，则绑定实例到channel；
"""
if not self.is_bound and channel:
self._channel = channel
self.when_bound()
self._is_bound = True
return self
class ConsumerBase(object):
"""
Consumer（消费者）基类；
"""
def __init__(self, channel, callback, tag, **kwargs):
"""
根据相关参数在一个amqp channel上声明产生一个队列；
"""
self.callback = callback
self.tag = str(tag)
self.kwargs = kwargs
self.queue = None
# 重连接到channel；
# 声明队列和交换器，通过routing key绑定队列到交换器；
self.reconnect(channel)
def reconnect(self, channel):
"""
重连接到channel；
声明队列和交换器，通过routing key绑定队列到交换器；
"""
self.channel = channel
self.kwargs['channel'] = channel
# 队列的声明类，实现队列初始化，并且实现队列与交换器和channel的绑定；
self.queue = kombu.entity.Queue(**self.kwargs)
# 序列重新的申报；
# 声明队列和交换器，通过routing key绑定队列到交换器；
self.queue.declare()
class Queue(MaybeChannelBound):
"""
队列的声明类，实现队列初始化，并且实现队列与交换器和channel的绑定；
"""
name = ""
exchange = None
routing_key = ""
durable = True
exclusive = False
auto_delete = False
no_ack = False
attrs = (("name", None),
("exchange", None),
("routing_key", None),
("queue_arguments", None),
("binding_arguments", None),
("durable", bool),
("exclusive", bool),
("auto_delete", bool),
("no_ack", None),
("alias", None))
def __init__(self, name="", exchange=None, routing_key="", channel=None,
**kwargs):
super(Queue, self).__init__(**kwargs)
self.name = name or self.name
self.exchange = exchange or self.exchange
self.routing_key = routing_key or self.routing_key
# exclusive implies auto-delete.
if self.exclusive:
self.auto_delete = True
# 如果没有绑定，则绑定到channel；
self.maybe_bind(channel)再来看语句self.queue.declare()，这条语句实现了声明队列和交换器，通过routing key绑定队列到交换器，具体的实现来看方法declare的代码：
def declare(self, nowait=False):
"""
声明队列和交换器，通过routing key绑定队列到交换器；
"""
# 队列名称；
name = self.name
if name:
if self.exchange:
self.exchange.declare(nowait)
self.queue_declare(nowait, passive=False)
# 通过routing key绑定队列到交换器；
if name:
self.queue_bind(nowait)
return self.name首先来看语句self.exchange.declare(nowait)，这条语句实现了对特定的交换器的声明操作，具体来看方法declare的代码实现：
def declare(self, nowait=False):
"""
声明交换器，并在代理上创建交换器；
"""
# 在绿色线程中执行方法exchange_declare，实现交换器的声明和绑定；
return _SYN(self.channel.exchange_declare, exchange=self.name,
type=self.type,
durable=self.durable,
auto_delete=self.auto_delete,
arguments=self.arguments,
nowait=nowait)def exchange_declare(self, exchange, type="direct", durable=False,
auto_delete=False, arguments=None, nowait=False):
"""
声明交换器；
"""
try:
prev = self.state.exchanges[exchange]
if not self.typeof(exchange).equivalent(prev, exchange, type,
durable, auto_delete,
arguments):
raise NotEquivalentError(
"Cannot redeclare exchange %r in vhost %r with "
"different type, durable or autodelete value" % (
exchange,
self.connection.client.virtual_host or "/"))
except KeyError:
self.state.exchanges[exchange] = {
"type": type,
"durable": durable,
"auto_delete": auto_delete,
"arguments": arguments or {},
"table": [],
}
def queue_declare(self, nowait=False, passive=False):
"""
在服务器上声明队列；
"""
ret = _SYN(self.channel.queue_declare, queue=self.name,
passive=passive,
durable=self.durable,
exclusive=self.exclusive,
auto_delete=self.auto_delete,
arguments=self.queue_arguments,
nowait=nowait)
if not self.name:
self.name = ret[0]
return retdef queue_declare(self, queue, passive=False, auto_delete=False, **kwargs):
"""
声明队列；
"""
if auto_delete:
self.auto_delete_queues.setdefault(queue, 0)
if passive and not self._has_queue(queue, **kwargs):
raise StdChannelError("404",
u"NOT_FOUND - no queue %r in vhost %r" % (
queue, self.connection.client.virtual_host or '/'),
(50, 10), "Channel.queue_declare")
else:
self._new_queue(queue, **kwargs)
return queue, self._size(queue), 0
def queue_bind(self, nowait=False):
"""
在服务器上建立队列的绑定；
通过routing key绑定队列到交换器；
"""
return _SYN(self.channel.queue_bind, queue=self.name,
exchange=self.exchange.name,
routing_key=self.routing_key,
arguments=self.binding_arguments,
nowait=nowait)def queue_bind(self, queue, exchange, routing_key, arguments=None,
**kwargs):
"""
通过routing key绑定队列到交换器；
"""
# 如果队列已经在绑定的列表中，则直接返回；
if queue in self.state.bindings:
return
table = self.state.exchanges[exchange].setdefault("table", [])
# 队列绑定的信息加入到列表中；
self.state.bindings[queue] = exchange, routing_key, arguments
meta = self.typeof(exchange).prepare_bind(queue,
exchange,
routing_key,
arguments)
table.append(meta)
if self.supports_fanout:
self._queue_bind(exchange, *meta)def prepare_bind(self, queue, exchange, routing_key, arguments):
return routing_key, self.key_to_pattern(routing_key), queue在下一篇博文中，将继续解析/nova/server.py中类Service下的方法def start(self)中的下一条也是很重要的语句：self.conn.consume_in_thread()，这条语句实现了从队列中获取消息，并最终实现了对消息的处理和执行操作。
类似资料：