基于RabbitMQ rpc实现的主机管理

可以对指定机器异步的执行多个命令
    例子：
    >>:run "df -h" --hosts 192.168.3.55 10.4.3.4 
        task id: 45334
    >>: check_task 45334 
    >>:
    注意，每执行一条命令，即立刻生成一个任务ID,不需等待结果返回，通过命令check_task TASK_ID来得到任务结果

 

基于rabbitmq的rpc，输入执行命令，直接返回ID，进入到rpc中，通过指定的IP地址建立socket，建立queue（“rpc”） 然后执行命令，返回结果，返回的结果和id组成字典，输入ID就可以查看结果

测试：在windows下
备注：本实验在windows下进行的所以在执行命令是要使用windows的命令

 

 

import pika
import subprocess

connection =pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
channel = connection.channel()
channel.queue_declare(queue="rpc")

def command(cmd):
    res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    # print(res)
    msg = res.stdout.read().decode("gbk")
    print(msg)
    return msg

def on_request(ch,method,props,body):
    cmd = body.decode()
    response = command(cmd)
    ch.basic_publish(exchange="",
                     routing_key=props.reply_to,
                     properties=pika.BasicProperties(correlation_id=props.correlation_id),
                     body=response
                     )
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(on_request,queue="rpc")
print("Waiting RPC requests")
channel.start_consuming()

import pika
import uuid
import random

class Client(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,command,host):
        self.response = None
        self.corr_id = str(uuid.uuid4())
        self.channel.basic_publish(exchange="",
                                   routing_key="rpc",
                                   properties=pika.BasicProperties(reply_to=self.callback_queue,correlation_id=self.corr_id,),
                                   body=str(command)
                                   )
        while self.response is None:
            self.connection.process_data_events()

        self.corr_id = random.randint(10000,99999)
        id = self.corr_id
        res = self.response.decode()
        dict[id] =res
        print('task_id: %s host: %s cmd: %s ' % (self.corr_id, host, command))
        return self.corr_id, self.response.decode()

def help():
    print("run 'df -h' --hosts 127.0.0.1  10.10.10.1")
    print("check_task id")
    print("check_task_all")

def start(command_input):
    command_list = command_input.split()
    if command_list[0]== "run":
        try:
            obj = command_input.split("run")
            host_obj =obj[1].split("--hosts")
            hosts = host_obj[1].strip().split()
            command= command_input.split("\"")[1]
            for host in hosts:
                try:
                    rpc_client.call(command,host)
                except TypeError and AssertionError:
                    break
        except IndexError:
            print('-bash: %s command not found' % command_input)
            help()
    elif command_list[0] =="check_task":
        try:
            print(dict[int(command_list[1])])
        except IndexError:
            help()
    elif command_list[0] =="check_task_all":
        for index, key in enumerate(dict.keys()):
            print(index,key)
    elif command_list[0]=="help":
        help()
    else:
        print('-bash: %s command not found' % command_input)
        help()


rpc_client = Client()
dict={}
help()
while True:
    command_input =input("请输入命令>>>:").strip()
    if len(command_input)==0:
        continue
    else:
        start(command_input)