OpenStack之RPC调用（一）
关于OpenStack中基于RESTFul API的通信方式主要是应用了WSGI，我会在以后的博文中详细讨论。这里主要还是分享一下关于RPC调用的一些理解。
首先，什么是RPC呢？百度百科给出的解释是这样的：“RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议”。这个概念听起来还是比较抽象，下面我会结合OpenStack中RPC调用的具体应用来具体分析一下这个协议。
其次，为什么要采用RPC呢？单纯的依靠RESTFul API不可以吗？其实原因有下面这几个：
1. 由于RESTFul API是基于HTTP协议的，因此客户端与服务端之间所能传输的消息仅限于文本
2. RESTFul API客户端与服务端之间采用的是同步机制，当发送HTTP请求时，客户端需要等待服务端的响应。当然对于这一点是可以通过一些技术来实现异步的机制的
3. 采用RESTFul API，客户端与服务端之间虽然可以独立开发，但还是存在耦合。比如，客户端在发送请求的时，必须知道服务器的地址，且必须保证服务器正常工作
基于上面这几个原因，所以OpenStack才采用了另一种远程通信机制，这就是我们今天要讨论的鼎鼎大名的RPC。
要了解OpenStack中的RPC，有一个组件是必不可少的，那就是RabbitMQ（消息队列）。OpenStack中，RPC采用AMQP协议实现进程间通信，而RabbitMQ正是AMQP的实现方式，所以可以说OpenStack中的RPC调用都是基于RabbitMq完成的（注：有关AMQP、RabbitMQ的一些知识，可以参看我上篇分享的文章——《兔子与兔子洞》）。
在Nova中，定义了两种远程调用方式——rpc.call和rpc.cast。其中rpc.call方式是指request/response（请求/响应）模式，即客户端在发送请求后，继续等待服务器端的响应结果，待响应结果到达后，才结束整个过程。rpc.cast方式是指客户端发送RPC调用请求后，不等待服务器端的响应结果。不难看出，较rpc.cast模式，rpc.call更为复杂。为了处理rpc.call，Nova采用了Topic Exchange（主题交换器）和Direct Exchange（直接交换器）两种消息交换器。其中Topic Exchange用于客户端向服务器端rpc.call的发起，Direct Exchange用于服务器端向客户端返回rpc.call。对应于这两种交换机，Nova中定义了Topic/Direct消息消费者、Topic/Direct消息发布者、Topic/Direct交换器。各部件如下图所示：
需要说明的是一个主题交换器可以关联多个队列，而一个直接交换器只能关联一个队列。
结合rpc.call代码实例，开始我们的分析吧，代码结构如下：
client.py——RPC调用请求客户端启动脚本
dispatcher.py——将客户端发布的消息分发给相应的方法处理
impl_kombu.py——核心代码，实现了消费者、生产者、建立连接等操作
manager.py——定义处理RPC请求的方法
rpc_amqp.py——发送RPC请求和发生RPC响应
rpc.py——为外部提供访问API
server.py——服务器端启动脚本
service.py——创建和管理RPC服务
接下来看一下rpc.call执行的流程：
1). RPC服务器端定义并启动RPC服务
2). RPC服务器端建立和RabbitMQ服务器的连接
3). RPC服务器端创建和激活主题消费者
4). RPC客户端向主题交换器发送RPC请求
5). RPC服务器端接收和处理RPC请求
6). RPC客户端创建和激活直接消费者
7). RPC服务器端向直接交换机发送RPC响应
1. 服务器端：定义和启动RPC服务
server.py
import service
srv = service.Service() #创建RPC服务
srv.start() #启动RPC服务
while True:
srv.drain_events() #监听RPC请求service.py
import rpc
import manager
import dispatcher
TOPIC = 'sendout_request'
class Service(object):
def __init__(self):
self.topic = TOPIC
self.manager = manager.Manager()
def start(self):
self.conn = rpc.create_connection()
rpc_dispatcher = dispatcher.RpcDispatcher(self.manager)
self.conn.create_consumer(self.topic, rpc_dispatcher)
self.conn.consume()
def drain_events(self):
self.conn.drain_events()Service类中包含init、start、drain_events三个方法。
2. 服务器端：建立与RabbitMQ的连接
Service类调用rpc.crerate_connection方法来建立连接。该方法会返回一个Connection对象。Connection对象的定义在impl_kombu.py文件中。
impl_kombu.py
class Connection(object):
def __init__(self):
self.consumers = []
self.connection = None
self.reconnect()
def reconnect(self):
#初次重连的等待时间
sleep_time = conf.get('interval_start', 1)
#每次连接失败后增加的等待时间
stepping = conf.get('interval_stepping', 2)
#重连的最大等待时间
interval_max = conf.get('interval_max', 30)
sleep_time -= stepping
while True:
try:
self._connect()
return
except Exception, e:
if 'timeout' not in str(e):
raise
sleep_time += stepping
sleep_time = min(sleep_time, interval_max)
print("AMQP Server is unreachable,"
"trying to connect %d seconds later\n" % sleep_time)
time.sleep(sleep_time) def _connect(self):
hostname = rabbit_params.get('hostname')
port = rabbit_params.get('port')
if self.connection: #如果已有连接，释放原有连接
print("Reconnecting to AMQP Server on "
"%(hostname)s:%(port)d\n" % locals())
self.connection.release()
self.connection = None
self.connection = kombu.connection.BrokerConnection(**rabbit_params)
self.consumer_num = itertools.count(1) #消费者迭代器，产生消费者唯一的标识
self.connection.connect() #建立与RabbitMQ的连接
self.channel = self.connection.channel() #获取连接的通道
for consumer in self.consumers:
consumer.reconnect(self.channel)Connection类的初始化方法比较简单，主要是调用reconnect方法。reconnect方法会不断尝试与RabbitMQ建立连接。_connect方法实现真正的连接的建立。
3. 服务器端：创建和激活主题消费者
（1）Service类通过Connection类的create_consumer方法创建消费者
impl_kombu.py
class Connection(object):
def create_consumer(self, topic, proxy):
proxy_cb = rpc_amqp.ProxyCallback(proxy)
self.declare_topic_consumer(topic, proxy_cb)
def declare_topic_consumer(self, topic, callback):
print('declaring topic consumer for topic %s...\n' % topic)
self.declare_consumer(TopicConsumer, topic, callback)
def declare_consumer(self, consumer_cls, topic, callback):
def _declare_consumer():
consumer = consumer_cls(self.channel,topic, callback,self.consumer_num.next())
self.consumers.append(consumer)
print('Succed declaring consumer for topic %s\n' % topic)
return consumer
return self.ensure(_declare_consumer, topic)
def ensure(self, method, topic):
while True:
try:
return method()
except Exception, e:
if 'timeout' not in str(e):
raise
print('Failed to declare consumer for topic %s: '
'%s\n' % (topic, str(e)))
self.reconnect()
impl_kombu.py
class TopicConsumer(ConsumerBase):
def __init__(self, channel, topic, callback, tag, **kwargs):
self.topic = topic
options = {'durable': False,
'auto_delete': False,
'exclusive': False}
options.update(kwargs)
exchange = kombu.entity.Exchange(name=topic,
type='topic',
durable=options['durable'],
auto_delete=options['auto_delete'])
super(TopicConsumer, self).__init__(channel,
callback,
tag,
name=topic,
exchange=exchange,
routing_key=topic,
**options)impl_kombu.py
class ConsumerBase(object):
def __init__(self, channel, callback, tag, **kwargs):
self.callback = callback
self.tag = str(tag)
self.kwargs = kwargs
self.queue = None
self.reconnect(channel)
def reconnect(self, channel):
self.channel = channel
self.kwargs['channel'] = channel
self.queue = kombu.entity.Queue(**self.kwargs)
self.queue.declare()
（2）激活消费者
Service类通过Connection类的consume方法激活消费者。Connection类的consume方法最终会调用ConsumerBase类的consume方法。
impl_kombu.py
class ConsumerBase(object):
def consume(self, *args, **kwargs):
options = {'consumer_tag': self.tag}
options['nowait'] = False
def _callback(raw_message):
message = self.channel.message_to_python(raw_message)
try:
msg = message.payload #获取消息体
self.callback(msg) #处理消息
message.ack() #通知交换器消息处理完毕
except Exception:
print("Failed to process message... skipping it.\n")
self.queue.consume(*args, callback=_callback, **options) #激活消费者主要定义了_callback方法，分发和处理RPC请求。
至此服务器端的工作暂时告一段落，下一篇博文来我们再来分析下客户端的工作和服务器端的后续接收和处理RPC请求的工作。