简单主机批量管理工具（这里实现了paramiko 用su切换到root用户）

项目名：简单主机批量管理工具

一、需求

1、主机分组

2、可批量执行命令、发送文件，结果实时返回，执行格式如下

batch_run  -h h1,h2,h3   -g web_clusters,db_servers    -cmd  "df -h"　

batch_scp   -h h1,h2,h3   -g web_clusters,db_servers  -action put  -local test.py  -remote /tmp/　

3、主机用户名密码、端口可以不同

二、设计表结构(model原型)

三、代码结构

model.py  表结构（model）

 # -*- coding: utf-8 -*-
 from lib import commons
 from multiprocessing import Lock

 class Host(object):
     MUTEX = Lock()

     def __init__(self, host, port, user, password):
         self.MUTEX.acquire()
         self.hostId = commons.create_id('host')
         self.host = host
         self.port = port
         self.user = user
         self.password = password
         self.MUTEX.release()

     def __eq__(self, other):
         res = False
         if type(other) == type(self):
             if self.host == other.host:
                 res = True
         return res

     def __str__(self):
         return 'hostId:%s host:%s' % (self.hostId, self.host)

 class Group(object):
     MUTEX = Lock()

     def __init__(self, groupName):
         self.MUTEX.acquire()
         self.groupId = commons.create_id('group')
         self.groupName = groupName
         self.MUTEX.release()

     def __eq__(self, other):
         res = False
         if type(other) == type(self):
             if self.groupName == other.groupName:
                 res = True
         return res

     def __str__(self):
         return 'groupId:%s group:%s' % (self.groupId, self.groupName)

 class Group2Host(object):
     MUTEX = Lock()

     def __init__(self, hostId, groupId):
         self.MUTEX.acquire()
         self.g2hId = commons.create_id('group2Host')
         self.hostId = hostId
         self.groupId = groupId
         self.MUTEX.release()

     def __eq__(self, other):
         res = False
         if type(other) == type(self):
             if self.hostId == other.hostId and self.groupId == other.groupId:
                 res = True
         return res

     def __str__(self):
         return 'g2hId:%s group2Host:%s' % (self.g2hId, (self.hostId, self.groupId),)

model.py

main.py（这里实现了paramiko 用su - root 切换到root用户，再继续执行命令）

 # Author：ton
 # -*- coding: utf-8 -*-
 import paramiko
 import os
 import threading
 import shelve
 import re
 import time
 import xlrd
 import xlwt
 import json
 from conf import settings
 from models import models
 from core.db_handler import Db_handler
 from core.color import Colors
 from core import logger
 from threading import Thread

 # paramiko.util.log_to_file(os.path.join(settings.LOG_PATH, 'paramiko.log'))
 class Ideploy(object):
     def __init__(self):
         self.initDb()
         self.logger = logger.logger('MyIdeploy.log')
         self.host_db = shelve.open(os.path.join(settings.HOST_TABLE_PATH, 'host'))
         self.group_db = shelve.open(os.path.join(settings.GROUP_TABLE_PATH, 'group'))
         self.g2h_db = shelve.open(os.path.join(settings.G2H_TABLE_PATH, 'group2Host'))
         # 默认有default主机组
         self.default_group_obj = Db_handler.getGroupObjByGroupName(self.group_db, 'default')
         if not self.default_group_obj:
             self.default_group_obj = models.Group('default')
             Db_handler.insert_group(self.group_db, self.default_group_obj)
         self.thread_list = []
         self.instructions()
         self.run()
         self.host_db.close()
         self.group_db.close()
         self.g2h_db.close()

     @staticmethod
     def exit():
         exit('Bye')

     @staticmethod
     def instructions():
         """使用说明"""
         msg = """
         1、在conf/setttings下配置好需要暴力尝试密码的password_list和host_list
         2、在Terminal终端运行工具:python bin/ideploy.py -t start
         3、输入violentCipher，回车，完成后提示"暴力尝试密码完毕!"
         4、输入manageHosts，回车，可以查看管理暴力尝试密码成功的主机列表，记住默认主机组(default)的groupId为1，输入b，退出
         5、输入executeCommand，回车，输入批量执行命令：batch_run -g 1 -cmd "hostname"，该hostname命令执行的主机对象为默认主机组(default)下的所有主机
         6、输入show_task，回车，可以看到批量执行命令的结果
         7、继续输入批量执行命令：batch_scp -g 1 -action put -local __init__.py -remote /tmp/target.py，把本地文件__init__.py上传至远端/tmp/下，并取名为target.py
         8、输入show_task，回车，可以看到批量执行上传文件的结果
         9、输入q，退出批量执行命令的界面，输入exit，退出程序
         """
         print(msg)

     @staticmethod
     def initDb():
         """初始化数据库、日志目录"""
         # 初始化各表目录及其自增长ID记录文件
         for table_name in settings.TABLE_LIST:
             table_path = os.path.join(settings.DATABASE_PATH, table_name)
             table_id_file = os.path.join(table_path, 'countId')
             if not os.path.isdir(table_path):  # 创建数据文件路径
                 os.mkdir(table_path)
             if not os.path.isfile('%s.dat' % table_id_file):  # 创建自增长ID记录文件
                 data_dic = shelve.open(table_id_file)
                 data_dic['id'] = ''
                 data_dic.close()
         # 初始化日志目录
         if not os.path.isdir(os.path.join(settings.BASE_PATH, 'logs')):
             os.mkdir(os.path.join(settings.BASE_PATH, 'logs'))

     def run(self):
         while True:
             print("欢迎来到Ideploy".center(45, '-'))
             msg = """
                 violentCipher暴力尝试密码
                 createGroups创建主机组
                 manageHosts管理主机
                 executeCommand批量执行命令
                 exportHostToExcel导出主机信息到excel表
                 importHostFromExcel从excel表导入主机信息
                 exit退出
             """
             print(Colors(msg))
             print('thread number:%s' % threading.active_count())
             print("".center(50, '-'))
             choice = input('输入命令>>').strip()
             if hasattr(self, choice):
                 getattr(self, choice)()

     def violentCipher(self):
         """为每个主机分配线程尝试ssh密码"""
         for host in settings.host_list:
             # 多线程尝试ssh密码
             t = Thread(target=self.tryPasswordForHost, args=(host, settings.port, settings.user))
             t.setDaemon(True)
             self.thread_list.append(t)
             # 单线程尝试ssh密码
             # self.try_password_for_host(ip, settings.port, settings.user)
         for t in self.thread_list:
             t.start()
         for t in self.thread_list:
             t.join()
         self.thread_list = []
         print(Colors('暴力尝试密码完毕!输入"manageHosts"可以管理主机', 'green'))

     def tryPasswordForHost(self, host, port, user):
         """循环ssh密码列表尝试密码,并把正确密码保存文件"""
         password_list = settings.password_list
         for passwd in password_list:
             try:
                 ssh = paramiko.SSHClient()
                 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                 ssh.connect(hostname=host, port=port, username=user, password=passwd, timeout=3)
                 msg = 'correct ip:%s user:%s password:%s' % (host, user, passwd)
                 print(Colors(msg, 'green'))
                 # 更新host、g2h表
                 host_obj = models.Host(host, port, user, passwd)
                 Db_handler.update_host(self.host_db, host_obj)
                 return_host_obj = Db_handler.check_unique_host(self.host_db, host_obj)
                 if return_host_obj:
                     host_obj = return_host_obj
                 Db_handler.insert_g2h(self.g2h_db, host_obj, self.default_group_obj)
                 break
             except KeyError as e:
                 raise e  # 调试
             except Exception as e:
                 print(Colors(str(e), 'red'))
                 msg = 'wrong ip:%s user:%s password:%s' % (host, user, passwd)
                 print(Colors(msg, 'red'))
             finally:
                 ssh.close()

     def checkPassword(self):
         """检查ssh密码和root密码的有效性"""
         pass

     def exportHostToExcel(self):
         """从数据库导出所有主机信息到excel表里"""
         # 创建workbook和sheet对象
         workbook = xlwt.Workbook()  # 注意Workbook的开头W要大写
         sheet1 = workbook.add_sheet('sheet1', cell_overwrite_ok=True)
         # 向sheet页中写入列名数据
         column_names = ['host', 'groupName', 'user', 'password', 'port']
         for index, col in enumerate(column_names):
             sheet1.write(0, index, col)
         # 读取数据库，按group读取host
         group_list = []
         for key in self.group_db:
             group_list.append(self.group_db[key])
         group_list.sort(key=lambda group_obj: group_obj.groupId, reverse=False)  # 根据groupId排序
         for g_obj in group_list:
             # 根据主机组Id,获取该主机组所有主机Obj列表
             host_list = Db_handler.getHostObjListByGroupId(self.host_db, self.g2h_db, g_obj.groupId)
             host_list.sort(key=lambda obj: obj.host, reverse=False)  # 根据主机的ip排序
             # 向sheet页中写入host数据
             for row_num, host_obj in enumerate(host_list, 1):
                 col_values = [host_obj.host, g_obj.groupName, host_obj.user, host_obj.password, host_obj.port]
                 for col_num, col_val in enumerate(col_values):
                     sheet1.write(row_num, col_num, col_val)
         workbook.save(os.path.join(settings.BASE_PATH, 'hosts.xls'))
         print(Colors('导出成功!导出文件:%s' % os.path.join(settings.BASE_PATH, 'hosts.xls'), 'green'))

     def importHostFromExcel(self):
         """从excel表中导入主机信息并存入数据库"""
         # 打开一个workbook
         workbook = xlrd.open_workbook(os.path.join(settings.BASE_PATH, 'hosts.xls'))
         # 定位到sheet1
         sheet1 = workbook.sheets()[0]
         # 遍历sheet1中所有行row
         num_rows = sheet1.nrows
         for row_num in range(1, num_rows):
             row_val = sheet1.row_values(row_num)
             group_obj = Db_handler.getGroupObjByGroupName(self.group_db, row_val[1])
             if group_obj:
                 host_obj = models.Host(row_val[0], int(row_val[4]), row_val[2], row_val[3])
                 Db_handler.update_host(self.host_db, host_obj)
                 return_host_obj = Db_handler.check_unique_host(self.host_db, host_obj)
                 if return_host_obj:
                     host_obj = return_host_obj
                     Db_handler.insert_g2h(self.g2h_db, host_obj, group_obj)
             else:
                 print(Colors('没有该主机组名[%s]' % row_val[1], 'red'))
         else:
             print(Colors("导入成功!请输入'manageHosts'查看导入的主机", 'green'))

     def createGroups(self):
         while True:
             create_groupName = input('请输入需要创建的主机组名(b退出):').strip()
             if not create_groupName: continue
             if create_groupName == 'b': break
             create_group = models.Group(create_groupName)
             result_code = Db_handler.insert_group(self.group_db, create_group)
             if result_code:
                 print(Colors('创建主机组成功', 'green'))
             else:
                 print(Colors('该主机组已存在', 'red'))

     def manageHosts(self):
         """分配主机到主机组"""
         # 解析分配的hostId和groupId,判断是否存在
         while True:
             print('所有主机信息如下:')
             self.displayHosts()
             choice_action = input('请输入要对主机组执行的操作(add添加,del删除,b退出):').strip()
             if choice_action == 'b':
                 break
             elif choice_action != 'add' and choice_action != 'del':
                 continue
             quit_flag = True
             while quit_flag:
                 choice_hostIds = input('请输入hostId(用空格隔开)(b退出):').strip()
                 if not choice_hostIds: continue
                 if choice_hostIds == 'b': break
                 hostId_list = choice_hostIds.split()
                 exist_flag = True
                 for hostId in hostId_list:
                     if hostId not in self.host_db:
                         exist_flag = False
                         print(Colors('输入要操作的hostId:%s 不存在' % hostId, 'red'))
                 if not exist_flag: continue
                 while quit_flag:
                     choice_groupId = input('请输入要操作的groupId(b退出):').strip()
                     if not choice_groupId: continue
                     if choice_groupId == 'b': break
                     if choice_groupId not in self.group_db:
                         print(Colors('输入的groupId:%s 不存在' % choice_groupId, 'red'))
                         continue
                     # 开始更新g2h表
                     for hostId in hostId_list:
                         if choice_action == 'add':
                             Db_handler.insert_g2h(self.g2h_db, self.host_db[hostId], self.group_db[choice_groupId])
                         else:
                             Db_handler.delete_g2h(self.g2h_db, self.host_db[hostId], self.group_db[choice_groupId])
                     print(Colors('配置成功', 'green'))
                     quit_flag = False

     def displayHosts(self):
         """展示管理的主机"""
         group_list = []
         for key in self.group_db:
             group_list.append(self.group_db[key])
         group_list.sort(key=lambda group_obj: group_obj.groupId, reverse=False)  # 根据groupId排序
         for g_obj in group_list:
             # 根据主机组Id,获取该主机组所有主机Obj列表
             host_list = Db_handler.getHostObjListByGroupId(self.host_db, self.g2h_db, g_obj.groupId)
             print(Colors(
                 'Group:%s[%d](groupId:%s)' % (g_obj.groupName, len(host_list), g_obj.groupId), 'cyan'))
             host_list.sort(key=lambda obj: obj.host, reverse=False)  # 根据主机的ip排序
             for host_obj in host_list:
                 print('\t%s' % host_obj)

     def executeCommand(self):
         """批量执行ssh命令"""
         SSHClient(self)

 class TaskList(list):
     def __init__(self, item=()):
         super().__init__(item)
         self.logger = logger.logger('task_list')

     def append(self, p_object):
         if not isinstance(p_object, dict):
             raise TypeError
         super().append(p_object)
         # with open(os.path.join(settings.BASE_PATH, 'task_list'), 'a') as f:
         #     f.write(json.dumps(p_object) + '\n')
         self.logger.info(json.dumps(p_object))

 class SSHClient(object):
     def __init__(self, ideploy_obj):
         self.ideploy_obj = ideploy_obj
         self.task_list = TaskList()
         self.interactive()

     @staticmethod
     def help_msg():
         """ssh命令帮助信息"""
         msg = """注意:-h 后为hostId，-g 后为groupId
         batch_run -h 1,2,3 -g 1,2 -cmd "df -h"
         batch_scp -h 1,2,3 -g 1,2 -action put -local test.py -remote /tmp/　
         show_task  查看ssh命令结果
         """
         print(msg)

     def interactive(self):
         while True:
             print('\n thread number:%s' % threading.active_count())
             cmd = input(Colors('批量执行命令>>', 'cyan')).strip()
             if not cmd: continue
             if cmd == 'q': break
             if hasattr(self, cmd[:9]):
                 getattr(self, cmd[:9])(cmd[9:].strip())
             else:
                 self.help_msg()

     @staticmethod
     def create_task_dic(hostId, host, command, result, date):
         task_dic = {
             'hostId': hostId,
             'host': host,
             'command': command,
             'result': result,
             'date': date,
         }
         return task_dic

     def show_task(self, cmd):
         for task_dic in self.task_list:
             print(
                 '\033[36m(hostId:%s)host:\033[0m%s \033[36mcommand:\033[0m%s \033[36mresult:\033[0m\n%s \033[36mdate:\033[0m%s' % (
                     task_dic['hostId'], task_dic['host'], task_dic['command'], task_dic['result'], task_dic['date']))

     def batch_run(self, cmd):
         """批量执行batch_run命令"""
         argv_dic = self.parse_run_command(cmd)
         if argv_dic['cmd']:
             self.batch('batch_run', argv_dic)
         else:
             self.help_msg()

     def connect_batch_run(self, host_obj, argv_dic):
         """与ssh服务端通讯执行远程ssh命令"""
         ssh = paramiko.SSHClient()
         try:
             ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
             ssh.connect(hostname=host_obj.host, port=host_obj.port, username=host_obj.user, password=host_obj.password,
                         timeout=5)
             channel = ssh.invoke_shell()
             result = ''
             if host_obj.user != 'root':
                 # channel.send("sudo su - \n")
                 channel.send("su - \n")
                 # 下面几行代码是发送 su - root命令时所需要输入的root密码,配置了/etc/sudoers NOPASSWD就不用密码了
                 while not re.search(r'(P|p)assword: $', result):
                     result += channel.recv(8196).decode('utf-8')
                 self.ideploy_obj.logger.info(b"++" + result.encode('utf-8') + b'++')
                 result = ''
                 channel.send('%s\n' % settings.root_pwd)
             while not re.search(r'#[^#]{0,13}$', result):
                 result += channel.recv(8196).decode('utf-8')
             self.ideploy_obj.logger.info(b"++" + result.encode('utf-8') + b'++')
             result = ''
             channel.send('%s\n' % argv_dic['cmd'])
             while not re.search(r'#[^#]{0,13}$', result):
                 result += channel.recv(8196).decode('utf-8')
             self.ideploy_obj.logger.info(b"++" + result.encode('utf-8') + b'++')
             result_list = re.findall(r".*\n", result)[1:]
             result = ''.join(result_list)
             channel.close()
             self.task_list.append(self.create_task_dic(host_obj.hostId, host_obj.host,
                                                        argv_dic['cmd'], result,
                                                        time.strftime("%Y-%m-%d %X", time.localtime())))
         except Exception as e:
             self.task_list.append(
                 self.create_task_dic(host_obj.hostId, host_obj.host, argv_dic['cmd'], str(e),
                                      time.strftime("%Y-%m-%d %X", time.localtime())))
         finally:
             ssh.close()

     def connect_batch_scp(self, host_obj, argv_dic):
         """与ssh服务端建立sftp通道执行远程scp命令"""
         try:
             transport = paramiko.Transport((host_obj.host, host_obj.port))
             transport.connect(username=host_obj.user, password=host_obj.password, )
             sftp = paramiko.SFTPClient.from_transport(transport)
             if argv_dic['action'] == 'put':
                 # 将location.py 上传至服务器 /tmp/test.py
                 sftp.put(argv_dic['local'], argv_dic['remote'])
             else:
                 # 将remove_path 下载到本地 local_path
                 sftp.get(argv_dic['remote'], argv_dic['local'])
             self.task_list.append(
                 self.create_task_dic(host_obj.hostId, host_obj.host,
                                      'action[%s] local[%s] remote[%s]' % (
                                          argv_dic['action'], argv_dic['local'], argv_dic['remote']), 'OK',
                                      time.strftime("%Y-%m-%d %X", time.localtime())))
         except Exception as e:
             self.task_list.append(
                 self.create_task_dic(host_obj.hostId, host_obj.host,
                                      'action[%s] local[%s] remote[%s]' % (
                                          argv_dic['action'], argv_dic['local'], argv_dic['remote']), str(e),
                                      time.strftime("%Y-%m-%d %X", time.localtime())))
         finally:
             try:
                 transport.close()
             except UnboundLocalError:
                 pass

     def batch(self, batch_type, argv_dic):
         """为每个host分配一个线程去连接ssh服务端批量执行batch_run或batch_scp命令"""
         finished_hostId_list = []
         batch_type_func = 'connect_%s' % batch_type
         if argv_dic.get('group_list'):
             for groupId in argv_dic['group_list']:
                 if groupId in self.ideploy_obj.group_db:
                     host_list = Db_handler.getHostObjListByGroupId(self.ideploy_obj.host_db, self.ideploy_obj.g2h_db,
                                                                    groupId)
                     for host_obj in host_list:
                         t = Thread(target=getattr(self, batch_type_func), args=(host_obj, argv_dic))
                         t.setDaemon(True)
                         t.start()
                         finished_hostId_list.append(host_obj.hostId)
                 else:
                     self.task_list.append(self.create_task_dic("groupId[%s]" % groupId, None,
                                                                None, "groupId[%s] is not exist" % groupId,
                                                                time.strftime("%Y-%m-%d %X", time.localtime())))
         if argv_dic.get('host_list'):
             for hostId in argv_dic['host_list']:
                 if hostId in self.ideploy_obj.host_db:
                     if hostId not in finished_hostId_list:
                         t = Thread(target=getattr(self, batch_type_func),
                                    args=(self.ideploy_obj.host_db[hostId], argv_dic))
                         t.setDaemon(True)
                         t.start()
                 else:
                     self.task_list.append(self.create_task_dic(hostId, None,
                                                                None, "hostId[%s] is not exist" % hostId,
                                                                time.strftime("%Y-%m-%d %X", time.localtime())))

     def batch_scp(self, cmd):
         """批量执行batch_scp命令"""
         argv_dic = self.parse_scp_command(cmd)
         if argv_dic['action'] and argv_dic['local'] and argv_dic['remote']:
             self.batch('batch_scp', argv_dic)
         else:
             self.help_msg()

     @staticmethod
     def parse_target(cmd):  # -h h1,h2,h3 -g web_clusters,db_servers -cmd "df -h"
         """解析-h、-g参数，获取主机、主机组列表"""
         host_str = re.match(r"-h[ ]+[^-]+", cmd)
         host_list = host_str.group().strip()[2:].strip().replace(r" ", "").split(",") if host_str else None
         group_str = re.search(r"-g[ ]+[^-]+", cmd)
         group_list = group_str.group().strip()[2:].strip().replace(r" ", "").split(",") if group_str else None
         return host_list, group_list

     def parse_run_command(self, cmd):  # -h h1,h2,h3 -g web_clusters,db_servers -cmd "df -h"
         """解析batch_run命令参数"""
         host_list, group_list = self.parse_target(cmd)
         real_cmd_str = re.search(r"-cmd[ ]+(\'|\")(?P<cmd>.*)(\'|\")", cmd)
         if real_cmd_str:
             real_cmd_dic = real_cmd_str.groupdict()
             real_cmd_str = real_cmd_dic['cmd'].strip()
         else:
             real_cmd_str = None
         argv_dic = {
             'host_list': host_list,
             'group_list': group_list,
             'cmd': real_cmd_str
         }
         return argv_dic

     def parse_scp_command(self, cmd):  # -h h1,h2,h3 -g web_clusters,db_servers -action put -local test.py -remote /tmp/
         """解析batch_scp命令参数"""
         host_list, group_list = self.parse_target(cmd)
         action_str = re.search(r"-action[ ]+[^-]+", cmd)
         action_str = action_str.group().strip()[7:].strip() if action_str else None
         local_str = re.search(r"-local[ ]+[^-]+", cmd)
         local_str = local_str.group().strip()[6:].strip() if local_str else None
         remote_str = re.search(r"-remote[ ]+[^-]+", cmd)
         remote_str = remote_str.group().strip()[7:].strip() if remote_str else None
         argv_dic = {
             'host_list': host_list,
             'group_list': group_list,
             'action': action_str,
             'local': local_str,
             'remote': remote_str
         }
         return argv_dic

mian.py

db_handler.py

 import shelve
 from models import models
 from core.color import Colors
 from multiprocessing import Lock

 class Db_handler(object):
     HOST_MUTEX = Lock()
     GROUP_MUTEX = Lock()
     G2H_MUTEX = Lock()

     @staticmethod
     # 根据主机组名称,获取该主机组Obj
     def getGroupObjByGroupName(group_db, groupName):
         for key in group_db:
             if group_db[key].groupName == groupName:
                 return group_db[key]
         return

     @staticmethod
     # 根据主机组Id,获取该主机组所有主机Obj列表
     def getHostObjListByGroupId(host_db, g2h_db, groupId):
         host_list = []
         for key in g2h_db:
             if g2h_db[key].groupId == groupId:
                 host_list.append(host_db[g2h_db[key].hostId])
         return host_list

     # 检查主机表唯一性(host字段唯一)(判断一个host对象是否存在)
     @classmethod
     def check_unique_host(cls, host_db, host_obj):
         for key in host_db:
             if host_db[key] == host_obj:
                 # print('存在host:%s'%host_db[key])
                 return host_db[key]
         return

     # 检查主机组表唯一性(groupName字段唯一)(判断一个group对象是否存在)
     @classmethod
     def check_unique_group(cls, group_db, group_obj):
         for key in group_db:
             if group_db[key] == group_obj:
                 # print('存在group:%s'%group_db[key])
                 return group_db[key]
         return

     # 检查主机组-主机表唯一性(记录中存在重复的hostId和groupId)(判断一个group2Host对象是否存在)
     @classmethod
     def check_unique_g2h(cls, g2h_db, g2h_obj):
         for key in g2h_db:
             if g2h_db[key] == g2h_obj:
                 # print('存在g2h:%s'%g2h_db[key])
                 return g2h_db[key]
         return

     # update host table
     @classmethod
     def update_host(cls, host_db, host_obj):
         cls.HOST_MUTEX.acquire()
         return_host_obj = cls.check_unique_host(host_db, host_obj)
         if not return_host_obj:
             host_db[host_obj.hostId] = host_obj
             print(Colors('insert host table 1 row', bcolor='green'))
         else:
             host_obj.hostId = return_host_obj.hostId
             host_db[return_host_obj.hostId] = host_obj
             print(Colors('update host table 1 row', bcolor='cyan'))
         cls.HOST_MUTEX.release()

     # insert group table
     @classmethod
     def insert_group(cls, group_db, group_obj):
         result_code = False
         cls.GROUP_MUTEX.acquire()
         if not cls.check_unique_group(group_db, group_obj):
             group_db[group_obj.groupId] = group_obj
             result_code = True
             print(Colors('insert group table 1 row', bcolor='green'))
         cls.GROUP_MUTEX.release()
         return result_code

     # insert g2h table
     @classmethod
     def insert_g2h(cls, g2h_db, host_obj, group_obj):
         result_code = False
         cls.G2H_MUTEX.acquire()
         g2h_obj = models.Group2Host(host_obj.hostId, group_obj.groupId)
         if not cls.check_unique_g2h(g2h_db, g2h_obj):
             g2h_db[g2h_obj.g2hId] = g2h_obj
             result_code = True
             print(Colors('insert g2h table 1 row', bcolor='green'))
         cls.G2H_MUTEX.release()
         return result_code

     # delete g2h table
     @classmethod
     def delete_g2h(cls, g2h_db, host_obj, group_obj):
         result_code = False
         cls.G2H_MUTEX.acquire()
         for key in g2h_db:
             if g2h_db[key].hostId == host_obj.hostId and g2h_db[key].groupId == group_obj.groupId:
                 g2h_db.pop(key)
                 result_code = True
                 print(Colors('delete g2h table 1 row', bcolor='yellow'))
         cls.G2H_MUTEX.release()
         return result_code

db_handler.py

logger.py

 # -*- coding: utf-8 -*-
 import logging
 import os
 from logging import handlers
 from conf import settings

 def logger(log_file):
     log_level = settings.log_level
     if log_level == 'debug':
         log_level = logging.DEBUG
     elif log_level == 'info':
         log_level = logging.INFO
     elif log_level == 'warning':
         log_level = logging.WARNING
     elif log_level == 'error':
         log_level = logging.ERROR
     else:
         log_level = logging.CRITICAL
     # 1.生成logger对象
     logger = logging.getLogger(log_file)
     logger.setLevel(logging.DEBUG)
     # 2.生成handler对象
     fh = handlers.TimedRotatingFileHandler(filename=os.path.join(settings.LOG_PATH, log_file),
                                            when='D', interval=1, backupCount=3)
     fh.setLevel(log_level)
     # 2.1 把handler对象绑定到logger
     if not logger.handlers:
         logger.addHandler(fh)
     # 3.生成formatter对象
     f = logging.Formatter(fmt='%(asctime)s %(name)s [%(levelname)s] %(message)s', datefmt=None)
     # 3.1 把formatter对象绑定到handler
     fh.setFormatter(f)
     return logger

logger.py

color.py

 def Colors(text, fcolor=None, bcolor=None, style=None):
     """自定义字体样式及颜色"""
     # 字体颜色
     fg = {
         'black': '\033[30m',  # 字体黑
         'red': '\033[31m',  # 字体红
         'green': '\033[32m',  # 字体绿
         'yellow': '\033[33m',  # 字体黄
         'blue': '\033[34m',  # 字体蓝
         'magenta': '\033[35m',  # 字体紫
         'cyan': '\033[36m',  # 字体青
         'white': '\033[37m',  # 字体白
         'end': '\033[0m'  # 默认色
     }
     # 背景颜色
     bg = {
         'black': '\033[40m',  # 背景黑
         'red': '\033[41m',  # 背景红
         'green': '\033[42m',  # 背景绿
         'yellow': '\033[43m',  # 背景黄
         'blue': '\033[44m',  # 背景蓝
         'magenta': '\033[45m',  # 背景紫
         'cyan': '\033[46m',  # 背景青
         'white': '\033[47m',  # 背景白
     }
     # 内容样式
     st = {
         'bold': '\033[1m',  # 高亮
         'url': '\033[4m',  # 下划线
         'blink': '\033[5m',  # 闪烁
         'seleted': '\033[7m',  # 反显
     }

     if fcolor in fg:
         text = fg[fcolor] + text + fg['end']
     if bcolor in bg:
         text = bg[bcolor] + text + fg['end']
     if style in st:
         text = st[style] + text + fg['end']
     return text

color.py

settings.py

 # Author：ton
 # -*- coding: utf-8 -*-
 import os

 BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 LOG_PATH = os.path.join(BASE_PATH, 'logs')
 DATABASE_PATH = os.path.join(BASE_PATH, 'db')
 HOST_TABLE_PATH = os.path.join(DATABASE_PATH, 'host')
 GROUP_TABLE_PATH = os.path.join(DATABASE_PATH, 'group')
 G2H_TABLE_PATH = os.path.join(DATABASE_PATH, 'group2Host')
 TABLE_LIST = ['host', 'group', 'group2Host']

 # 暴力破解配置项
 user = 'sshusr'
 password_list = ['', 'sshusr123', '', ]
 host_list = ['10.0.0.11', '10.0.0.12', '10.0.0.13', '10.0.0.14']
 port = 22
 root_pwd = ''

 # 日志记录配置项
 log_level = 'debug'

settings.py

四、使用说明

1、在conf/setttings下配置好需要暴力尝试密码的password_list和host_list
2、在Terminal终端运行工具:python bin/ideploy.py -t start
3、输入violentCipher，回车，完成后提示"暴力尝试密码完毕!"
4、输入manageHosts，回车，可以查看管理暴力尝试密码成功的主机列表，记住默认主机组(default)的groupId为1，输入b，退出
5、输入executeCommand，回车，输入批量执行命令：batch_run -g 1 -cmd "hostname"，该hostname命令执行的主机对象为默认主机组(default)下的所有主机
6、输入show_task，回车，可以看到批量执行命令的结果
7、继续输入批量执行命令：batch_scp -g 1 -action put -local __init__.py -remote /tmp/target.py，把本地文件__init__.py上传至远端/tmp/下，并取名为target.py
8、输入show_task，回车，可以看到批量执行上传文件的结果
9、输入q，退出批量执行命令的界面，输入exit，退出程序

截图：

PS:任务列表(show_task)会同时记录到logs/task_list文件，永久保存