class Rabbit_send(object):
def __init__(self):
self.__rabbit = Rabbit(host="localhost")
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.__rabbit.close()
def simple_mode(self, body, queue_name="simple", is_msg_durable=False):
self.__rabbit.declare_queue(queue_name=queue_name,
durable=is_msg_durable) # 队列持久化
self.__rabbit.publish(body=str(body),
exchange_name="",
routing_key=queue_name,
is_msg_durable=is_msg_durable) #消息持久化
def fanout_mode(self, body, exchange_name):
self.__rabbit.declare_exchange(exchange_name=exchange_name,
exchange_type="fanout")
self.__rabbit.publish(body=str(body),
routing_key="",
exchange_name=exchange_name)
def direct_mode(self, body, exchange_name, routing_key):
self.__rabbit.declare_exchange(exchange_name=exchange_name,
exchange_type="direct")
self.__rabbit.publish(body=str(body),
exchange_name=exchange_name,
routing_key=routing_key)
def rpc_mode(self, callback=None):
result = self.__rabbit.declare_queue_exclusive()
self.callback_queue = result.method.queue
receive_callback = callback if callback is not None else self.on_rpc_response
self.__rabbit.consume(receive_callback,
queue_name=self.callback_queue,
no_ack=True)
def on_rpc_response(self, ch, method, props, body):
if self.corr_id == props.correlation_id:
self.__rabbit.response = body
def rpc_call(self, body, routing_key="rpc_queue"):
self.corr_id = str(uuid.uuid4())
return self.__rabbit.call(self.corr_id,
self.callback_queue,
body,
routing_key=routing_key)
class RpcClient(object):
def __init__(self, routing_key, host="localhost"):
# routing_key - 'rpc_queue'
self.routing_key = routing_key
self.rabbit = Rabbit(host)
# 队列名，随机
self.callback_queue_name = self.rabbit.declare_queue(exclusive=True)
self.rabbit.register_consumer(queue_name=self.callback_queue_name, callback=self.on_response)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.rabbit.close()
def on_response(self, ch, method, props, body):
"""
收到消息就调用
:param ch: 管道内存对象地址
:param method: 消息发给哪个queue
:param props:
:param body: 数据对象
:return:
"""
# 判断本机生成的ID与生产端发过来的ID是否相等
if self.corr_id == props.correlation_id:
# 将body值 赋值给self.response
self.response = body
def call(self, msg):
"""
发送dict
:param msg:
:type msg: dict
:return: dict
"""
# 随机的字符串
self.response = None
self.corr_id = str(uuid.uuid4())
# routing_key='rpc_queue' 发一个消息到rpc_queue内
self.rabbit.channel.basic_publish(exchange='',
routing_key=self.routing_key,
properties=pika.BasicProperties(
# 执行命令之后消费端将结果返回给self.callaback_queue这个队列中
reply_to=self.callback_queue_name,
# 生成UUID 发送给消费端
correlation_id=self.corr_id,
),
# 发的消息，必须传入字符串，不能传数字
body=json.dumps(msg))
# 监听数据
while self.response is None:
# 没有消息不阻塞
self.rabbit.conn.process_data_events()
return json.loads(str(self.response, encoding="utf-8"))
class Rabbit_receive(object):
def __init__(self):
self.__rabbit = Rabbit(host="localhost")
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.__rabbit.close()
def simple_mode(self, callback=None, queue_name="simple", durable=False):
self.__rabbit.declare_queue(queue_name=queue_name, durable=durable)
receive_callback = callback if callback is not None else self.on_simple_mode_callback
self.__rabbit.consume(receive_callback,
queue_name=queue_name,
no_ack=True)
self.__rabbit.start()
def on_simple_mode_callback(self, ch, method, properties, body):
print(" [x] Received %r" % body)
def fanout_mode(self, callback=None, exchange_name="logs"):
self.__rabbit.declare_exchange(exchange_name=exchange_name)
result = self.__rabbit.declare_queue_exclusive()
queue_name = result.method.queue
self.__rabbit.bind(exchange=exchange_name, queue_name=queue_name)
receive_callback = callback if callback is not None else self.on_simple_mode_callback
self.__rabbit.consume(receive_callback,
queue_name=queue_name,
no_ack=True)
self.__rabbit.start()
def direct_mode(self,
callback=None,
exchange_name="direct_logs",
binding_keys=[]):
self.__rabbit.declare_exchange(exchange_name=exchange_name,
exchange_type="direct")
result = self.__rabbit.declare_queue_exclusive()
queue_name = result.method.queue
for binding_key in binding_keys:
self.__rabbit.bind(exchange=exchange_name,
queue_name=queue_name,
routing_key=binding_key)
receive_callback = callback if callback is not None else self.on_simple_mode_callback
self.__rabbit.consume(receive_callback,
queue_name=queue_name,
no_ack=True)
self.__rabbit.start()
def rpc_mode(self, callback=None, queue_name="rpc_queue"):
self.__rabbit.declare_queue(queue_name=queue_name)
self.__rabbit.qos()
receive_callback = callback if callback is not None else self.on_rpc_mode_callback
self.__rabbit.consume(receive_callback, queue_name=queue_name)
self.__rabbit.start()
def on_rpc_mode_callback(self, ch, method, props, body):
print(" [.] received one msg (%s)" % body)
response = body
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)
def receive_msg(self):
rabbit = Rabbit()
rabbit.declare_queue("algorithm", durable=True)
rabbit.register_consumer(queue_name="algorithm", callback=self.callback, no_ack=False)
rabbit.start_consuming()
def consume_from_rmq(self):
rabbit = Rabbit()
rabbit.declare_queue("algorithm", durable=True)
rabbit.register_consumer(queue_name="algorithm", callback=self.algorithmCallback, no_ack=False)
rabbit.start_consuming()
from rabbit import Rabbit
import json
if __name__ == '__main__':
rabbit = Rabbit()
rabbit.declare_queue("queue_test", durable=True)
test_data = {
'action': 'launch',
'owner': 'aiur_system',
'eval_info': {
'name': '【测试数据】视频-视频黑白边检测模型评测任务',
'model': '003',
'desc': 'today is friday',
'sample_pattern': '',
'num': '200',
'extra': {
'source': 'commercialization'
}
}
}
for i in range(10000):
temp = json.dumps(test_data)
rabbit.produce(f'{i}: {temp}', "queue_test")
rabbit.close()
