def run_unit_task(self, arg, stdout=False):
if arg in conf_data('shell_unit'):
cmd = conf_data('shell_unit', arg)
data = self.run_cmd_task(cmd, stdout)
return data
else:
return {"recode": 9, "redata": 'unit error'}
def __init__(self):
super(Nginx_Acl, self).__init__()
self.user = conf_data("user_info", "default_user")
service_script = conf_data("service_info", "local_service_script")
self.reload_cmd = " ".join([service_script, "nginx", "reload"])
self.deny_conf = conf_data("service_info", "nginx", "deny_conf")
self.cache = NetCache()
def run(self):
task = self.data.get("task")
arg = self.data.get("arg")
ip = self.data.get("ip")
user = self.data.get("user")
work_log.info(str(self.data))
if not user:
user = conf_data("user_info", "default_user")
elif user not in conf_data("user_info"):
return {"recode": 1, "redata": "input user error"}
if task == 'shell':
try:
info = HostBaseCmd(ip, user=user)
return info.run_cmd_task(arg)
except AttributeError as e:
work_log.error("ssh session create error")
work_log.error(str(e))
return {"recode": 1, "redata": "input format error"}
except Exception as e:
work_log.error("run_cmd_task error")
work_log.error(str(e))
return {"recode": 9, "redata": "run other error"}
elif task == 'unit':
info = HostBaseCmd(ip, user=user)
return info.run_unit_task(arg)
elif task == 'script':
info = HostBaseCmd(ip, user=user)
return info.run_cmd_task(arg)
else:
work_log.info("req format error")
return {"recode": 1, "redata": "format error"}
def __init__(self):
super(NetCache, self).__init__()
redis_host = conf_data('redis', 'host')
redis_port = conf_data('redis', 'port')
self.r = redis.StrictRedis(host=redis_host,
port=redis_port,
decode_responses=True)
self.NginxLockSet = 'set:nginxlockip'
def unit(self, arg):
work_log.info(f'unit: {arg}')
if arg in conf_data('shell_unit'):
cmd = conf_data('shell_unit', arg)
redata = self.task.cmd(cmd)
elif arg in ['disk_dict', 'uptime_dict', 'mem_dict']:
redata = self.task.unit(cmd)
else:
return {"recode": 9, "redata": 'unit error'}
data = {"recode": 0, "redata": redata}
return data
def run_unit_task(self, arg):
if arg in conf_data('shell_unit'):
cmd = conf_data('shell_unit', arg)
else:
return {"recode": 9, "redata": 'unit error'}
try:
recode, data = self.ssh_cmd(cmd, stdout=True)
return {"recode": recode, "redata": data}
except Exception as e:
work_log.error("run_unit_task error")
work_log.error(str(e))
return {"recode": 9, "redata": str(e)}
def send_mess(self, mobile_list, content):
rspXml_body = []
url = conf_data("sms_conf", "url")
password = conf_data("sms_conf", "passwd")
try:
work_log.info(url)
work_log.info(mobile_list)
work_log.info(content)
client = Client(url)
except Exception as e:
work_log.error("link sms webservice interface url error")
work_log.error(str(e))
return 1
for mobile in mobile_list:
reqXml = (
"""<?xml version=\"1.0\" encoding=\"UTF-8\"?> <SmsServiceReq><SmsList>
<Mobile>""" + mobile + """</Mobile>
<Contents><![CDATA[""" + content + """]]></Contents></SmsList>
</SmsServiceReq>""")
work_log.debug("-------------------------------------")
work_log.debug(str(mobile))
work_log.debug("send sms xml")
work_log.debug(str(reqXml))
work_log.debug("-------------------------------------")
action = "00"
target = "0101"
brief = self.md5s(password + action + reqXml + target)
try:
rspXml = client.service.smsService(target, action, reqXml,
brief)
work_log.info("send_mess yes-----------------------------")
work_log.info(str(mobile))
work_log.info(str(content))
work_log.info("send_mess rspXml---------------------------")
work_log.info(str(rspXml))
work_log.info("send_mess yes-----------------------------")
except Exception as e:
work_log.error("send_mess error----------------------------")
work_log.error(str(reqXml))
work_log.error("send_mess error----------------------------")
work_log.error(str(e))
work_log.error("send_mess error----------------------------")
return 2
rspXml_body.append(rspXml)
return rspXml_body
def v2_upload():
work_log.debug(str(request.path))
work_log.info("request host interface ip: %s" % (request.remote_addr))
try:
file = request.files["file"]
ip = request.form["ip"]
destdir = request.form["dir"]
user = request.form["user"]
if not ip or not destdir:
return "", 404
work_log.info(
f"upload file, ip: {ip}, filename: {file.filename}, dest: {destdir}, user: {user}"
)
tmp_dir = conf_data("work_tmp_dir")
local_tmp = os.path.join(tmp_dir, file.filename)
dest = os.path.join(destdir, file.filename)
file.save(local_tmp) # 保存临时文件
info = UpDownFile(ip, user)
data = info.upload(local_tmp, dest)
os.remove(local_tmp) # 删除临时文件
return jsonify(data)
except Exception as e:
work_log.error("upload file run error")
work_log.error(str(e))
return jsonify({"recode": 9, "redata": str(e)})
else:
return "", 200
def Shield(self, zone, ip, port, cancel=None):
hosts = conf_data("service_info", "nginx", zone)
if not cancel and port != "all":
# 屏蔽某个服务
cmd = f'sed -i "/{ip}:{port}/s/server/#server/g" {self.upstream_conf}'
elif not cancel and port == "all":
# 屏蔽某个主机
cmd = f'sed -i "/{ip}/s/server/#server/g" {self.upstream_conf}'
elif cancel and port != "all":
# 解除某个服务的屏蔽
# 遗留：配置本行末的注释会被影响
# 如果有多个#，则每次取消一个
cmd = f'sed -i "/{ip}:{port}/s/#//" {self.upstream_conf}'
elif cancel and port == "all":
cmd = f'sed -i "/{ip}/s/#//g" {self.upstream_conf}'
# 解除某个主机的屏蔽
info = HostGroupCmd(hosts, self.user)
try:
info.run_cmd_task(cmd)
info.run_cmd_task(self.reload_cmd)
# 没有报错就算成功了，暂时忽略了多个主机个别错误的情况
return {"recode": 0, "redata": "success"}
except Exception as e:
work_log.error(str(e))
return {"recode": 2, "redata": "remote run error"}
def down(self):
try:
ip = self.data.get("ip")
file = self.data.get("file")
user = self.data.get("user")
if self.data.get("task") != 'remote_file_down':
return {"recode": 1, "redata": "req arg error"}
work_log.info(
f"down file, ip: {ip}, filename: {file}, user: {user}")
tmp_dir = conf_data("work_tmp_dir")
filename = os.path.basename(file)
local_tmp = os.path.join(tmp_dir, filename)
info = UpDownFile(ip, user)
data = info.down(file, local_tmp)
if data:
return {"recode": 0, "redata": f"api/v2/downfile/{filename}"}
else:
return {"recode": 2, "redata": "file not fount"}
except Exception as e:
work_log.error("down file run error")
work_log.error(str(e))
return {"recode": 9, "redata": str(e)}
def net_port_scan(self, ip, port):
try:
work_dir = conf_data("work_dir")
source_file = work_dir + "/utils/port_scan.py"
des_file = "/tmp/port_scan.py"
work_log.debug("copy file to remote")
self.ssh_file_put(source_file, des_file)
except Exception as e:
work_log.error('scp port check file to remote server error')
return 9
cmd0 = "chmod u+x " + des_file
cmd1 = des_file + " " + ip + " " + str(port)
cmd2 = "rm " + des_file
try:
work_log.debug("chmod file")
self.ssh_cmd(cmd0)
work_log.debug("exec remote file")
cmdstatus, taskstatus = self.ssh_cmd(cmd1, stdout=True)
work_log.info(str(taskstatus))
work_log.debug("rm file to remote")
self.ssh_cmd(cmd2)
recode = int(taskstatus.rstrip("\n"))
work_log.info(str(recode))
except Exception as e:
work_log.error("remote exec cmd error")
work_log.error(str(e))
recode = 2
return recode
work_log.debug("port scan recode: %s" % recode)
def __init__(self, ip, user=None, scp=None):
if not user:
ssh_user = conf_data("user_info", "default_user")
else:
ssh_user = user
try:
ssh_pw = conf_data("user_info", str(ssh_user), "ssh_passwd")
key = conf_data("user_info", str(ssh_user), "ssh_key")
ssh_port = conf_data("user_info", "ssh_port")
except Exception as e:
work_log.info("ssh arg input error")
work_log.info(str(e))
raise e
self.ip = ip
if key:
ssh_key = conf_data("work_conf_dir") + "/" + key
try:
if ssh_key and not scp:
Myssh.__init__(self, ip, ssh_user, keys=ssh_key, port=ssh_port)
elif ssh_key and scp:
Myssh.__init__(self,
ip,
ssh_user,
keys=ssh_key,
port=ssh_port,
scp=True)
elif ssh_pw and scp:
Myssh.__init__(self,
ip,
ssh_user,
passwd=ssh_pw,
port=ssh_port,
scp=True)
elif ssh_pw and not scp:
Myssh.__init__(self,
ip,
ssh_user,
passwd=ssh_pw,
port=ssh_port)
except Exception as e:
work_log.error('ssh login server error')
work_log.error(str(e))
raise e
def v2_downfile(file_name):
'''从服务器自身的临时目录下载文件'''
work_log.debug("---------------")
work_log.debug(str(request.path))
work_log.info("request host interface ip: %s" % (request.remote_addr))
if request.method == "GET":
tmp_dir = conf_data("work_tmp_dir")
return send_from_directory(tmp_dir, file_name, as_attachment=True)
def get_host_task(self, ip):
'''获取一个主机的任务列表'''
data = []
for i in conf_data("app_group").values():
if ip in i:
for port in i.get(ip):
data.append([ip, port])
return data
work_log.info(data)
def showprojectlog(self):
# 查看业务日志
log_out = conf_data("service_info", "weblogic", "log_out")
cmd = "tail -n 500 " + log_out.replace("1",
str(int(self.port) - 17100))
run_data = self._weblogic_ssh_cmd(cmd)
if run_data[0] == 0:
return {"recode": run_data[0], "redata": run_data[1]}
else:
return {"recode": run_data[0], "redata": run_data[1]}
def showlogaccess(self):
# 查看访问日志
log_access = conf_data("service_info", "weblogic", "log_access")
cmd = "tail -n 300 " + log_access.replace("1",
str(int(self.port) - 17100))
run_data = self._weblogic_ssh_cmd(cmd)
if run_data[0] == 0:
return {"recode": run_data[0], "redata": run_data[1]}
else:
return {"recode": run_data[0], "redata": run_data[1]}
def check_group_weblogic_interface(self, groupname):
'''检查一组服务'''
UrlList = []
for x, y in conf_data("app_group", groupname).items():
for i in y:
url = self.get_wg_check_url(x, i)
UrlList.append(url)
data = self.check_weblogic(UrlList, processes=20)
return {"recode": 0, "redata": data}
def check_all_weblogic_interface(self):
'''检查全部服务'''
UrlList = []
group_all = conf_data("app_group")
for group in group_all:
for host in group_all.get(group):
for port in group_all.get(group).get(host):
url = self.get_wg_check_url(host, port)
UrlList.append(url)
data = self.check_weblogic(UrlList, processes=80)
return {"recode": 0, "redata": data}
def get_group_data(self):
unit_list = []
if self.group:
info = conf_data("mc_group", self.group)
for i in info:
ip = i.split()[0]
port = i.split()[1]
unit_list.append([ip, port])
return unit_list
if self.mc_list:
for i in self.mc_list:
host = i.split()[0]
port = i.split()[1]
unit_list.append([ip, port])
return unit_list
def run_task_list(self, cmdlist):
cmdlist.append(self.reload_cmd) # add reload
work_log.debug(f"{cmdlist}")
hosts = conf_data("service_info", "nginx", "dmz")
try:
info = HostGroupCmd(hosts, self.user)
for i in cmdlist:
work_log.info(f"nginx lock task, exec: {i}")
run_data_list = info.run_cmd_task(i)
work_log.info(str(run_data_list))
work_log.debug("--------------------------")
# 遗留问题，此处只处理了最后一个返回结果
return self.get_run_data(run_data_list)
work_log.debug("lock task all run")
# return {"redata": "success", "recode": 0}
except Exception as e:
work_log.error(str(e))
return {"recode": 2, "redata": "nginx server error"}
def __init__(self):
super(NginxManager, self).__init__()
self.user = conf_data("user_info", "default_user")
service_script = conf_data("service_info", "local_service_script")
self.start_cmd = " ".join([service_script, "nginx", "start"])
self.stop_cmd = " ".join([service_script, "nginx", "stop"])
self.reload_cmd = " ".join([service_script, "nginx", "reload"])
self.nginx_access_log = conf_data("service_info", "nginx",
"nginx_access_log")
self.nginx_error_log = conf_data("service_info", "nginx",
"nginx_error_log")
self.master_conf = conf_data("service_info", "nginx", "master_conf")
self.upstream_conf = conf_data("service_info", "nginx",
"upstream_conf")
def weblogic(self, data):
task = data.get("task")
types = data.get("types")
work_log.debug("---------------- weblogic task start ----------------")
if types == 'single':
work_log.debug(str(data))
server = data.get("server")
port = data.get("port")
info = WeblogicManagerSingle(server, port)
return info.run_task(task)
elif types == 'group':
group = data.get("group")
work_log.debug(group)
# 全部服务检查
if group == "all" and task == "check":
work_log.debug(f"wg check all service")
info = WeblogicManagerCheck()
return info.check_all_weblogic_interface()
if group not in conf_data("app_group"):
work_log.debug(f"weblogic grou not find")
return {"recode": 9, "redata": "参数错误"}
if task == "check":
work_log.debug(f"wg check group: {group}")
info = WeblogicManagerCheck()
return info.check_group_weblogic_interface(group)
elif task in ["start", "stop"]:
work_log.debug(f"wg group: {task} {group}")
info = WeblogicManagerGroup(group)
return info.run_task_group(task)
else:
work_log.debug(f"wg check args error")
return {"recode": 9, "redata": "参数错误"}
else:
work_log.debug(f"weblogic types args error")
return {"recode": 9, "redata": "参数错误"}
def memcached(self, data):
types = data.get("types")
task = data.get("task")
if types == 'single':
server = data.get("server")
port = data.get("port")
if task in ["start", "stop"]:
info = MemcachedManagerSingle(server, port)
return info.run_task(task)
if types == 'group':
group = data.get("group")
if group not in conf_data("mc_group"):
work_log.debug(f"memcached grou not find")
return {"recode": 9, "redata": "参数错误-group错误"}
if task in ["start", "stop"]:
info = MemcachedManagerGroup(group)
return info.run_task(task)
return {"recode": 1, "redata": "format error"}
return {"recode": 1, "redata": "format error"}
def run(self):
work_log.info(str(self.data))
task = self.data.get("task")
arg = self.data.get("arg")
ip = self.data.get("ip")
user = self.data.get("user")
group = self.data.get("group")
stdout = self.data.get("stdout")
if group:
if group in conf_data('host_mgr_type'):
ip = conf_data('host_mgr_type', group)
else:
work_log.info("group name error")
return {"recode": 1, "redata": "format error"}
if not user:
user = conf_data("user_info", "default_user")
elif user not in conf_data("user_info"):
return {"recode": 1, "redata": "input user error"}
if task == 'shell':
return self.group_task_exec(ip, user, arg, stdout)
elif task == 'unit':
if arg not in conf_data('shell_unit'):
return {"recode": 9, "redata": 'unit error'}
cmd = conf_data('shell_unit', arg)
return self.group_task_exec(ip, user, cmd, stdout)
elif task == 'script':
info = HostGroupCmd(ip, user=user)
return info.run_cmd_task(arg)
else:
work_log.info("req format error")
return {"recode": 1, "redata": "format error"}
def __init__(self, ip, port=None):
super(WeblogicManagerSingle, self).__init__()
self.ip = ip
self.port = port
self.user = conf_data("service_info", "weblogic", "default_user")
self.service_script = conf_data("service_info", "local_service_script")
def get_group_host(self):
info = conf_data("app_group", self.group)
return info.keys()
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from app.main.conf import conf_data
from app.utils.mylog import My_log
app = Flask(__name__)
db_url = conf_data('db', 'BUNNYC_MYSQL_URL')
db_user = conf_data('db', 'BUNNYC_MYSQL_USER')
db_pw = conf_data('db', 'BUNNYC_MYSQL_PW')
db_name = conf_data('db', 'BUNNYC_MYSQL_DB')
app.config[
'SQLALCHEMY_DATABASE_URI'] = f'mysql+pymysql://{db_user}:{db_pw}@{db_url}/{db_name}'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# app.config['SQLALCHEMY_ECHO'] = True
log_file = conf_data("work_log")
log_level = conf_data("log_level")
work_log = My_log(log_file, log_level).get_log()
db = SQLAlchemy(app)
from app.views import apiv2
from app.views import local
from app.views import host
from app.views import cmdb
from app.views import network
from app.views import nginx_acl
from app.views import monitor
from app.views import sms
def __init__(self, ip, port):
super(MemcachedManagerSingle, self).__init__()
self.ip = ip
self.port = port
self.user = conf_data("user_info", "default_user")
self.service_script = conf_data("service_info", "local_service_script")
def get_wg_check_url(self, ip, port):
'''拼接任务URL'''
return f"http://{ip}:{port}" + conf_data("service_info", "weblogic",
"weblogic_interface")
