RabbitMQ学习笔记(五)

远程调用(RPC)

ps: 使用pika
以前的笔记中，已经知道如何使用工作队列，在多个工作者Worker中分发耗时任务。
但是有时候我们可能遇到这样的情况，我们将一个函数运行在远程计算机上，然后另一个计算机等待从remote Computer上获取运行的结果，该怎么办？这种模式通常叫做远程过程调用(Remote Procedure Call)就是RPC。

客户端接口

为了展示PRC服务的使用，我们创建一个简单的客户顿类。它暴露出一个名为call()的方法用来发送一个RPC请求，并且在收到回应前保持阻塞。

fibonacci_rpc = FibonacciPrcClient()
result = fibonacci_rpc .call(4)
print " fib(4) is %r" % (result, )

回调队列

RabbbitMQ实现RPC是很容易的，一个客户端发送来请求信息，服务端将应用到一个回复信息中。为了接受到回复信息，客户端需要在发送请求的时候同时发送一个回调队列(callback queue)的地址。

result = channel.queue_declare(exclusive=True)
callback_queue = result.method.queue

channel.basic_publish(exchange='',
                      routing_key='rpc_queue',
                      properties=pika.BasicProperties(
                            reply_to = callback_queue,
                            ),
                      body=request)

消息属性

AMQP协议给消息定义了一系列的属性，常用的属性有：

• delivery_mode（投递模式）：将消息标记为持久的（值为2）或暂存的（除了2之外的其他任何值）。第二篇教程里接触过这个属性，记得吧？
• content_type（内容类型）:用来描述编码的mime-type。例如在实际使用中常常使用application/json来描述JOSN编码类型。
• reply_to（回复目标）：通常用来命名回调队列。
• correlation_id（关联标识）：用来将RPC的响应和请求关联起来

关联标识

在每一个RPC请求都创建一个回调队列，这样如果请求数量多大导致系统内队列过多，造成性能下降，所以更好的方法就是为每一个客户端只创建一个独立回调队列。
但是有一个问题就是，一个客户端可能发送很多个请求，服务端处理完后怎么知道把相应发送给那个请求呢？correlation_id可以解决这个问题，相当于就是每一个请求会有有一个独一无二的值标识，当相应时，会匹配这个独一无二的值，将相应发送到指定的请求。

总结

如何工作

• 客户端启动的时候，会创建一个回调队列(可以使用匿名队列)。
• 在发送RPC请求时，客户端发送带有两个属性的消息，一个设置回调队列的reply_to属性，另一个设置唯一值correlation_id属性.
• 将请求发送到一个rpc_queue 队列中。
• RPC工作者(服务器)等待请求发送到这个队列中，然后获取请求并执行，将执行的结果发送到reply_to指定的队列中。
• 客户端等待回调队列中的数据，并检查correlation_id属性，如果属性匹配就将数据取走。

代码

rpc_server.py

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))

channel = connection.channel()

channel.queue_declare(queue='rpc_queue')

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

def on_request(ch, method, props, body):
    n = int(body)

    print " [.] fib(%s)"  % (n,)
    response = fib(n)

    ch.basic_publish(exchange='',
                     routing_key=props.reply_to,
                     properties=pika.BasicProperties(correlation_id = \
                                                     props.correlation_id),
                     body=str(response))
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(on_request, queue='rpc_queue')

print " [x] Awaiting RPC requests"
channel.start_consuming()

解释

• 我们先创建连接，声明队列。
• 声明fibonacci函数，在输入一个合法的值返回一个结果，但是递归不能太深。
• 为 basic_consume 声明了一个回调函数，这也是RPC设计的核心，它主要是执行任务并产生相应。

rpc_client.py

import pika
import uuid

class FibonacciRpcClient(object):
    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(
                host='localhost'))

        self.channel = self.connection.channel()

        result = self.channel.queue_declare(exclusive=True)
        self.callback_queue = result.method.queue

        self.channel.basic_consume(self.on_response, no_ack=True,
                                   queue=self.callback_queue)

    def on_response(self, ch, method, props, body):
        if self.corr_id == props.correlation_id:
            self.response = body

    def call(self, n):
        self.response = None
        self.corr_id = str(uuid.uuid4())
        self.channel.basic_publish(exchange='',
                                   routing_key='rpc_queue',
                                   properties=pika.BasicProperties(
                                         reply_to = self.callback_queue,
                                         correlation_id = self.corr_id,
                                         ),
                                   body=str(n))
        while self.response is None:
            self.connection.process_data_events()
        return int(self.response)

fibonacci_rpc = FibonacciRpcClient()

print " [x] Requesting fib(30)"
response = fibonacci_rpc.call(30)
print " [.] Got %r" % (response,)

解释

• 创建连接、并声明独享的回调队列
• 订阅这个回调队列，便于接受RPC相应。
• “on_response”回调函数对每一个响应执行一个非常简单的操作，检查每一个响应消息的correlation_id属性是否与我们期待的一致，如果一致，将响应结果赋给self.response，然后跳出consuming循环。
• 我们定义我们的主要方法 call 方法。它执行真正的RPC请求。
• 在这个方法中，首先我们生成一个唯一的 correlation_id 值并且保存起来，'on_response'回调函数会用它来获取符合要求的响应。
• 接下来，我们将带有 reply_to 和 correlation_id 属性的消息发布出去。
• 现在我们可以坐下来，等待正确的响应到来。
• 最后，我们将响应返回给用户。