day11-RPC

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

server 

import pika
import paramiko,os,

class Server(object):
    def __init__(self,rabbitmq,queue_name):
        self.queue_name = queue_name
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(
            host=rabbitmq))
        self.channel = self.connection.channel()
        self.channel.queue_declare(queue=self.queue_name)

    def handle(self,cmd,host):

        #print(cmd,host)
        message = self.paramiko_ex(cmd,host)
        if not message:
            message = "Wrong Command"
        return message

    def paramiko_ex(self,command,host):
        transport =paramiko.Transport((host,22))
        transport.connect(username="root",password="cdw123") #用户密码简单写死，可以扩展类别根据IP 判断用户，密码。
        ssh=paramiko.SSHClient()
        ssh._transport = transport
        stdin,stdout,stderr = ssh.exec_command(command)
        #print(stdout.read().decode())
        ack_msg=stdout.read().decode()
        #print(ack_msg)
        transport.close()
        return ack_msg

    def on_request(self,ch, method, props, body):
        #print(body,type(body))
        body=body.decode()
        body=body.split("_")
        cmd,host=body[0],body[1]
        #print(cmd,host)
        response = self.handle(cmd,host)
        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 start(self):
        self.channel.basic_consume(self.on_request,
                                   queue=self.queue_name)

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


if __name__ == "__main__":
    rabbitmq = "localhost"      #rabbitmq服务器地址
    queue_name = "rpc_5"
    server = Server(rabbitmq,queue_name)
    server.start()

client

import pika,random,uuid,threading


class Client(object):
    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(
            host="localhost"))
        self.channel = self.connection.channel()

    def on_response(self, ch, method, props, body):
        '''获取命令执行结果的回调函数'''
        # print("验证码核对",self.callback_id,props.correlation_id)
        if self.callback_id == props.correlation_id:  # 验证码核对
            self.response = body
        ch.basic_ack(delivery_tag=method.delivery_tag)

    def get_response(self,callback_queue,callback_id):
        '''取队列里的值，获取callback_queued的执行结果'''
        self.callback_id = callback_id
        self.response = None
        self.channel.basic_consume(self.on_response,  # 只要收到消息就执行on_response
                                   queue=callback_queue)
        while self.response is None:
            self.connection.process_data_events()  # 非阻塞版的start_consuming
        return self.response

    def call(self,host,command):
        '''队列里发送数据'''

        result = self.channel.queue_declare(exclusive=False) #exclusive=False 必须这样写
        self.callback_queue = result.method.queue
        self.corr_id = str(uuid.uuid4())
        # print(self.corr_id)
        self.channel.basic_publish(exchange='',
                                   routing_key="rpc_5",
                                   properties=pika.BasicProperties(
                                       reply_to=self.callback_queue,  # 发送返回信息的队列name
                                       correlation_id=self.corr_id,  # 发送uuid 相当于验证码
                                   ),
                                   body=command+"_"+host) #组合命令，跟主机IP发给server

        return self.callback_queue,self.corr_id




class Handler(object):
    def __init__(self):
        self.information = {}   # 后台进程信息
    def check_all(self,*args):
        '''查看所有task_id信息'''

        for key in self.information:
            print("TASK_ID【%s】\tHOST【%s】\tCOMMAND【%s】"%(key,self.information[key][0],
                                                                    self.information[key][1]))

    def check_task(self,user_cmd):
        '''查看task_id执行结果'''

        try:
            task_id = user_cmd.split()[1]
            task_id = int(task_id)
            callback_queue=self.information[task_id][2]
            callback_id=self.information[task_id][3]
            client = Client()
            response = client.get_response(callback_queue, callback_id)
            print(response.decode())
            del self.information[task_id]

        except KeyError  as e :
            print("\33[31;0mWrong id[%s]\33[0m"%e)
        except IndexError as e:
            print("\33[31;0mWrong id[%s]\33[0m"%e)

    def run(self,user_cmd):
        '''执行命令'''
        try:
            #time.sleep(2)
            #print("--->>",user_cmd)
            #print(user_cmd)
            command = user_cmd.split("\"")[1]
            #print(user_cmd.split()[4:])
            hosts = user_cmd.split()[4:]
            for host in hosts:
                #print(command,host)
                # cmd_dict={"cmd":command,
                #           "host":hosts}
                task_id = random.randint(10000, 99999)
                client = Client()
                response = client.call(host, command)
                # print(response)
                self.information[task_id] = [host, command, response[0],response[1]]
        except IndexError as e:
            print("\33[31;0mError：%s\33[0m"%e)

    def reflect(self,str,user_cmd):
        '''反射'''
        if hasattr(self, str):
            getattr(self, str)(user_cmd)


    def start(self):
        while True:
            user_cmd = input("->>").strip()
            if not user_cmd:continue
            str = user_cmd.split()[0]
            t1 = threading.Thread(target=self.reflect,args=(str,user_cmd))  #多线程
            t1.start()

if __name__ == '__main__':
    obj = Handler()
    obj.start()