def single_service(self, task):
# work_log.info("service weblogic task: %s , host: %s port: %s" % (task, self.ip, self.port))
work_log.info(
f"service weblogic task: {task} , host: {self.ip} port: {self.port}"
)
try:
if task == "start":
return self.start_weblogic_single_service()
elif task == "stop":
return self.stop_weblogic_single_service()
elif task == "accesslog":
return self.showlogaccess()
elif task == "projectlog":
return self.showprojectlog()
elif task == "gclog":
return self.showgclog()
elif task == "check":
work_log.info('check task')
info = WeblogicManagerCheck()
data = info.get_wg_single_service_status(self.ip, self.port)
return {"recode": 0, "redata": data}
except Exception as e:
work_log.error("single weblogic service run error")
work_log.error(str(e))
return {"recode": 2, "redata": str(e)}
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 sms_send():
work_log.debug('no phone arg')
if request.method == "GET":
work_log.debug(str(request.path))
phone = request.args.get("phone")
if not phone:
return "error", 404
else:
body = request.args.get("body")
work_log.info(str(body))
phone_list = phone.split(",")
work_log.debug(str(phone_list))
sms = Sms_tools()
data = sms.send_mess(phone_list, body)
if data == 1:
work_log.error("link sms webservice interface error")
return "", 510
elif data == 2:
work_log.error("webservice interface args error")
return "", 511
else:
work_log.debug(str("sms_send yes-------------"))
return "", 200
else:
work_log.error('other error')
return "error", 404
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 add_host(self, mess):
work_log.info(str(mess))
data = t_conf_host(
ip_v4=mess.get("ip_v4"),
ip_v6=mess.get("ip_v6"),
ip_v4_m=mess.get("ip_v4_m"),
name=mess.get("name"),
operating_system=mess.get("operating_system"),
hostname=mess.get("hostname"),
cpu_number=mess.get("cpu_number"),
memory_size=mess.get("memory_size"),
sn=mess.get("sn"),
address=mess.get("address"),
belong_machineroom=mess.get("belong_machineroom"),
rack=mess.get("rack"),
manufacturer=mess.get("manufacturer"),
dev_type=mess.get("type"),
dev_category=mess.get("dev_category"),
produce=mess.get("produce"),
level=mess.get("level"),
info=mess.get("info"),
)
try:
db.session.add(data)
db.session.commit()
work_log.info("add host --- yes")
return {"recode": 0, "redata": "ok"}
except Exception as e:
work_log.error("add host --- error")
work_log.error(str(e))
return {"recode": 9, "redata": "error"}
def ssh_cmd(self, cmd, stdout=False):
work_log.info("ssh_cmd host: %s cmd: %s" % (self.ip, cmd))
try:
run_stdout, run_stderr = self.runshell(cmd)
if run_stderr:
# 先记录执行的错误输出
work_log.error("ssh_cmd is error stdout")
work_log.error(str(run_stderr))
# 需要标准输出的情况
if stdout:
if run_stderr:
return [2, run_stderr.decode("utf-8")]
else:
work_log.debug("ssh_cmd success, run_stdout")
work_log.debug(str(run_stdout))
return [0, run_stdout.decode("utf-8")]
# 不需要标准输出的情况
if run_stderr:
return [2, run_stderr.decode("utf-8")]
else:
work_log.debug("ssh_cmd success, run_stdout")
work_log.debug(str(run_stdout))
return [0, "success"]
except Exception as e:
work_log.error("ssh_cmd Exception error")
work_log.error(str(e))
return False
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 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 stats(self):
try:
data = self.mc.stats_str()
work_log.info(data)
return {"recode": 0, "redata": data}
except Exception as e:
work_log.error("get memcached data error")
work_log.error(str(e))
return {"recode": 9, "redata": "error"}
def upload(self, src, dest):
work_log.info(f"upload: {src} -> {dest}")
try:
self.put(src, dest)
return {"recode": 0, "redata": "上传成功"}
except Exception as e:
work_log.error("upload error")
work_log.error(str(e))
return {"recode": 9, "redata": "上传失败"}
def down(self, src, localfile):
work_log.info(f"down: {src}, {localfile}")
try:
self.get(src, localfile)
return True
except Exception as e:
work_log.error("upload error")
work_log.error(str(e))
return False
def ssh_file_put(self, source_file, des_file):
work_log.info("ssh_file_put host: %s =>> %s" % (source_file, des_file))
try:
self.put(source_file, des_file)
work_log.info("ssh_file_put success")
except Exception as e:
work_log.error("ssh_file_put error")
work_log.error(str(e))
return False
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 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 _weblogic_ssh_cmd(self, cmd):
work_log.info("weblogic_ssh host: %s cmd: %s" % (self.ip, cmd))
try:
ssh = HostBaseCmd(self.ip, user=self.user)
data = ssh.ssh_cmd(cmd, stdout=True)
work_log.debug("_weblogic_ssh_cmd redata: %s" % str(data))
return data
except Exception as e:
work_log.error("_weblogic_ssh_cmd Exception error")
work_log.error(str(e))
return [2, str(e)]
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 nginx_lock(self, data):
task = data.get('task')
ip = data.get("ip")
if not isinstance(ip, list):
iplist = []
iplist.append(ip)
else:
iplist = ip
info = Nginx_Acl()
# if ip not in re.compile("\d+.\d+.\d+.\d+").findall(ip):
# return {"recode": 2, "redata": "req format error"}
# 暂时停止IP地址校验，因为还没有考虑ipv6
if task == 'lock':
work_log.info(f"nginx task: lock, ip: {iplist}")
return info.lock_ip(iplist)
elif task == 'unlock':
work_log.info(f"nginx task: unlock, ip: {iplist}")
return info.unlock_ip(iplist)
elif task == "showlock":
work_log.info("nginx task: showlock")
return info.show_lock()
elif task == "clearlock":
work_log.info("nginx task: clearlock")
return info.clear_lock()
else:
return {"redata": 'task error', "recode": 1}
def remote_check_port(self, server, ip, port):
work_log.info('login remote server check port')
try:
info = HostBaseCmd(server, scp=True)
redata = info.net_port_scan(ip=ip, port=port)
except Exception as e:
work_log.error(str(e))
return {"recode": 9, 'redata': '连接服务器失败'}
work_log.debug("port scan status: "+str(redata))
if redata == 0:
return {"recode": 0, 'redata': '探测成功'}
else:
return {"recode": 4, 'redata': '探测失败'}
def local_ping(self, ip):
work_log.info("networkmanager ping host: " + str(ip))
recode = self.host_ping_check(ip)
if recode == 0:
redata = "成功"
elif recode == 3:
redata = "服务器端解析错误"
elif recode == 4:
redata = "目标不存在"
else:
redata = "失败"
data = {"recode": recode, "redata": redata}
return data
def check_url(self, url):
work_log.info("checkweburl: " + str(url))
try:
info = CheckWebInterface()
recode = info.get_url_status_code(url, timeout=2)
work_log.debug(str(recode))
if recode == 200:
return {"recode": 0, "redata": "success 成功"}
else:
return {"recode": recode, "redata": "error"}
except Exception as e:
work_log.error("checkweburl error")
work_log.error(str(e))
return {"recode": 9, "redata": "server error"}
def port_check(self, ip, port):
try:
tn = telnetlib.Telnet(ip, port=port, timeout=3)
tn.close()
work_log.info("port_check yes")
work_log.info("desc_host: %s ,port: %s" % (ip, str(port)))
return 0
except ConnectionRefusedError:
work_log.error("port_check error")
work_log.error("ConnectionRefusedError")
return 1
except Exception as e:
work_log.error("port_check error")
work_log.error(str(e))
return 2
def v2_hosts():
work_log.debug(str(request.path))
try:
key = request.json.get("key")
if verify_key(key) and request.json.get("obj") == "hosts":
info = HostsTask(request.json.get("content"))
data = info.run()
work_log.info(str(data))
return jsonify(data)
else:
work_log.error("req verify_key or obj error")
return "", 404
except Exception as e:
work_log.error("hosts run error")
work_log.error(str(e))
return jsonify({"recode": 9, "redata": str(e)})
def v2_monitor():
work_log.info("request MonitorTask interface ip: %s" %
(request.remote_addr))
try:
key = request.json.get("key")
if verify_key(key) and request.json.get("obj") == "monitor":
info = MonitorTask()
data = info.run(request.json.get("content"))
work_log.info(str(data))
return jsonify(data)
else:
work_log.error("format error")
return "", 404
except Exception as e:
work_log.error(str(e))
return jsonify({"recode": 1, "redata": "run error"})
def nginx_shield(self, data):
# "shield", "cancelShield"
# 屏蔽/解除屏蔽-后台应用服务
ip = data.get("ip")
port = data.get("port")
zone = data.get("zone")
task = data.get("task")
info = NginxManager()
work_log.info(
f"nginx task: {task}, zone: {zone} ip: {ip}, port: {port}")
if task == "shield":
return info.Shield(zone, ip, port)
elif task == "cancelShield":
return info.Shield(zone, ip, port, cancel=True)
else:
return {"recode": 1, "redata": "req format task error"}
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 single_host_server(self, task):
work_log.info("server weblogic task not port, all service")
try:
if task == "start":
return self.start_wg_single()
elif task == "stop":
return self.stop_wg_single()
elif task == "check":
info = WeblogicManagerCheck()
data = info.get_wg_single_server_status(self.ip)
return {"recode": 0, "redata": data}
else:
return {"recode": 4, "redata": "不支持该操作"}
except Exception as e:
work_log.error("single weblogic service run error")
work_log.error(str(e))
return {"recode": 2, "redata": str(e)}
def v2_service():
work_log.debug(str(request.path))
work_log.debug("request service interface, ip: %s " %
(request.remote_addr))
try:
key = request.json.get("key")
if verify_key(key) and request.json.get("obj") == "service":
info = Service()
data = info.run_task(request.json.get("content"))
work_log.info(str(data))
return jsonify(data)
else:
work_log.error("req verify_key or obj error")
return "", 404
except Exception as e:
work_log.error("req format error")
work_log.error(str(e))
return "", 404
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 v2_down():
'''原理：从指定服务器上下载文件到临时目录，再返回一个文件的get下载路径'''
work_log.debug("---------------")
work_log.debug(str(request.path))
work_log.info("request host interface ip: %s" % (request.remote_addr))
try:
key = request.json.get("key")
if not verify_key(key) and request.json.get("obj") != "file":
work_log.error("req verify_key or obj error")
return "", 404
except Exception as e:
work_log.error(str(e))
work_log.error("req verify_key or obj error")
return "", 404
info = DownRemoteFile(request.json.get("content"))
data = info.down()
return jsonify(data)
def group_task_exec(self, ip, user, arg, stdout):
try:
if stdout:
info = HostGroupCmd(ip, user=user)
data = info.run_cmd_task(arg, stdout=True)
return {"recode": 0, "redata": data}
else:
work_log.info('---------shell -- not stdout')
info = HostGroupCmd(ip, user=user)
data = info.run_cmd_task(arg, stdout=False)
return self.polymerization(data)
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"}
