def load_host_groups(sqlhelper):
"""
显示所有主机组，用户选择返回一个选择的主机组列表
:param sqlhelper: 数据库访问对象
:return: 返回选择的主机组
"""
tmpi = 0
tmpflag = False
# 获取所有组信息
print("\n\033[1;30m <-- 选择所属主机组编号 -->\033[0m")
groupobj = BLL_Host_Group(sqlhelper)
grouplist = groupobj.load_group_all()
while tmpi < len(grouplist):
print(" [{0}] {1}".format(str(tmpi + 1), grouplist[tmpi].groupname))
tmpi += 1
# 选择主机组
while not tmpflag:
choose_group = []
gidlist = common.input_msg("选择组编号(多个组用逗号分割): ")
for gid in gidlist.split(","):
if not gid.isdigit():
common.show_message("输入错误!", "ERROR")
tmpflag = False
break
elif int(gid) > len(grouplist):
common.show_message("组编号不存在,请重新选择!", "ERROR")
tmpflag = False
break
else:
# 将选择的主机组对象放入选择列表中
choose_group.append(grouplist[int(gid) - 1])
tmpflag = True
return choose_group
def start():
server_ip = settings.FTP_SERVER_IP
server_port = settings.FTP_SERVER_PORT
common.show_message(template.START_MENU, "INFO")
common.show_message(
"正在连接FTP服务器 {0}:{1} ......".format(server_ip, server_port), "INFO")
# 创建一个client对象
client = Client(server_ip, server_port)
# 连接服务器，返回结果
conn_result = client.connect()
# 连接成功
if conn_result == codes.CONN_SUCC:
common.show_message("连接成功!", "NOTICE")
# 客户端登录
client_login(client)
# 登录成功
if client.login_status:
# 退出系统
exit_flag = False
while not exit_flag:
# 显示登录后的菜单
show_menu = template.LOGINED_MENU.format(
client.username,
str(int(client.totalspace / 1024 /
1024)), #固定配额 不存在为小数 int 去整
str(round(client.usedspace / 1024 / 1024, 2))) #保留两位小数点 显示
common.show_message(show_menu, "NOTICE")
# 输入命令串
input_command = common.input_command("[ 输入命令 ] : ")
if input_command == "quit":
exit_flag = True
else:
# 获取命令的的command
cmd_func = input_command.split("|")[0]
try:
# 通过反射调用Client类的对应command方法,并返回执行结果
if hasattr(Client, cmd_func):
func = getattr(Client, cmd_func)
exec_result = func(client, input_command)
print(exec_result)
else:
common.writelog(
"Client {0} 未找到".format(input_command),
"error")
except Exception as e:
common.writelog(e, "error")
else:
common.show_message("连接失败", "ERROR")
def client_login(userobj):
"""
客户端前台登录操作
:param userobj: 当前客户端对象
:return: 登录结果
"""
tmp_flag = False
while not tmp_flag:
# 开始登录
username = common.input_msg("Input username: "******"Input password: "******"登录成功", "NOTICE")
tmp_flag = True
elif auth_status == codes.AUTH_FAIL:
common.show_message("用户名或密码错误", "ERROR")
elif auth_status == codes.AUTH_LOCKED:
common.show_message("账户已被锁定,联系管理员!", "ERROR")
else:
common.show_message("用户不存在", "ERROR")
def client_login(userobj):
"""
客户端前台登录操作
:param userobj: 当前客户端对象
:return: 登录结果
"""
tmp_flag = False
while not tmp_flag:
# 开始登录
username = common.input_msg("Input username: "******"Input password: "******"登录成功", "NOTICE")
tmp_flag = True
elif auth_status == codes.AUTH_FAIL:
common.show_message("用户名或密码错误", "ERROR")
elif auth_status == codes.AUTH_LOCKED:
common.show_message("账户已被锁定,联系管理员!", "ERROR")
else:
common.show_message("用户不存在", "ERROR")
def start():
server_ip = settings.FTP_SERVER_IP
server_port = settings.FTP_SERVER_PORT
common.show_message(template.START_MENU, "INFO")
common.show_message("正在连接FTP服务器 {0}:{1} ......".format(server_ip, server_port), "INFO")
# 创建一个client对象
client = Client(server_ip, server_port)
# 连接服务器，返回结果
conn_result = client.connect()
# 连接成功
if conn_result == codes.CONN_SUCC:
common.show_message("连接成功!", "NOTICE")
# 客户端登录
client_login(client)
# 登录成功
if client.login_status:
# 退出系统
exit_flag = False
while not exit_flag:
# 显示登录后的菜单
show_menu = template.LOGINED_MENU.format(client.username,
str(int(client.totalspace / 1024 / 1024)),
str(int(client.usedspace / 1024 / 1024)))
common.show_message(show_menu, "NOTICE")
# 输入命令串
input_command = common.input_command("[ 输入命令 ] : ")
if input_command == "quit":
exit_flag = True
else:
# 获取命令的的command
cmd_func = input_command.split("|")[0]
try:
# 通过反射调用Client类的对应command方法,并返回执行结果
if hasattr(Client, cmd_func):
func = getattr(Client, cmd_func)
exec_result = func(client, input_command)
print(exec_result)
else:
common.writelog("Client {0} 未找到".format(input_command), "error")
except Exception as e:
common.writelog(e, "error")
else:
common.show_message("连接失败", "ERROR")
def add_group(sqlhelper):
"""
添加主机组
:param sqlhelper: 数据库连接对象
:return:
"""
try:
groupname = common.input_msg("请输入主机组名称: ")
groupobj = BLL_Host_Group(sqlhelper)
groupobj.groupname = groupname
if not groupobj.load_group_by_name():
groupobj.insert()
common.show_message("主机组添加成功", "INFORMATION")
else:
common.show_message("该组已经存在!", "NOTICE")
except Exception as e:
common.write_log("[module.admin.add_group] {0}".format(e))
def add_host(sqlhelper):
"""
添加主机信息
:param sqlhelper:
:return:
"""
try:
hostname = common.input_msg(" 请输入主机名: ")
hostip = common.input_msg(" 请输入IP地址: ")
sshport = common.input_msg(" 请输入SSH端口(default:22): ", int=True)
choose_group = load_host_groups(sqlhelper)
# 生成主机对象并执行sql写入
hostobj = BLL_Hosts(sqlhelper)
hostobj.hostname = hostname
hostobj.ipaddr = hostip
hostobj.sshport = sshport
hostobj.insert(choose_group)
common.show_message("主机添加成功!", "INFORMATION")
except Exception as e:
common.write_log("[module.admin.add_host] {0}".format(e))
def login(sqlhelper):
while True:
username = common.input_msg("登录名: ")
passwd = common.input_msg("密码: ", password=True)
# 实例化一个用户对象
user = BLL_Login_User(sqlhelper)
user.username = username
user.password = common.encry(passwd)
# 执行登录操作
user.login()
if user.exists:
# 登录成功,如果是管理员进入管理员模块
if user.role == "admin":
admin_run(user, sqlhelper)
else:
# 普通用户进入普通用户模块
user_run(user, sqlhelper)
# print("name:", user.name, user.role)
else:
common.show_message("用户名或密码错误!", "ERROR")
del user
def init_run():
"""
数据库初始化模块，检测数据库是否已经创建，如果未创建数据库就生成表
"""
if os.path.exists(settings.DB_INIT_LCK):
pass
else:
confirm = common.input_msg("尚未创建数据表，是否现在初始化数据表?(y/n): ", ("y", "n"))
# 开始创建数据表
if confirm == "y":
try:
common.show_message("开始创建数据表......", "INFORMATION")
base = tables.Base
mysql = MySqlHelper()
base.metadata.create_all(mysql.engine)
common.show_message("数据表创建完成！", "INFORMATION")
# 创建完成数据表后生成标识文件
fb = open(settings.DB_INIT_LCK, 'wb')
fb.close()
# 创建一个管理员
common.show_message("开始初始化用户........", "INFORMATION")
user_admin = tables.Login_User(username='******',
password=common.encry('admin'),
name='管理员',
role='admin',
isdel=0,
expired=datetime.now() + timedelta(days=+999)
)
mysql.connect()
mysql.session.add(user_admin)
mysql.session.commit()
common.show_message("初始化用户完成，请用admin / admin 登录", "INFORMATION")
# 关闭连接
mysql.close()
except Exception as e:
common.write_log(e, "error")
sys.exit(-1)
def user_run(user, sqlhelper):
"""
普通用户登录操作模块
:param user:
:return:
"""
try:
op_log = BLL_Op_Logs(user, sqlhelper)
exit_flag = False
while not exit_flag:
tmpi = 0
tmpflag = False
# 打印标题
print(title_menu(user))
common.show_message("<-- 请选择要操作的主机 -->", "INFORMATION")
# 获取用户所属组列表
host_list = user.load_hosts_by_uid()
# 打印主机列表
for host in host_list:
print("\033[1;32m [{0}] 主机名:{1} IP:{2} 所属组:{3}\033[0m".format(str(tmpi + 1),
host['hostname'],
host['ipaddr'],
host['groupname']
))
tmpi += 1
# 选择一个要登录的主机
while not tmpflag:
exit_flag = False
choose_id = common.input_msg("\n请选择要登录的主机编号(exit 退出): ")
if choose_id == "exit":
exit_flag = True
break
if int(choose_id) > len(host_list):
common.show_message("主机编号不存在!", "ERROR")
continue
else:
choose_host = host_list[int(choose_id) - 1]
break
# 是否要退出
if exit_flag == True:
continue
# 要登录的主机IP
ssh_host_ip = choose_host['ipaddr']
ssh_host_port = choose_host['port']
ssh_host_hostname = choose_host['hostname']
# 获取选择的主机中用户可以使用的ssh用户列表
ssh_users = user.load_sshusers(choose_host['hostid'])
if len(ssh_users) == 0: # 未找到可以使用的账户
common.show_message("\n未配置登录用户,请联系系统管理员!", "ERROR")
continue
elif len(ssh_users) == 1: # 如果当前主机只有一个用户可以操作
ssh_user = ssh_users[0]
else: # 有多个用户,需要选择一个
tmpi = 0
for sshuser in ssh_users:
print(" [{0}] {1}".format(str(tmpi + 1), sshuser['username']))
tmpi += 1
choose = common.input_msg("请选择要使用的SSH用户编号:", int=True)
ssh_user = ssh_users[int(choose) - 1]
# 记录一条op日志
op_log.save_log(("用户[{0}]使用SSH用户[{1}]登录主机[{2}](IP:{3}).".format(user.username,
ssh_user['username'],
ssh_host_hostname,
ssh_host_ip),), "ssh")
# 调用paramiko进行登录
# print(ssh_host_ip, ssh_host_port, ssh_user['username'], ssh_user['auth_type'], ssh_user['passwd'])
interactive.run(user,
sqlhelper,
ssh_host_ip,
ssh_host_port,
ssh_user['username'],
ssh_user['auth_type'],
ssh_user['passwd'])
op_log.save_log(("用户[{0}]使用SSH用户[{1}]登出主机[{2}](IP:{3}).".format(user.username,
ssh_user['username'],
ssh_host_hostname,
ssh_host_ip),), "ssh")
# 释放对象
del op_log
except Exception as e:
common.write_log("[bin.main.user_run] {0}".format(e), "error")
def add_host_user(sqlhelper):
"""
添加主机用户信息
:param sqlhelper:
:return:
"""
try:
group_list = load_host_groups(sqlhelper)
while len(group_list) > 1:
print("添加主机用户时一次只能选择一台主机,请选择一个主机组!")
group_list = load_host_groups(sqlhelper)
# 显示选择组下的所有主机信息
tmpi = 0
#print(choose_group,type(choose_group))
choose_group = group_list[0]
hostobj = BLL_Hosts(sqlhelper)
host_list = hostobj.load_hosts_by_group(choose_group)
print("\n\033[1;30m <--- 主机组 [{0}] 包含如下主机,请选择主机编号 --->\033[0m".format(
choose_group.groupname))
while tmpi < len(host_list):
print(" [{0}] 主机名:{1} IP:{2}".format(
tmpi + 1, host_list[tmpi].hostname.ljust(10, " "),
host_list[tmpi].ipaddr))
tmpi += 1
# 选择主机编号
while True:
host_id = common.input_msg("选择主机编号(q 返回): ")
if host_id == "q":
break
else:
host_id = int(host_id)
# 判断选择的组编号是否越界
if host_id > len(host_list):
common.show_message("选择编号错误,请重新选择!", "ERROR")
continue
else:
break
choose_host = host_list[host_id - 1]
# 对选择的主机添加用户
choose_flag = False
ssh_user = BLL_SSH_User(sqlhelper, choose_host)
while not choose_flag:
auth_user = common.input_msg("登录用户名: ")
auth_type = common.input_msg("登录验证类型[1:密码 / 2:密钥]: ",
limit_value=('1', '2'))
auth_key = common.input_msg("登录密码/密钥文件: ")
# 新增用户
ssh_user.auth_key = auth_key
ssh_user.auth_name = auth_user
ssh_user.auth_type = int(auth_type)
ssh_user.insert()
# 继续添加
common.show_message("添加成功!", "INFORMATION")
goon = common.input_msg("是否继续添加用户(y/n)? :", limit_value=('y', 'n'))
if goon == "y":
continue
else:
choose_flag = True
except Exception as e:
common.write_log("[module.admin.add_host_user] {0}".format(e))
def add_login_user(sqlhelper):
"""
添加登录堡垒及的账户信息
:param sqlhelper:
:return:
"""
try:
back_flag = False
while not back_flag:
# 初始化输入
login_user = BLL_Login_User(sqlhelper)
while True:
username = common.input_msg("用户名(q 返回): ")
if username == "q":
back_flag = True
break
# 判断用户是否存在
login_user.username = username
if login_user.user_exists:
common.show_message("该用户名已经存在,请重新输入!", "ERROR")
continue
else:
break
if not back_flag:
password = common.input_msg("密 码: ", password=True)
name = common.input_msg("姓 名: ")
role = common.input_msg("权限(1:普通用户 / 2:管理员): ",
limit_value=('1', '2'))
expired_days = common.input_msg("有效期(天): ", int=True)
expired = datetime.now() + timedelta(days=int(expired_days))
if role == "1":
role = "user"
else:
role = "admin"
# 给用户划分组
group_list = load_host_groups(sqlhelper)
# group_list对象在数据库操作中关闭链接后就没了，不知到为什么，copy一份
group_list_bak = copy.deepcopy(group_list)
# 开始新建一个用户
login_user.password = common.encry(password)
login_user.name = name
login_user.role = role
login_user.expired = expired
login_user.insert(group_list)
common.show_message("用户[{0}]创建成功!".format(username),
"INFORMATION")
# 给用户分配所属组下的主机登录用户,主机包含多个登录用户,给用户分配一个用户
choose = common.input_msg(
"需要现在给[{0}]分配各主机的管理用户吗?(y/n)".format(username),
limit_value=('y', 'n'))
if choose == "y":
hostobj = BLL_Hosts(sqlhelper)
sshuserobj = BLL_SSH_User(sqlhelper, hostobj)
# 保存所有主机登录用户的id，用于去重
ssh_user_set = []
for usergroup in group_list_bak:
# 根据用户的所属组获取各组下的所有主机
hostobj_list = hostobj.load_hosts_by_group(usergroup)
# 从主机列表遍历获取所有ssh用户信息
for host in hostobj_list:
sshuserobj.host = host
# 获取主机下的所有用户信息
sshuser_list = sshuserobj.load_users_by_host()
# 将这些信息添加到集合中，单条记录为字典格式
for sshuser in sshuser_list:
sshuser_info = dict(sid=sshuser.id,
username=sshuser.auth_user,
host=host.hostname,
group=usergroup.groupname)
ssh_user_set.append(sshuser_info)
# 全部遍历完成后的集合中存放的就是该用户可以使用的登录主机用户信息，下面用来选择
common.show_message("<--可以使用的用户列表-->", "INFORMATION")
for user in ssh_user_set:
print(
"用户ID: {0} 用户名: {1} 所属主机: {2} 所属组: {3}".format(
str(user['sid']).ljust(3, ' '),
user['username'].ljust(10, ' '),
user['host'].ljust(8, ' '),
user['group'].ljust(8, ' ')))
ssh_user_id_list = common.input_msg("请选择SSH用户ID(多个用,分隔): ")
# 当前处理的登录用户对象
curr_user = BLL_Login_User(sqlhelper)
curr_user.username = login_user.username
curr_user.insert_ssh_user(ssh_user_id_list)
common.show_message("分配成功!".format(username),
"INFORMATION")
else:
pass
except Exception as e:
common.write_log("[module.admin.add_login_user] {0}".format(e),
"ERROR")
