1 什么是AMPQ，什么事RabbitMQ，二者是什么关系？
AMPQ是应用层协议的一个标准，它是为了面向消息中间件而设计的。它的主要作用是规定了异步消息传递所使用的协议标准。而AMPQ只是一个协议标准，需要有中间件来实现，实现的中间件有很多，例如，RabbitMQ、Qpid等，openstack官方推荐使用RabbitMQ支持的RPC方式来实现异步消息通信，模式采用典型的发布(Publish)/订阅(subcribe)模式。
2 openstack为什么要用AMPQ，rabbitmq和AMPQ又是什么关系？
Openstack的架构决定了需要使用消息队列机制来实现不同模块间的通信，通过消息验证、消息转换、消息路由架构模式，带来的好处就是可以是模块之间最大程度解耦，客户端不需要关注服务端的位置和是否存在，只需通过消息队列进行信息的发送。RabbitMQ适合部署在一个拓扑灵活易扩展的规模化系统环境中，有效保证不同模块、不同节点、不同进程之间消息通信的时效性，可有效支持OpenStack云平台系统的规模化部署、弹性扩展、灵活架构以及信息安全的需求。
注：RPC（remoteprocedure Call Protocol）远程调用协议。它是一种通过网络从远程计算机程序上请求服务协议。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。
3 下面我们根据conductor 发送RPC信息到Schedule流程理解实现机制。我们都知道，任何一个RPC调用，都有Client/Server两部分，那么在openstack中分别在rpcapi.py和manager.py中实现了client和server。
其实发送消息的机制简单来讲就是下面的流程：
（1）创建连接；
（2）获得channel；
（3）创建exchange；
（4）创建Producer，指定exchange与routing_key；
（5）发送消息；
当然openstack中实现不会这么简单，而是经过了很多层封装，不会整个流程就是上面5部分。既然是根据代码分析，那么多说无益，先上rpcapi.py的代码。
Nova.conduct.rpcapi.py
def ComputeTaskAPI(self, context, instances, image, filter_properties, admin_password, injected_files, requested_networks, security_groups, block_device_mapping, legacy_bdm=True): image_p = jsonutils.to_primitive(image) cctxt = self.client.prepare(version='1.5') cctxt.cast(context, 'build_instances', instances=instances, image=image_p, filter_properties=filter_properties,
其中，我们可以看出首先创建一个叫cctxt的实例，这个cctxt是rabbitmq提供的client对象，可以通过cctxt.cast（）来进行消息的发送。那么问题来了，这个cctxt是哪里来的？
class ComputeTaskAPI(rpcclient.RpcProxy)：
def __init__(self):
self.client = self.get_client(namespace=self.RPC_API_NAMESPACE)
... ...
父类：nova.rpcclient.py
class RpcProxy(proxy.RpcProxy): def get_client(self, namespace=None, server_params=None): return RPCClient(self, ... ...
返回RPCClient，再看RPCClient类：
class RPCClient(object):
def cast(self, ctxt, method, **kwargs): ... ... return self.proxy.fanout_cast_to_server( ctxt, self.server_params, msg, **kwargs) caster = cast_to_server ... ...
可以看出这个cctxt是RPClient实例，这个RPClient又是怎么实现发送消息呢？
from nova.openstack.common.rpc import proxy
在RPCClient中的初始化构造函数中，我们可以看到：
self.proxy = proxy
可以看出最终是调用nova/openstack/common/rpc/proxy.py中的PRCProxy类(RPCClinet辅助类)来实现发送任务，那么现在看看RpcProxy类，由于发送时通过.cast()方法发送消息的。下面只列出我们用到的cast()方法。
class RpcProxy(object): """A helper class for rpc clients.
... ...
def cast(self, context, msg, topic=None, version=None): self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.cast(context, self._get_topic(topic), msg)
... ...
从这里
from nova.openstack.common import rpc
nova.openstack.common:__init__.py中的cast()方法
def cast(context, topic, msg): return _get_impl().cast(CONF, context, topic, msg)
我们可以看出，最终是通过调用rpc的__init__.py中cast()方法来实现，这个方法返回_get_impl().
_get_impl()
def _get_impl():
... ... impl = CONF.rpc_backend.replace('nova.rpc', 'nova.openstack.common.rpc') _RPCIMPL = importutils.import_module(impl) return _RPCIMPL
这里可以看出，这里load的是CONF.rpc_backend，也就是系统配置的RPC消息的后端。因为我们是通过rabbitmq来实现RPC消息通信，所以系统配置nova.conf文件可以找到rpc_backend = impl_kombu，那么我们就可以找到的Impl_kombu.py的cast()方法。
Nova.openstack.common.rpc. impl_kombu.py
（1步）
def cast(conf, context, topic, msg): """Sends a message on a topic without waiting for a response.""" return rpc_amqp.cast( conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection))
然后通过下面，可以知道又引用了nova/openstack/common/rpc/ampq.py的get_connection_pool():
from nova.openstack.common.rpc import amqp as rpc_amqp
ampq.py中的get_connection_pool()
get_connection_pool(conf, connection_cls): with _pool_create_sem: # Make sure only one thread tries to create the connection pool. if not connection_cls.pool: connection_cls.pool = Pool(conf, connection_cls) return connection_cls.pool
get_connection_pool()就是实现了到RabbitMQ的连接池中获取一个连接。而其中connection_cls传进来的就是类Connection的实例化对象，Connection类就是实现了到RabbitMQ的连接。这里就完成了获取connection链接工作。来看connection：
class Connection(object):
。。。。。。
def cast(conf, context, topic, msg): """Sends a message on a topic without waiting for a response.""" return rpc_amqp.cast( conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection))
这里我们回到1步的.cast（），也就是connection的cast()方法。
nova.openstack.common.rpc.ampq.py
def cast(conf, context, topic, msg, connection_pool): """Sends a message on a topic without waiting for a response.""" LOG.debug(_('Making asynchronous cast on %s...'), topic) _add_unique_id(msg) pack_context(msg, context) with ConnectionContext(conf, connection_pool) as conn: conn.topic_send(topic, rpc_common.serialize_msg(msg))
这里我们会发现最红是调用connection的topic_send()来进行主题模式的发送:
def topic_send(self, topic, msg, timeout=None): """Send a 'topic' message.""" self.publisher_send(TopicPublisher, topic, msg, timeout)
topic_send 中通过.publisher_send()中通过实现发布者类Publish来对消息进行发送。
def publisher_send(self, cls, topic, msg, timeout=None, **kwargs): """Send to a publisher based on the publisher class.""" def _error_callback(exc): log_info = {'topic': topic, 'err_str': str(exc)} LOG.exception(_("Failed to publish message to topic " "'%(topic)s': %(err_str)s") % log_info) def _publish(): publisher = cls(self.conf, self.channel, topic, **kwargs) publisher.send(msg, timeout) self.ensure(_error_callback, _publish)
这个publisher发布者类，是通过传进来的TopicPublisher主题式发布者类进行修饰的，在这个主题式发布者类TopicPublisher实例化时，完成了很多功能：channel的获取，交换器exchange的声明与routing_key的确定、并创建相应的producer等。
接下来通过publisher.send(msg,timeout)将消息进行一定的消息结构封装，并通过routing_key与将消息发送到相应的队列中去。至此我们已经实现了消息的发送操作。流程如下（本图摘自网络）：
接下来看下接收端也就是server端是如何从特定的消息队列发送给自己的消息，并进行具体操作：
我们知道，nova中的各个服务在启动时机会初始化所有自己会用到的队列，并会启动一个绿色线程，不断的检测新的消息的到来，一旦有新的消息，将会由合适的consumer进行读取，并进一步进行消息的解析和执行操作。
下面是usr/bin/nova-scheduler中的启动操作：
import sys from nova.cmd.scheduler importmain
if __name__ == "__main__":
sys.exit(main())
我们可以看出，首先会找到nova/cmd/scheduler.py中的main()函数：
def main(): config.parse_args(sys.argv) logging.setup("nova") utils.monkey_patch() server = service.Service.create(binary='nova-scheduler', topic=CONF.scheduler_topic) service.serve(server) service.wait()
可以看出，这里主要的任务就是创建和启动服务。先看看Service类的静态方法create：
def create(cls, host=None, binary=None, topic=None, manager=None, report_interval=None, periodic_enable=None, periodic_fuzzy_delay=None, periodic_interval_max=None, db_allowed=True): ... ... service_obj = cls(host, binary, topic, manager, report_interval=report_interval, periodic_enable=periodic_enable, periodic_fuzzy_delay=periodic_fuzzy_delay, periodic_interval_max=periodic_interval_max, db_allowed=db_allowed) return service_obj
主要是返回各Service的对象。随后会调用这个service的start()方法。 这个方法主要实现了获取所有服务、创建到RPC的连接，创建不同类型的消息消费者，启动消费者线程用来执行获取的消息，并在启动服务后添加服务到服务成员组等等操作。它其中共创建了两个不同范围的topic消费者及一个广播消费者。然后每个消费都都放置在自己的协程中进行处理。
具体见start()代码：
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) self.manager.pre_start_hook() 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) # 初始化RPC调度器； rpc_dispatcher = self.manager.create_rpc_dispatcher(self.backdoor_port) # Share this same connection for these Consumers # 建立不同的消息消费者； # 创建以服务的topic为路由键的消费者； self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=False) # 创建以服务的topic和本机名为路由键的消费者 node_topic = '%s.%s' % (self.topic, self.host) # 创建以服务的topic和本机名为路由键的消费者（基于topic&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.consume_in_thread() self.manager.post_start_hook() LOG.debug(_("Join ServiceGroup membership for this service %s") % self.topic) # Add service to the ServiceGroup membership group. self.servicegroup_api.join(self.host, self.topic, self) if self.periodic_enable: if self.periodic_fuzzy_delay: initial_delay = random.randint(0, self.periodic_fuzzy_delay) else: initial_delay = None self.tg.add_dynamic_timer(self.periodic_tasks, initial_delay=initial_delay, periodic_interval_max=self.periodic_interval_max)
协程这里不花太多的时间来研究。这里我们分析下：self.conn = rpc.create_connection()
,这个的作用就是建立一个connection的链接，完成接收的第一步。
接下来会创建消费者cusumer，也是在connection类中的create_consumer()方法中完成的。
def create_consumer(self, topic, proxy, fanout=False): """Create a consumer that calls a method in a proxy object.""" proxy_cb = rpc_amqp.ProxyCallback( self.conf, proxy, rpc_amqp.get_connection_pool(self.conf, Connection)) self.proxy_callbacks.append(proxy_cb) if fanout: self.declare_fanout_consumer(topic, proxy_cb) else: self.declare_topic_consumer(topic, proxy_cb)
完成了建立一个主题式的消息消费者的工作。
def declare_topic_consumer(self, topic, callback=None, queue_name=None, exchange_name=None, ack_on_error=True): """Create a 'topic' consumer.""" self.declare_consumer(functools.partial(TopicConsumer, name=queue_name, exchange_name=exchange_name, ack_on_error=ack_on_error, ), topic, callback)
看下declare_topic_consumer():
def declare_consumer(self, consumer_cls, topic, callback): """Create a Consumer using the class that was passed in and add it to our list of 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 = consumer_cls(self.conf, self.channel, topic, callback, self.consumer_num.next()) self.consumers.append(consumer) return consumer
这里其实是实例化了一个TopicConsumer进行初始化，并获取其实例化对象consumer，再把建立好的消费者对象加入到consumers列表中然后返回，等待dispatch接收到后来调用。
这个消费者Cusumer在建立过程中，经过TopicConsumer的实例以及其父类ConsumerBase一系列的操作实现exchange以及queue的声明、创建与绑定，最终完成得到这个主题式消费者。
下面看下协程的处理：
self.conn.consume_in_thread()
def consume_in_thread(self): """Consumer from all queues/consumers in a greenthread.""" @excutils.forever_retry_uncaught_exceptions def _consumer_thread(): try: self.consume() except greenlet.GreenletExit: return if self.consumer_thread is None: self.consumer_thread = eventlet.spawn(_consumer_thread) return self.consumer_thread
协程相关的代码与我们理解rabbitmq关系不大，就先不去深追，感兴趣的话，推荐博客：
http://blog.csdn.net/gaoxingnengjisuan/article/details/12234079
我们只需知道，最终会通过ConsumerBase的message = self.receiver.fetch()接受消息，并调用start()方法中的rpc_dispatcher实例，来对消息进行分发，调用相关的方法去解决。
参考文档：
http://www.cnblogs.com/popsuper1982/p/3800396.html
http://blog.csdn.net/tantexian/article/details/44804329http://blog.csdn.net/gaoxingnengjisuan/article/details/9623529
http://www.aboutyun.com/thread-11230-1-1.html
http://lynnkong.iteye.com/blog/1699299
http://blog.sina.com.cn/s/blog_66ca40550101l3vm.html
http://m.blog.csdn.net/blog/z_lstone/14165777
http://bingotree.cn/?p=207