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

需求

---

题目：rpc命令端

需求：

    可以异步的执行多个命令
    对多台机器

>>:run "df -h" --hosts 192.168.3.55 10.4.3.4
task id: 45334
>>: check_task 45334
>>: 

实现需求

---

 

　　1. 实现全部需求

　　2.会缓存已建立过的连接，减少短时间内连接相同主机时再次建立连接的开销

　　3.定时清理缓存的连接

 

目录结构

---

 

rabbitmq_server
    ├ bin   # 执行文件目录
    |   └ rabbitmq_server.py     # 执行程序接口 
    ├ conf  # 配置文件目录
    |   └ setting.py           # 配置文件。目前主要保存用以连接RabbitMQ服务器的远程用户权限
    └ core  # 程序核心代码位置
        └ main.py           # 主交互逻辑
 

rabbitmq_client
    ├ bin   # 执行文件目录
    |   └ rabbitmq_client.py     # 执行程序 
    ├ conf  # 配置文件目录
    |   └ setting.py           # 配置文件。目前主要保存用以连接RabbitMQ服务器的远程用户权限，以及缓存连接的保存时间
    └ core  # 程序核心代码位置
        └ main.py           # 主逻辑交互程序

 代码

---

rabbitmq_server

import os,sys

BasePath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0,BasePath)

from core import main
main.main()

#! /usr/bin/env python3
# -*- coding:utf-8 -*-
# Author:Jailly

import os,sys,pika,subprocess,locale,threading

BasePath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0,BasePath)

from conf import setting

sys_encode = locale.getdefaultlocale()[1]
username = setting.username
password = setting.password

credentials = pika.PlainCredentials(username,password)


def cb(ch,method,properties,body):
    command = body.decode('utf-8')
    print('Received:',command)

    res = subprocess.Popen(command,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    out,err = res.communicate()
    res_con = err.decode(sys_encode) if err else out.decode(sys_encode)

    ch.basic_publish(
        exchange = '',
        routing_key = properties.reply_to,
        properties = pika.BasicProperties(
            correlation_id = properties.correlation_id
        ),
        body = res_con
    )
    print('send:',res_con)



def main():
    try:
        conn = pika.BlockingConnection(pika.ConnectionParameters('127.0.0.1', 5672, '/', credentials))
    except Exception as e:
        print(e)
    else:

        try:
            ch = conn.channel()
            ch.queue_declare(queue='rpc_queue')
            ch.queue_purge(queue='rpc_queue')

            ch.basic_consume(
                cb,
                queue='rpc_queue'
            )

            ch.start_consuming()

        except KeyboardInterrupt:
            conn.close()
            print('Server closed')
        except Exception as e:
            conn.close()
            print('Server down because of',e)

if __name__ == '__main__':
    main()

#! /usr/bin/env python3
# -*- coding:utf-8 -*-
# Author:Jailly

username = 'jailly'
password = '123456'

rabbitmq_client

import os,sys

BasePath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0,BasePath)

from core import main
main.main()

#! /usr/bin/env python3
# -*- coding:utf-8 -*-
# Author:Jailly

import re
import time
import random
import threading
import sys
import os
import pika

BasePath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0,BasePath)

from conf import setting

username = setting.username
password = setting.password
connection_timeout = setting.connection_timeout

run_p = re.compile('''
    ^\s*run\s+  # run
    (?P<quote>\')?(?P<d_quote>\'\')?  # 单引号 或 双引号 的前一半
    (?P<command>.+)  # command
    (?(quote)\'|)(?(d_quote)\'\'|)  # 单引号 或 双引号 的后一半
    \s+--host\s+
    (?P<ips>
        (((([01]?\d?\d)|2[0-4]\d|25[0-5])\.){3}(([01]?\d?\d)|2[0-4]\d|25[0-5])\s+)*  # ip
        ((([01]?\d?\d)|2[0-4]\d|25[0-5])\.){3}(([01]?\d?\d)|2[0-4]\d|25[0-5])\s*  # ip
    )$  
    ''',re.X)  # 匹配run指令的re模式对象
check_p = re.compile(r'^\s*check_task\s+(?P<task_id>\d+)\s*$')  # 匹配check_task指令的re模式对象
exit_p = re.compile(r'^\s*exit\s*$')  # 匹配exit指令的re模式对象

task_ids = list(range(65535))  #task_id 的取值范围

# tasks是一个保存任务的字典。key为task_id,value是该id对应的RPCClient()对象们组成的列表。创建该变量的目的是为映射 task_id 与其对应的
# RPCClient()对象，方便获取该 task_id 所对应的结果（该结果即RPCClient()对象的response属性）
tasks = {}

# conns是一个保存连接的字典，用以缓存已建立过的连接。key 为ip,value 是一个列表[rc,last_start_time,task_id_list],rc是该ip对应的
# RPCClient()对象，last_start_time是最近一次连接的开始时间,task_id_list 是使用该连接（或该RPCClient()对象）的task_id 所构成的列表。
# 创建该变量的目的是为了缓存连接，当在超时时间（默认5分钟）内再次请求同一个主机时，不用再次创建连接，节省建立连接的开销,同时也为定期清理连接保留了
# 连接记录
conns = {}

lock = threading.RLock()

class RPCClient(object):
    def __init__(self,host,port,vhost,credentials,conn=None):

        self.host = host
        self.conn = conn if conn else pika.BlockingConnection(pika.ConnectionParameters(host,port,vhost,credentials))
        self.ch = self.conn.channel()
        self.ch.queue_declare(queue='rpc_queue')

        result = self.ch.queue_declare(exclusive=True)
        self.callback_queue = result.method.queue

        self.ch.basic_consume(
            self.cb,
            queue = self.callback_queue
        )


    def cb(self,ch,method,properties,body):
        if self.corr_id == properties.correlation_id:
            self.response = body


    def call(self,command,task_id):
        self.corr_id = str(task_id)
        self.response = None

        self.ch.basic_publish(
            exchange = '',
            routing_key = 'rpc_queue',
            properties = pika.BasicProperties(
                reply_to = self.callback_queue,
                correlation_id = self.corr_id
            ),
            body = command
        )

        while self.response is None:
            self.conn.process_data_events()

        self.response = '\033[1;32m[--- %s ---]\033[0m\n%s\n'% (self.host,self.response.decode('utf-8'))


def create_connection(conns,ips,rcs,task_id):
    '''
    创建连接，并将生成的 RPCClient()对象 加入 rcs 列表
    :param conns: 对应 main.py 中的全局变量 conns
    :param ips: 本次任务对应的远程主机的 ip 列表
    :param rcs: 对应 main.py 中的 main_interactive() 中的 rcs 变量：该task_id 对应的 RPCClient()对象们 所组成的列表
    :param task_id: 本次任务的task_id
    :return:
    '''

    credentials = pika.PlainCredentials(username,password)
    for ip in ips:
        if ip in conns:
            rc = RPCClient(ip,5672,'/',credentials,conn=conns[ip][0])
            rcs.append(rc)
            conns[ip][1] = time.time()      # 重置“最新连接的开始时间”
            conns[ip][2].append(task_id)    # 添加跟该连接相关的task_id
        else:
            rc = RPCClient(ip,5672,'/',credentials)
            rcs.append(rc)
            conns[ip] = [rc.conn,time.time(),[task_id,]]


def get_result(tasks,task_id):
    '''
    根据task_id 获取 RabbitMQ 服务器的返回结果
    :param tasks: 任务列表，对应同名全局变量
    :param task_id: 任务id
    :return:
    '''

    rcs = tasks[task_id]
    outcome = ''
    for rc in rcs:
        if rc.response is not None:
            outcome += rc.response
        else:
            print('Task %s is handling\nIf the time for handling was too long,plz check the server health or your network conditions'%task_id)
            return False
    else:
        print(outcome)
        print('\033[1;34mTask done,task_id %s has been cleaned up\033[0m'%task_id )
        return True


def handle(command,ips,task_id,conns):
    '''
    建立连接，并处理指令。相当于整合了creat_connection() 和 get_result()
    :param command: 待处理的指令
    :param ips: 待连接的主机ip列表
    :param task_id: 任务id
    :param conns: 保存连接的列表，对应同名全局变量
    :return:
    '''

    # 第一步：建立连接
    rcs = []  # 与本次 task_id 对应的 RPCClient() 对象们组成的列表
    try:
        create_connection(conns, ips, rcs, task_id)
    except Exception as e:
        print('\033[1;31mCan not connect with specified host,plz check server health or make sure your network patency\033[m')
    else:
        tasks[task_id] = rcs

        # 第二步：处理指令
        for rc in rcs:
            tc = threading.Thread(target=rc.call, args=(command, task_id))
            tc.setDaemon(True)
            tc.start()


def main_interactive():
    '''
    主交互逻辑
    :return:
    '''

    while 1:
        cmd = input('>> ').strip()

        m = run_p.search(cmd)
        if m:
            command = m.group('command')
            ips = m.group('ips').split()

            task_id = random.choice(task_ids)
            task_ids.remove(task_id)
            print('task_id:', task_id)

            t = threading.Thread(target=handle,args=(command,ips,task_id,conns))
            t.setDaemon(True)
            t.start()

        else:
            m = check_p.search(cmd)
            if m:
                task_id = m.group('task_id')
                if task_id.isdigit():
                    task_id = int(task_id)
                    if task_id in tasks:
                        if get_result(tasks,task_id):
                            # 取得结果后，释放task_id,删除对应的RPCClient() 对象
                            task_ids.append(task_id)
                            del tasks[task_id]
                    else:
                        print('''\033[1;31mTask_id not found.It may because: 
1. task_id does not exist
2. connection with specified host has not been created.For this,please try again later
3. connection with specified host has been cleaned up because of timeout\033[0m''')
                else:
                    print('\033[1;31mTask_id must be integer\033[0m')

            else:
                m = exit_p.search(cmd)
                if m:
                    for rc in tasks.values():
                        rc.conn.close()
                    exit()
                else:
                    if cmd:
                        print('\033[1;31mCommand \'%s\' not found\033[0m'%cmd.split()[0])
                    else:
                        print('Command can not be None')


def clean_conns():
    '''
    超时连接清理。
    每5分钟(默认值，可在setting中设置)检查一次，某连接最近一次建立/声明距现在5分钟以上，则从conns列表中删除，同时删除其对应的task_id和RPCClient()对象
    注意 ： 如果有正在执行的任务，会因为清除对应的RPCClient()对象，而无法取得结果！！！
    :return:
    '''

    while 1:
        time.sleep(connection_timeout)
        lock.acquire()
        for ip in conns.copy():  # 不能在本字典迭代时删除字典元素，可以通过其软拷贝间接删除之
            if time.time() - conns[ip][1] > connection_timeout:  # 判断是否超时
                for id in conns[ip][2]:

                    # 清除与该连接相关的所有任务记录
                    if id in tasks:
                        del tasks[id]

                del conns[ip]  # 清除连接记录
        lock.release()


def main():
    t = threading.Thread(target=clean_conns)
    t.setDaemon(True)
    t.start()

    main_interactive()


if __name__ == '__main__':
    main()

#! /usr/bin/env python3
# -*- coding:utf-8 -*-
# Author:Jailly

username = 'jailly'
password = '123456'
connection_timeout = 300