python--基于RabbitMQ rpc实现的主机管理

要求：

可以异步的执行多个命令
对多台机器
>>:run "df -h" --hosts 192.168.3.55 10.4.3.4
task id: 45334
>>: check_task 45334
>>:

思考：
1、分解其中需要实现的功能
（1）命令是发到远程主机上执行的，命令放在队列里，再发到主机处理，主机执行完结果放在队列里，提交命令的人自取。
就需要2个进程，一个client，提交命令，取结果，一个server，处理命令，放结果
（2）发送命令的时候，exchange决定往哪个队列放消息，每个server取自己的命令，用ip作为筛选的binding_key
（3）取结果的时候，就用默认的exchange，直接往reply_to的队列里放

server端

#rabbitMQserver='10.21.147.189'
rabbitMQserver='localhost'

import pika
import os
import socket

class server(object):
    def __init__(self):
        self.connection=pika.BlockingConnection(pika.ConnectionParameters(rabbitMQserver))
        self.channel=self.connection.channel()
        self.channel.exchange_declare(exchange='cmd',exchange_type='topic')
        self.queue_default = self.channel.queue_declare(exclusive=True)
        self.quname = self.queue_default.method.queue
        # 获取本机ip作为binding_key，binding_key的格式是以点分隔的一系列字符串，client发过来的消息，routing_key满足server的binding_key匹配原则，就会加入server连的那个queue
        self.hostip=socket.gethostbyname(socket.gethostname())
        self.binding_key='#.'+self.hostip+'.#'
        print("binding_key: %s" % self.binding_key)
        self.channel.queue_bind(queue=self.quname, exchange='cmd', routing_key=self.binding_key)
        self.channel.basic_qos(prefetch_count=1)

        self.channel.basic_consume(self.execcmd,queue=self.quname,no_ack=False)
        self.channel.start_consuming()
        return

    def execcmd(self,ch,method,props,body):
        cmd=bytes.decode(body)
        print("[*] Received %s" % cmd)
        result = os.popen(cmd).read()
        print(result)
        ch.basic_publish(
            exchange='',
            routing_key=props.reply_to,
            properties=pika.BasicProperties(
                correlation_id=props.correlation_id
            ),
            body=result
        )
        ch.basic_ack(delivery_tag=method.delivery_tag)
        return

se=server()

 

client端

import pika
import uuid

#rabbitMQserver='10.21.147.189'
rabbitMQserver='localhost'

class client(object):
    def __init__(self):
        self.cmdid={}
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(rabbitMQserver))
        self.channel = self.connection.channel()
        self.channel.exchange_declare(exchange='cmd', exchange_type='topic')

        #回写result的队列用默认生成的，需要取得名字,exclusive定为True表示只能有本client消费这个queue
        self.result=self.channel.queue_declare(exclusive=True)
        self.resultqueue=self.result.method.queue
        return

    def showcmdid(self):
        print("-----命令标识如下：--------")
        for id,hosts in self.cmdid.items():
            print("cmdid:%s run on hosts: %s"%(id,hosts))
        return

    def callcmd(self,cmdinput):
        #如果是call命令，格式是 call+"命令"+ --host + 一串ip地址
        #首先判断格式对不对，至少4个参数
        msglist=cmdinput.split()
        argnum=len(msglist)
        if argnum<4:
            print("Wrong cmd. Input again.")
            return
        #其次，命令是第二个参数，命令用双引号标记，所以要strip
        msg = msglist[1].strip("\"")
        #然后，第三个是--host，第四个开始是ip，ip当作routing_key
        routing_key=msglist[3]
        i=4
        while i < argnum:
            routing_key=routing_key+'.'+msglist[i]
            i+=1
        print("routing_key: %s"%routing_key)
        #再然后，生成一个随机数，把他作为消息的属性参数
        self.corr_id=str(uuid.uuid4())
        self.cmdid[self.corr_id]=msglist[3:]
        print("命令标识：%s"%self.corr_id)
        #然后，把消息发到exchange，routing_key，corr_id当作参数发布
        self.channel.basic_publish(
            exchange='cmd',
            routing_key=routing_key,
            body=msg,
            properties=pika.BasicProperties(
                reply_to=self.resultqueue,
                correlation_id=self.corr_id
            )
        )
        print("[*] Send message %s" % msg)
        return

    def on_response(self,ch,method,props,body):
        if self.targetcmdid==props.correlation_id:
            self.response=bytes.decode(body)
            print(self.response)
        ch.basic_ack(delivery_tag=method.delivery_tag)
        return

    def getres(self,cmdinput):
        msglist = cmdinput.split()
        self.targetcmdid=msglist[1]
        self.response=None
        self.channel.basic_consume(self.on_response,queue=self.resultqueue)
        while self.response is None:
            self.connection.process_data_events()
        return

cl=client()
while True:
    msginput=input(">>: ").strip()
    if msginput.startswith('call'):
        cl.callcmd(msginput)
    elif msginput.startswith('get'):
        cl.getres(msginput)
    elif msginput.startswith('show'):
        cl.showcmdid()
    elif msginput.startswith('exit'):
        cl.connection.close()
        exit(0)
    else:
        print("Wrong cmd. Input again.")
        continue

目前没有验证远程登陆rabbitMQ server的情况，应该是需要配置用户名密码，不能用默认的guest/guest。不过以上功能是实现了。