Question

对于服务器自动化，我们正在尝试开发一种工具，该工具可以在不同的服务器上处理和执行许多任务。我们将任务和服务器主机名发送到队列中。然后从请求者使用队列，该请求者将信息提供给ansible api。为了实现这一点，我们可以一次执行多个任务，我们正在使用线程。

现在我们一直坚持对消息的承认......

到目前为止我们做了什么：
requester.py使用队列并启动一个线程，其中正在运行ansible任务。然后将结果发送到另一个队列。因此每个新消息都会创建一个新线程。任务完成后，线程就会死掉但现在变得困难了。我们必须使消息持久化，以防我们的服务器死亡。所以每个消息都应该在之后被确认来自ansible的结果被回复。

现在我们的问题是，当我们尝试在线程本身中确认消息时，不再有＆＃34;同时＆＃34;完成工作，因为pika的consume等待承认。那么我们如何实现，consume消费消息而不等待确认？或者我们如何解决或改进我们的小程序？

requester.py

  #!/bin/python

  from worker import *
  import ansible.inventory
  import ansible.runner
  import threading

  class Requester(Worker):
      def __init__(self):
          Worker.__init__(self)
          self.connection(self.selfhost, self.from_db)
          self.receive(self.from_db)

      def send(self, result, ch, method):
          self.channel.basic_publish(exchange='',
                                     routing_key=self.to_db,
                                     body=result,
                                     properties=pika.BasicProperties(
                                                     delivery_mode=2,
                                     ))

          print "[x] Sent \n" + result
          ch.basic_ack(delivery_tag = method.delivery_tag)

      def callAnsible(self, cmd, ch, method):
          #call ansible api pre 2.0

          result =  json.dumps(result, sort_keys=True, indent=4, separators=(',', ': '))
          self.send(result, ch, method)

      def callback(self, ch, method, properties, body):
          print(" [x] Received by requester %r" % body)
          t = threading.Thread(target=self.callAnsible, args=(body,ch,method,))
          t.start()

worker.py

  import pika
  import ConfigParser
  import json
  import os

  class Worker(object):
      def __init__(self):
          #read some config files

      def callback(self, ch, method, properties, body):
          raise Exception("Call method in subclass")

      def receive(self, queue):
          self.channel.basic_qos(prefetch_count=1)
          self.channel.basic_consume(self.callback,queue=queue)
          self.channel.start_consuming()

      def connection(self,server,queue):
          self.connection = pika.BlockingConnection(pika.ConnectionParameters(
                 host=server,
                 credentials=self.credentials))
          self.channel = self.connection.channel()
          self.channel.queue_declare(queue=queue, durable=True)

我们正在使用Python 2.7和pika 0.10.0。

是的，我们在pika FAQ中注意到：http://pika.readthedocs.io/en/0.10.0/faq.html
那种鼠兔不是线程安全的。

Answer 1

禁用自动确认并将预取计数设置为大于1的值，具体取决于您希望消费者接收的消息数量。

以下是设置预取的方法 channel.basic_qos(prefetch_count=1)，找到here。

Pika：即使最后一条消息未被确认，也要接收下一条消息

1 个答案: