| |
| |
| |
| |
| |
| |
| |
| |
|
|
| |
| |
| |
| import os, sys, re, json, shutil, psutil, time |
| import datetime |
| import pwd |
| from projectModel.base import projectBase |
| from projectModel.watchModel import use_project_watch, add_project_watch, del_project_watch |
| import public, firewalls |
|
|
| try: |
| from BTPanel import cache |
| except: |
| pass |
| from xml.etree.ElementTree import ElementTree, Element |
|
|
|
|
| class mobj: |
| port = ps = '' |
|
|
|
|
| class main(projectBase): |
| _panel_path = public.get_panel_path() |
| __bttomcat_path = '/usr/local/bttomcat' |
| __jdk_path = '/usr/lib/jvm/' |
| __btjdk_path = '/usr/local/btjdk/' |
| _log_name = '项目管理' |
| __tomcat7_server = '/usr/local/bttomcat/tomcat7/conf/server.xml' |
| __tomcat8_server = '/usr/local/bttomcat/tomcat8/conf/server.xml' |
| __tomcat9_server = '/usr/local/bttomcat/tomcat9/conf/server.xml' |
| __tomcat7_path = '/usr/local/bttomcat/tomcat7' |
| __tomcat8_path = '/usr/local/bttomcat/tomcat8' |
| __tomcat9_path = '/usr/local/bttomcat/tomcat9' |
| __tomcat7_path_bak = '/usr/local/bttomcat/tomcat_bak7' |
| __tomcat8_path_bak = '/usr/local/bttomcat/tomcat_bak8' |
| __tomcat9_path_bak = '/usr/local/bttomcat/tomcat_bak9' |
| __site_path = '/www/server/bt_tomcat_web/' |
| _springboot = '/var/tmp/springboot' |
| _springboot_pid_path = '{}/vhost/pids'.format(_springboot) |
| _springboot_logs_path = '/www/wwwlogs/java/springboot' |
| _springboot_logs = '{}/vhost/logs'.format(_springboot) |
| _springboot_run_scripts = '{}/vhost/scripts'.format(_springboot) |
| __log_split_script_py = public.get_panel_path() + '/script/run_log_split.py' |
| _pids = None |
| __TREE = None |
| __ENGINE = None |
| __ROOT = None |
| __CONF_FILE = '' |
| __CONNECTROR = '' |
| _vhost_path = '{}/vhost'.format(_panel_path) |
| |
| def __init__(self): |
| if not os.path.exists(self.__site_path): |
| os.makedirs(self.__site_path) |
| if not os.path.exists(self.__bttomcat_path): |
| os.makedirs(self.__bttomcat_path) |
| if not os.path.exists(self.__btjdk_path): |
| os.makedirs(self.__btjdk_path) |
| if not os.path.exists(self._springboot): |
| os.makedirs(self._springboot) |
| if not os.path.exists(self._springboot_pid_path): |
| os.makedirs(self._springboot_pid_path) |
| if not os.path.exists(self._springboot_logs_path): |
| os.makedirs(self._springboot_logs_path) |
| if not os.path.exists(self._springboot_logs): |
| os.makedirs(self._springboot_logs) |
| if not os.path.exists(self._springboot_run_scripts): |
| os.makedirs(self._springboot_run_scripts) |
| |
| def test(self, get): |
| |
| return type(get.domains) |
| |
| def get_os_version(self, get): |
| """ |
| @name 获取操作系统版本的安装命令 |
| @author lkq<2021-08-25> |
| @param get<dict_obj> |
| @return string |
| """ |
| |
| if os.path.exists('/usr/bin/yum') and os.path.exists('/etc/yum.conf'): |
| return 'Centos' |
| |
| if os.path.exists('/usr/bin/apt-get') and os.path.exists('/usr/bin/dpkg'): |
| return 'Ubuntu' |
| return 'Unknown' |
| |
| def get_jdk_version(self, get): |
| ''' |
| @name 获取JDK 版本 |
| @author lkq<2021-08-25> |
| @param get<dict_obj> |
| @return string |
| ''' |
| ret = [] |
| ret2 = {} |
| if not 'JDK11' in ret2: |
| ret2['JDK11'] = {} |
| ret2['JDK11']['status'] = False |
| if not 'JDK8' in ret2: |
| ret2['JDK8'] = {} |
| ret2['JDK8']['status'] = False |
| if not os.path.exists(self.__jdk_path): return ret2 |
| for root, dirs, files in os.walk(self.__jdk_path): |
| for i2 in dirs: |
| if not os.path.islink(self.__jdk_path + i2): |
| ret.append(self.__jdk_path + i2) |
| break |
| for i in ret: |
| if os.path.exists(i): |
| if 'java-1.8' in i or 'java-8' in i: |
| |
| result = self.check_jdk(i) |
| java_ret = {} |
| if result: |
| java_ret['path'] = result |
| java_ret['status'] = True |
| java_ret['is_error'] = False |
| else: |
| java_ret['is_error'] = True |
| ret2['JDK8'] = java_ret |
| if 'java-11' in i or 'openjdk-11' in i: |
| result = self.check_jdk(i) |
| java_ret = {} |
| if result: |
| java_ret['path'] = i |
| java_ret['is_error'] = False |
| java_ret['status'] = True |
| else: |
| java_ret['is_error'] = True |
| ret2['JDK11'] = java_ret |
| return ret2 |
| |
| def install_jdk(self, get): |
| ''' |
| @name 安装JDK 版本 |
| @author lkq<2021-08-25> |
| @param get<dict_obj> |
| @param get.jdk_version<string> |
| @return string |
| ''' |
| tmp_file = '/tmp/panelShell.pl' |
| jdk_version = get.jdk_version.strip() |
| if jdk_version == '': return public.returnMsg(False, 'JDK版本不能为空!') |
| jdk_list = ['8', '11'] |
| if not jdk_version in jdk_list: return public.returnMsg(False, 'JDK版本只能为8或11!') |
| os_version = self.get_os_version(None) |
| if os_version == 'Centos': |
| if jdk_version == '8': |
| public.ExecShell('yum install java-1.8.0-openjdk java-1.8.0-openjdk-devel -y >>%s' % tmp_file) |
| elif jdk_version == '11': |
| public.ExecShell('yum install java-11-openjdk java-11-openjdk-devel -y >>%s' % tmp_file) |
| else: |
| return public.returnMsg(False, 'JDK版本只能为8或11!') |
| |
| jdk_data = self.get_jdk_version(None) |
| if jdk_data['JDK%s' % jdk_version]['status']: |
| |
| return public.returnMsg(True, '安装成功!') |
| else: |
| public.WriteFile(tmp_file, 'Error:请查看yum源是否正常', 'a+') |
| return public.returnMsg(False, '安装失败!') |
| elif os_version == 'Ubuntu': |
| if jdk_version == '8': |
| public.ExecShell('apt-get install -y openjdk-8-jre openjdk-8-jdk >>%s' % tmp_file) |
| elif jdk_version == '11': |
| public.ExecShell('apt-get install -y openjdk-11-jre openjdk-11-jdk >>%s' % tmp_file) |
| else: |
| return public.returnMsg(False, 'JDK版本只能为8或11!') |
| |
| jdk_data = self.get_jdk_version(None) |
| if jdk_data['JDK%s' % jdk_version]['status']: |
| |
| return public.returnMsg(True, '安装成功!') |
| else: |
| public.WriteFile(tmp_file, 'Error:请查看apt源是否正常', 'a+') |
| return public.returnMsg(False, '安装失败!') |
| else: |
| public.WriteFile(tmp_file, 'Error:不支持此操作系统', 'a+') |
| return public.returnMsg(False, '操作系统不支持!') |
| |
| def remove_jdk(self, get): |
| ''' |
| @name 删除JDK |
| @author lkq |
| @param get |
| @param get.jdk_version JDK版本 |
| @return |
| ''' |
| jdk_version = get.jdk_version.strip() |
| os_version = self.get_os_version(None) |
| tmp_file = '/tmp/panelShell.pl' |
| if os_version == 'Centos': |
| if jdk_version == '8': |
| public.ExecShell('yum remove java-1.8.0-openjdk java-1.8.0-openjdk-devel -y >>%s' % tmp_file) |
| elif jdk_version == '11': |
| public.ExecShell('yum remove java-11-openjdk java-11-openjdk-devel -y >>%s' % tmp_file) |
| else: |
| return public.returnMsg(False, 'JDK版本只能为8或11!') |
| |
| return public.returnMsg(True, '卸载成功') |
| elif os_version == 'Ubuntu': |
| if jdk_version == '8': |
| public.ExecShell('apt-get remove -y openjdk-8-jre openjdk-8-jdk >>%s' % tmp_file) |
| elif jdk_version == '11': |
| public.ExecShell('apt-get remove -y openjdk-11-jre openjdk-11-jdk>>%s' % tmp_file) |
| else: |
| return public.returnMsg(False, 'JDK版本只能为8或11!') |
| |
| return public.returnMsg(True, '卸载成功') |
| |
| def check_jdk(self, jdk_path=None): |
| ''' |
| @name 检查JDK版本是否可以用 |
| @author lkq<2021-08-25> |
| @param get<dict_obj> |
| @return string |
| ''' |
| java_path = jdk_path + '/jre/bin/java' |
| java_path2 = jdk_path + '/bin/java' |
| if os.path.exists(java_path): |
| ret = public.ExecShell(java_path + ' -version') |
| if ret[0].find('Error occurred') != -1: |
| return False |
| return java_path |
| elif os.path.exists(java_path2): |
| ret = public.ExecShell(java_path2 + ' -version') |
| if ret[0].find('Error occurred') != -1: |
| return False |
| return java_path2 |
| else: |
| return False |
| |
| def replace_jdk_version(self, get): |
| ''' |
| @name 修改JDK版本 |
| @author lkq<2021-08-27> |
| @param get.tomcat_start tomcat启动脚本路径 |
| @param get.jdk_path JDK路径 |
| @return string |
| ''' |
| jdk_path = get.jdk_path.strip() |
| jdk_path2 = jdk_path.split('/') |
| if jdk_path2[-1] == 'java': |
| if jdk_path2[-3] == 'jre': |
| jdk_path2 = '/'.join(jdk_path2[:-3]) |
| if jdk_path2[-2] == 'bin': |
| jdk_path2 = '/'.join(jdk_path2[:-2]) |
| else: |
| jdk_path2 = '/'.join(jdk_path2[:-1]) |
| |
| jdk_path = jdk_path2 |
| jdk_data = self.check_jdk(jdk_path) |
| if not jdk_data: return public.returnMsg(False, '请输入正确的JDK路径,例如:/www/server/jdk1.8/bin/java') |
| if jdk_data: |
| if not os.path.exists(jdk_data): return public.returnMsg(False, 'JDK目录不存在!') |
| if not jdk_data: return public.returnMsg(False, '当前输入的JDK不可用!') |
| tomcat_start = get.tomcat_start.strip() |
| if not os.path.exists(tomcat_start): return public.returnMsg(False, 'tomcat启动脚本不存在!') |
| tomcat_start_file = public.ReadFile(tomcat_start) |
| if isinstance(tomcat_start_file, str): |
| |
| jdk_path_re = re.findall('^JAVA_HOME=(.*)$', tomcat_start_file, re.M) |
| if jdk_path_re: |
| tomcat_start_file = tomcat_start_file.replace(jdk_path_re[0], jdk_path) |
| public.WriteFile(tomcat_start, tomcat_start_file) |
| |
| public.ExecShell('bash %s stop' % (tomcat_start)) |
| public.ExecShell('bash %s start' % (tomcat_start)) |
| return public.returnMsg(True, '修改成功!') |
| return public.returnMsg(False, '修改失败!') |
| |
| def get_tomcat_version(self, get): |
| ''' |
| @name 获取tomcat版本信息 |
| @author lkq<2021-08-27> |
| @param get<dict_obj> |
| @return string |
| ''' |
| ret = ["7", "8", "9", "10"] |
| default_path = "/usr/local/btjdk/jdk8/bin/java" |
| ret2 = { |
| 'tomcat7': {'status': False, "jdk_path": default_path}, |
| 'tomcat8': {'status': False, "jdk_path": default_path}, |
| 'tomcat9': {'status': False, "jdk_path": default_path}, |
| 'tomcat10': {'status': False, "jdk_path": default_path}, |
| } |
| rep_deemon_sh = re.compile(r"^JAVA_HOME=(?P<path>.*)\n", re.M) |
| for i in ret: |
| tmp_path = self.__bttomcat_path + '/tomcat' + i + "/bin/daemon.sh" |
| if os.path.exists(tmp_path): |
| tmp_data = public.readFile(tmp_path) |
| if isinstance(tmp_data, str): |
| re_res_jdk_path = rep_deemon_sh.search(tmp_data) |
| if re_res_jdk_path: |
| ret2["tomcat" + i]["jdk_path"] = re_res_jdk_path.group("path").strip() |
| ret2["tomcat" + i]["status"] = True |
| ret2["tomcat" + i]["path"] = self.__bttomcat_path + '/tomcat' + i |
| ret2["tomcat" + i]["start_path"] = "/etc/init.d/bttomcat" + i |
| ret2["tomcat" + i]["info"] = self.get_tomcat_info(version = i) |
| if i == '7': |
| ret2["tomcat" + i]["tomcat_server"] = self.__tomcat7_server |
| ret2["tomcat" + i]["tomcat_start"] = self.__tomcat7_path + '/bin/daemon.sh' |
| elif i == '8': |
| ret2["tomcat" + i]["tomcat_server"] = self.__tomcat8_server |
| ret2["tomcat" + i]["tomcat_start"] = self.__tomcat8_path + '/bin/daemon.sh' |
| elif i == '9': |
| ret2["tomcat" + i]["tomcat_server"] = self.__tomcat9_server |
| ret2["tomcat" + i]["tomcat_start"] = self.__tomcat9_path + '/bin/daemon.sh' |
| elif i == '10': |
| ret2["tomcat" + i]["tomcat_server"] = '/usr/local/bttomcat/tomcat10/conf/server.xml' |
| ret2["tomcat" + i]["tomcat_start"] = "/usr/local/bttomcat/tomcat10/bin/daemon.sh" |
| return ret2 |
| |
| def get_tomcat_info(self, version): |
| ''' |
| @name 获取tomcat版本信息 |
| @author lkq<2021-08-27> |
| @param version tomcat版本 7 8 9 |
| @return string |
| ''' |
| tmp = {} |
| tmp_path = '/usr/local/bttomcat/tomcat%s/conf/server.xml' % version |
| if os.path.exists(tmp_path): |
| if not self.Initialization(version): |
| tmp["port"] = False |
| else: |
| tmp["port"] = self.get_port() |
| tmp['status'] = self.get_server(version) |
| tmp['conf'] = public.readFile(tmp_path) |
| tmp['jdk_path'] = self.get_jdk_path(version) |
| |
| tmp['stype'] = 'built' |
| else: |
| tmp['status'] = False |
| tmp["port"] = False |
| tmp['conf'] = False |
| tmp['jdk'] = False |
| tmp['log'] = False |
| tmp['stype'] = 'uninstall' |
| return tmp |
| |
| def install_tomcat(self, get): |
| ''' |
| @name 安装tomcat版本 |
| @author lkq<2021-08-27> |
| @param get<dict_obj> |
| @param get.version 安装|卸载的版本 |
| @param get.type install ==安装 uninstall ==卸载 |
| @return string |
| ''' |
| tmp_file = '/tmp/panelShell2.pl' |
| if not os.path.exists(tmp_file): |
| public.ExecShell("touch /tmp/panelShell2.pl") |
| else: |
| public.ExecShell("echo ""> /tmp/panelShell2.pl") |
| version = str(get.version) |
| os_ver = self.get_os_version(None) |
| if 'type' not in get: |
| return public.returnMsg(False, '参数错误!') |
| type_list = ['install', 'uninstall'] |
| if not get.type in type_list: |
| return public.returnMsg(False, '安装卸载只能是install或者uninstall!') |
| if version == "7": |
| if os_ver == 'Ubuntu': |
| return public.returnMsg(False, '操作系统不支持!') |
| download_url = self.test_download_url() |
| if get.type != 'install' and os.path.exists("/tmp/1.sh"): |
| public.ExecShell("bash /tmp/1.sh %s %s >>%s" % (get.type, version, tmp_file)) |
| else: |
| if download_url is None: |
| error = '<br>错误：连接宝塔官网异常，请按照以下方法排除问题后重试：<br>解决方法：<a target="_blank" class="btlink" href="https://www.bt.cn/bbs/thread-87257-1-1.html">https://www.bt.cn/bbs/thread-87257-1-1.html</a><br>' |
| raise public.PanelError(error) |
| |
| public.ExecShell( |
| "rm -rf /tmp/1.sh && /usr/local/curl/bin/curl -o /tmp/1.sh %s/install/src/webserver/shell/new_jdk.sh && bash /tmp/1.sh %s %s >>%s" % ( |
| download_url, get.type, version, tmp_file) |
| ) |
| |
| |
| tomcat_status = self.get_tomcat_version(None) |
| if get.type == 'install': |
| if tomcat_status['tomcat' + version]['status']: |
| return public.returnMsg(True, '安装成功!') |
| else: |
| return public.returnMsg(False, '安装失败!') |
| else: |
| if not tomcat_status['tomcat' + version]['status']: |
| return public.returnMsg(True, '卸载成功!') |
| else: |
| return public.returnMsg(False, '卸载失败!') |
| |
| @staticmethod |
| def test_download_url(): |
| _sh = """ |
| . /www/server/panel/install/public.sh |
| curl -s -o /dev/null "${NODE_URL}" |
| if [ $? -ne 0 ]; then |
| echo "网络链接错误" |
| exit |
| fi |
| echo "${NODE_URL}" |
| """ |
| res: str = public.ExecShell(_sh)[0] |
| if res.find("网络链接错误") != -1: |
| return None |
| else: |
| return res.split("\n")[-2].strip() |
| |
| @staticmethod |
| def _get_jdk_version_by_jdk_path(jdk_path): |
| pass |
| |
| def install_tomcat_new(self, get): |
| ''' |
| @name 安装tomcat版本 |
| @author lkq<2021-08-27> |
| @param get<dict_obj> |
| @param get.version 安装|卸载的版本 |
| @param get.type install ==安装 uninstall ==卸载 |
| @param get.jdk_path 使用其他的jdk版本 |
| @return string |
| ''' |
| try: |
| jdk_path = "" |
| version = str(int(get.version)) |
| action = get.type.strip() |
| if "jdk_path" in get: |
| jdk_path = get.jdk_path.strip() |
| except (AttributeError, TypeError, ValueError): |
| return public.returnMsg(False, "参数错误") |
| |
| if action not in ('install', 'uninstall'): |
| return public.returnMsg(False, '安装卸载只能是install或者uninstall!') |
| os_ver = self.get_os_version(None) |
| if version == "7": |
| if os_ver == 'Ubuntu': |
| return public.returnMsg(False, '操作系统不支持!') |
| |
| if jdk_path: |
| if jdk_path.endswith("/bin/java"): |
| jdk_path = jdk_path[:-9] |
| _, error = public.ExecShell("{}/bin/java -version".format(jdk_path)) |
| |
| |
| if not (error.find("version") != -1 and error.find("Runtime") != -1): |
| return public.returnMsg(False, "指定的jdk不可用") |
| |
| tmp_file = '/tmp/panelShell2.pl' |
| public.writeFile(tmp_file, "") |
| |
| download_url = self.test_download_url() |
| if download_url is None: |
| error = ( |
| '<br>错误：连接宝塔官网异常，请按照以下方法排除问题后重试：<br>解决方法：' |
| '<a target="_blank" class="btlink" href="https://www.bt.cn/bbs/thread-87257-1-1.html">' |
| 'https://www.bt.cn/bbs/thread-87257-1-1.html</a><br>' |
| ) |
| raise public.PanelError(error) |
| |
| shell_str = ( |
| 'rm -rf /tmp/1.sh && ' |
| 'wget -O /tmp/1.sh %s/install/src/webserver/shell/new_jdk.sh && ' |
| 'bash /tmp/1.sh %s %s %s >>%s' |
| ) % (download_url, action, version, jdk_path, tmp_file) |
| |
| |
| |
| |
| _, _ = public.ExecShell(shell_str) |
| |
| tomcat_status = self.get_tomcat_version(None) |
| if action == 'install': |
| if tomcat_status['tomcat' + version]['status']: |
| return public.returnMsg(True, '安装成功!') |
| else: |
| return public.returnMsg(False, '安装失败!') |
| else: |
| if not tomcat_status['tomcat' + version]['status']: |
| return public.returnMsg(True, '卸载成功!') |
| else: |
| return public.returnMsg(False, '卸载失败!') |
| |
| @staticmethod |
| def change_tomcat_jdk(get): |
| try: |
| version_str = get.version |
| if version_str.startswith("tomcat") or version_str.startswith("Tomcat"): |
| version_str = version_str.replace("tomcat", "").replace("Tomcat", "") |
| version = str(int(version_str)) |
| jdk_path: str = get.jdk_path.strip() |
| except (AttributeError, TypeError, ValueError): |
| return public.returnMsg(False, "参数错误") |
| |
| if not os.path.exists(jdk_path): |
| return public.returnMsg(False, "指定的jdk路径不存在") |
| if jdk_path.endswith("/bin/java"): |
| jdk_path = jdk_path[:-9] |
| |
| _, error = public.ExecShell("{}/bin/java -version".format(jdk_path)) |
| if not (error.find("version") != -1 and error.find("Runtime") != -1): |
| return public.returnMsg(False, "指定的jdk不可用") |
| |
| tomcat_path = "/usr/local/bttomcat/tomcat{}".format(version) |
| if not os.path.isdir(tomcat_path): |
| return public.returnMsg(False, '没有安装Tomcat{}!'.format(version)) |
| |
| deemon_sh_path = "{}/bin/daemon.sh".format(tomcat_path) |
| if not os.path.isfile(deemon_sh_path): |
| return public.returnMsg(False, 'Tomcat{}启动文件丢失!'.format(version)) |
| |
| deemon_sh_data = public.readFile(deemon_sh_path) |
| if not isinstance(deemon_sh_data, str): |
| return public.returnMsg(False, 'Tomcat{}启动文件读取失败!'.format(version)) |
| |
| |
| rep_deemon_sh = re.compile(r"^JAVA_HOME=(?P<path>.*)\n", re.M) |
| re_res_deemon_sh = rep_deemon_sh.search(deemon_sh_data) |
| if not re_res_deemon_sh: |
| return public.returnMsg(False, 'Tomcat{}启动文件解析失败!'.format(version)) |
| |
| jsvc_make_path = None |
| for i in os.listdir(tomcat_path + "/bin"): |
| tmp_dir = "{}/bin/{}".format(tomcat_path, i) |
| if i.startswith("commons-daemon") and os.path.isdir(tmp_dir): |
| make_path = tmp_dir + "/unix" |
| if os.path.isdir(make_path): |
| jsvc_make_path = make_path |
| break |
| |
| if jsvc_make_path is None: |
| return public.returnMsg(False, 'Jsvc{}文件丢失!'.format(version)) |
| |
| |
| if os.path.isfile(tomcat_path + "/bin/jsvc"): |
| os.remove(tomcat_path + "/bin/jsvc") |
| |
| if os.path.isfile(jsvc_make_path + "/jsvc"): |
| os.remove(jsvc_make_path + "/jsvc") |
| |
| shell_str = r''' |
| cd {} |
| make clean |
| ./configure --with-java={} |
| make |
| \cp jsvc {} |
| '''.format(jsvc_make_path, jdk_path, tomcat_path + "/bin/jsvc") |
| public.ExecShell(shell_str) |
| |
| new_deemon_sh_data = deemon_sh_data[:re_res_deemon_sh.start()] + ( |
| 'JAVA_HOME={}\n'.format(jdk_path) |
| ) + deemon_sh_data[re_res_deemon_sh.end():] |
| public.writeFile(deemon_sh_path, new_deemon_sh_data) |
| return public.returnMsg(True, '修改成功') |
| |
| def change_duli_tomcat_jdk(self, project_name, jdk_path): |
| project_info = self.get_project_find(project_name) |
| if not project_info: |
| return public.returnMsg(False, "项目不存在") |
| project_conf = project_info['project_config'] |
| if project_conf["java_type"] != "duli": |
| return public.returnMsg(False, "项目类型错误") |
| |
| if not os.path.exists(jdk_path): |
| return public.returnMsg(False, "指定的jdk路径不存在") |
| if jdk_path.endswith("/bin/java"): |
| jdk_path = jdk_path[:-9] |
| |
| _, error = public.ExecShell("{}/bin/java -version".format(jdk_path)) |
| if not (error.find("version") != -1 and error.find("Runtime") != -1): |
| return public.returnMsg(False, "指定的jdk不可用") |
| |
| tomcat_path = "/www/server/bt_tomcat_web/{}".format(project_name) |
| if not os.path.isdir(tomcat_path): |
| return public.returnMsg(False, '没有安装Tomcat!') |
| |
| deemon_sh_path = "{}/bin/daemon.sh".format(tomcat_path) |
| if not os.path.isfile(deemon_sh_path): |
| return public.returnMsg(False, 'Tomcat启动文件丢失!') |
| |
| deemon_sh_data = public.readFile(deemon_sh_path) |
| if not isinstance(deemon_sh_data, str): |
| return public.returnMsg(False, 'Tomcat启动文件读取失败!') |
| |
| |
| rep_deemon_sh = re.compile(r"^JAVA_HOME=(?P<path>.*)\n", re.M) |
| re_res_deemon_sh = rep_deemon_sh.search(deemon_sh_data) |
| if not re_res_deemon_sh: |
| return public.returnMsg(False, 'Tomcat启动文件解析失败!') |
| |
| jsvc_make_path = None |
| for i in os.listdir(tomcat_path + "/bin"): |
| tmp_dir = "{}/bin/{}".format(tomcat_path, i) |
| if i.startswith("commons-daemon") and os.path.isdir(tmp_dir): |
| make_path = tmp_dir + "/unix" |
| if os.path.isdir(make_path): |
| jsvc_make_path = make_path |
| break |
| |
| if jsvc_make_path is None: |
| return public.returnMsg(False, 'Jsvc文件丢失!') |
| |
| |
| if os.path.isfile(tomcat_path + "/bin/jsvc"): |
| os.remove(tomcat_path + "/bin/jsvc") |
| |
| if os.path.isfile(jsvc_make_path + "/jsvc"): |
| os.remove(jsvc_make_path + "/jsvc") |
| |
| shell_str = r''' |
| cd {} |
| make clean |
| ./configure --with-java={} |
| make |
| \cp jsvc {} |
| '''.format(jsvc_make_path, jdk_path, tomcat_path + "/bin/jsvc") |
| public.ExecShell(shell_str) |
| |
| new_deemon_sh_data = deemon_sh_data[:re_res_deemon_sh.start()] + ( |
| 'JAVA_HOME={}\n'.format(jdk_path) |
| ) + deemon_sh_data[re_res_deemon_sh.end():] |
| public.writeFile(deemon_sh_path, new_deemon_sh_data) |
| |
| project_conf["jdk_path"] = jdk_path |
| public.M('sites').where("name=?", (project_name,)).update({"project_config": json.dumps(project_conf)}) |
| return public.returnMsg(True, '修改成功') |
| |
| def xml_init(self, path): |
| ''' |
| @name 初始化XML文件 |
| @author lkq<2021-08-27> |
| @param path<string> |
| @return string |
| ''' |
| try: |
| self.__CONF_FILE = str(path) |
| self.__TREE = ElementTree() |
| self.__TREE.parse(self.__CONF_FILE) |
| self.__ROOT = self.__TREE.getroot() |
| self.__ENGINE = self.__TREE.findall('Service/Engine')[0] |
| self.__CONNECTROR = self.__TREE.findall('Service/Connector') |
| return True |
| except Exception as e: |
| return False |
| |
| def Initialization(self, version): |
| ''' |
| @name 初始化XML文件 |
| @author lkq<2021-08-27> |
| @param version<string> |
| @return string |
| ''' |
| if version == '7' or version == 'tomcat7' or version == 7: |
| if self.xml_init(self.__tomcat7_server): |
| return True |
| else: |
| return False |
| elif version == '8' or version == 'tomcat8' or version == 8: |
| if self.xml_init(self.__tomcat8_server): |
| return True |
| else: |
| return False |
| elif version == '9' or version == 'tomcat9' or version == 9: |
| if self.xml_init(self.__tomcat9_server): |
| return True |
| else: |
| return False |
| elif version == '10' or version == 'tomcat10' or version == 10: |
| if self.xml_init('/usr/local/bttomcat/tomcat10/conf/server.xml'): |
| return True |
| else: |
| return False |
| else: |
| return False |
| |
| def get_server(self, version, domain=None): |
| ''' |
| @name 取服务状态 |
| @author lkq<2021-08-27> |
| @param version<string> |
| @return string |
| ''' |
| if domain: |
| pid_path = self.__site_path + '/' + domain + '/logs/catalina-daemon.pid' |
| else: |
| pid_path = self.__bttomcat_path + '/tomcat%s/logs/catalina-daemon.pid' % version |
| if os.path.exists(pid_path): |
| reuslt = public.ReadFile(pid_path) |
| if isinstance(reuslt, str): |
| if not reuslt.strip(): return False |
| pid = int(reuslt.split()[0].strip()) |
| else: |
| return False |
| try: |
| ret = psutil.Process(pid) |
| return True |
| except: |
| return False |
| else: |
| return False |
| |
| def get_port(self): |
| ''' |
| @name 取端口号 |
| @author lkq<2021-08-27> |
| @param version<string> |
| @return string |
| |
| ''' |
| for i in self.__CONNECTROR: |
| if 'protocol' in i.attrib and 'port' in i.attrib: |
| if i.attrib['protocol'] == 'HTTP/1.1': |
| return int(i.attrib['port']) |
| else: |
| return int(8080) |
| |
| def set_tomcat_duli_path(self, get, get_project_find=''): |
| ''' |
| @name 更改独立项目路径 |
| @author lkq<2021-09-17> |
| @param get.project_path<int> |
| @param get.project_name 项目名称 |
| ''' |
| project_name = get.project_name.strip() |
| project_info = get_project_find |
| if not project_info: return public.returnMsg(False, '更改项目路径失败!') |
| if project_info['project_config']['java_type'] == 'duli': |
| |
| project_path = get.project_path.strip() |
| if not os.path.exists(project_path): os.makedirs(project_path) |
| if not self.Initialization2(version = '7', site = project_name): return public.returnMsg( |
| False, "Tomcat配置文件错误请检查配置文件" |
| ) |
| ret = self.Set_Domain_path(project_name, project_path) |
| if ret: |
| |
| |
| project_info['project_config']['project_cwd'] = project_path |
| pdata = { |
| 'path': project_path, |
| 'project_config': json.dumps(project_info['project_config']) |
| } |
| public.M('sites').where('name=?', (project_name,)).update(pdata) |
| return public.returnMsg(True, '更改项目路径成功!') |
| else: |
| return public.returnMsg(False, '更改项目路径失败!') |
| if project_info['project_config']['java_type'] == 'neizhi': |
| project_path = get.project_path.strip() |
| if not os.path.exists(project_path): os.makedirs(project_path) |
| if not self.Initialization( |
| version = project_info['project_config']['tomcat_version'] |
| ): return public.returnMsg(False, "Tomcat配置文件错误请检查配置文件") |
| ret = self.Set_Domain_path(project_name, project_path) |
| if ret: |
| project_info['project_config']['project_cwd'] = project_path |
| pdata = { |
| 'path': project_path, |
| 'project_config': json.dumps(project_info['project_config']) |
| } |
| public.M('sites').where('name=?', (project_name,)).update(pdata) |
| return public.returnMsg(True, '更改项目路径成功!') |
| else: |
| return public.returnMsg(False, '更改项目路径失败') |
| |
| def set_tomcat_duli_port(self, get, get_project_find=''): |
| ''' |
| @name 更改独立项目端口 |
| @author lkq<2021-08-27> |
| @param get.port<int> |
| @param get.project_name 项目名称 |
| ''' |
| project_name = get.project_name.strip() |
| project_info = get_project_find |
| if not project_info: return public.returnMsg(False, '项目不存在!') |
| if project_info['project_config']['java_type'] == 'duli': |
| |
| port = str(get.port) |
| if self.check_port_is_used(port): return public.returnMsg(False, '端口已经被占用!') |
| if not self.Initialization2(version = '7', site = project_name): return public.returnMsg( |
| False, "配置文件错误请检查配置文件" |
| ) |
| ret = self.TomcatSetPort(port = port) |
| if ret: |
| get.domain = project_name |
| get.type = 'reload' |
| self.pendent_tomcat_start(get) |
| fs = firewalls.firewalls() |
| get = mobj() |
| get.port = port |
| get.ps = 'tomcat外部端口' |
| fs.AddAcceptPort(get) |
| |
| project_info['project_config']['port'] = int(port) |
| pdata = {'project_config': json.dumps(project_info['project_config'])} |
| public.M('sites').where('name=?', (project_name,)).update(pdata) |
| |
| return public.returnMsg(True, '更改成功!') |
| else: |
| return public.returnMsg(False, '更改失败') |
| if project_info['project_config']['java_type'] == 'neizhi': |
| port = str(get.port) |
| if self.check_port_is_used(port): return public.returnMsg(False, '端口已经被占用!') |
| if not self.Initialization( |
| version = project_info['project_config']['tomcat_version'] |
| ): return public.returnMsg(False, "配置文件错误请检查配置文件") |
| ret = self.TomcatSetPort(port = port) |
| if ret: |
| get.version = project_info['project_config']['tomcat_version'] |
| get.type = 'reload' |
| self.start_tomcat(get) |
| fs = firewalls.firewalls() |
| get = mobj() |
| get.port = port |
| get.ps = 'tomcat外部端口' |
| fs.AddAcceptPort(get) |
| |
| project_info['project_config']['port'] = int(port) |
| pdata = {'project_config': json.dumps(project_info['project_config'])} |
| public.M('sites').where('name=?', (project_name,)).update(pdata) |
| return public.returnMsg(True, '更改成功!') |
| else: |
| return public.returnMsg(False, '更改失败') |
| |
| def get_jdk_path(self, version, is_independent=False): |
| ''' |
| @name 获取JDK版本路径 |
| @author lkq<2021-08-27> |
| @param version<string> |
| @param is_independent<bool> 是否是独立版本 |
| @return string |
| ''' |
| if is_independent: |
| path = self.__site_path + '/%s/bin/daemon.sh' % version |
| else: |
| path = self.__bttomcat_path + '/tomcat%s/bin/daemon.sh' % version |
| if os.path.exists(path): |
| ret = public.ReadFile(path) |
| if isinstance(ret, str): |
| rec = "\nJAVA_HOME=.+" |
| if re.search(rec, ret): |
| jdk = re.search(rec, ret) |
| if not jdk: return '' |
| if jdk: |
| jdk = jdk.group(0).split('=')[1].strip() |
| return jdk |
| else: |
| return '' |
| else: |
| return '' |
| else: |
| return '' |
| |
| def format(self, em, level=0): |
| ''' |
| @name 格式化配置文件 |
| @author lkq<2021-08-27> |
| @param em<string> |
| @param level<int> |
| ''' |
| i = "\n" + level * " " |
| if len(em): |
| if not em.text or not em.text.strip(): |
| em.text = i + " " |
| for e in em: |
| self.format(e, level + 1) |
| if not e.tail or not e.tail.strip(): |
| e.tail = i |
| if level and (not em.tail or not em.tail.strip()): |
| em.tail = i |
| |
| |
| def save_tomcat(self): |
| ''' |
| @name 保存tomcat配置文件 |
| @author lkq<2021-08-27> |
| ''' |
| self.format(self.__ROOT) |
| self.__TREE.write(self.__CONF_FILE, 'utf-8') |
| |
| def get_vhost(self, domain): |
| ''' |
| @name 获取指定虚拟主机 |
| @author lkq<2021-08-27> |
| @param domain<string> |
| @return string |
| ''' |
| try: |
| Hosts = self.__ENGINE.getchildren() |
| except: |
| Hosts = list(self.__ENGINE) |
| for host in Hosts: |
| if host.tag != 'Host': continue |
| if host.attrib['name'] == domain: |
| return host |
| return None |
| |
| def add_vhost(self, path, domain): |
| ''' |
| @name tomcat 填写虚拟主机 |
| @author lkq<2021-08-27> |
| @param path<string> |
| @param domain<string> |
| @return bool |
| ''' |
| if not os.path.exists(path): os.makedirs(path) |
| if self.get_vhost(domain): return False |
| attr = { |
| "autoDeploy": "true", "name": domain, "unpackWARs": "true", |
| "xmlNamespaceAware": "false", "xmlValidation": "false" |
| } |
| Host = Element("Host", attr) |
| attr = {"docBase": path, "path": "", "reloadable": "true", "crossContext": "true", } |
| Context = Element("Context", attr) |
| Host.append(Context) |
| self.__ENGINE.append(Host) |
| self.save_tomcat() |
| return True |
| |
| |
| def start_tomcat(self, get): |
| version = str(get.version) |
| s_type = get.type |
| if version.startswith('tomcat') or version.startswith('Tomcat'): |
| version = version.replace('tomcat', '').replace('Tomcat', '') |
| |
| execStr = '/etc/init.d/bttomcat%s stop && /etc/init.d/bttomcat%s start' % (version, version) |
| start = '/usr/local/bttomcat/tomcat%s/bin/daemon.sh start' % version |
| stop = '/usr/local/bttomcat/tomcat%s/bin/daemon.sh stop' % version |
| if s_type == 'start': |
| ret = self.get_server(version) |
| if not ret: |
| pid_path = '/www/server/%s/logs/catalina-daemon.pid' % version |
| if os.path.exists(pid_path): |
| os.remove(pid_path) |
| public.ExecShell(start) |
| self.start_by_user("/etc/init.d/bttomcat{}".format(version)) |
| return public.returnMsg(True, '启动成功') |
| elif s_type == 'stop': |
| public.ExecShell(stop) |
| if self.get_server(version): |
| public.ExecShell(stop) |
| self.stop_by_user("/etc/init.d/bttomcat{}".format(version)) |
| return public.returnMsg(True, '关闭成功') |
| elif s_type == 'reload' or s_type == 'restart': |
| |
| public.ExecShell(stop) |
| public.ExecShell(start) |
| return public.returnMsg(True, '重载成功') |
| else: |
| return public.returnMsg(False, '类型错误') |
| |
| def pendent_tomcat_start(self, get): |
| ''' |
| 独立项目的tomcat启动 |
| @author lkq 2021-08-27 |
| @param get.domain 项目域名 |
| @param get.type 启动类型 start stop reload |
| ''' |
| version = get.domain |
| s_type = get.type |
| |
| execStr = '%s/%s/bin/daemon.sh stop && %s/%s/bin/daemon.sh start' % ( |
| self.__site_path, version, self.__site_path, version) |
| start = '%s/%s/bin/daemon.sh start' % (self.__site_path, version) |
| stop = '%s/%s/bin/daemon.sh stop' % (self.__site_path, version) |
| if s_type == 'start': |
| ret = self.get_server(version, version) |
| if not ret: |
| pid_path = '%s/%s/logs/catalina-daemon.pid' % (self.__site_path, version) |
| if os.path.exists(pid_path): |
| os.remove(pid_path) |
| public.ExecShell(start) |
| self.start_by_user(self.__site_path + "/" + version) |
| return public.returnMsg(True, '启动成功') |
| elif s_type == 'stop': |
| public.ExecShell(stop) |
| if self.get_server(version, version): |
| public.ExecShell(stop) |
| self.stop_by_user(self.__site_path + "/" + version) |
| return public.returnMsg(True, '关闭成功') |
| elif s_type == 'reload' or s_type == 'restart': |
| |
| public.ExecShell(stop) |
| public.ExecShell(start) |
| return public.returnMsg(True, '重载成功') |
| else: |
| return public.returnMsg(False, '类型错误') |
| |
| def pendent_tomcat_info(self, get=None, domain=None): |
| ''' |
| @name 独立项目的项目信息 |
| @author lkq 2021-08-27 |
| ''' |
| if get: domain = get.domain.strip() |
| tmp = {} |
| tmp_path = self.__site_path + '' + domain + '/conf/server.xml' |
| if os.path.exists(tmp_path): |
| if not self.Initialization2('7', domain): |
| tmp["port"] = False |
| else: |
| tmp["port"] = self.get_port() |
| tmp['status'] = self.get_server(domain, domain) |
| tmp['conf'] = public.readFile(tmp_path) |
| tmp['jdk_path'] = self.get_jdk_path(domain, True) |
| |
| tmp["tomcat_server"] = tmp_path |
| tmp['tomcat_start'] = self.__site_path + '' + domain + '/bin/daemon.sh' |
| tmp['stype'] = 'built' |
| else: |
| tmp['status'] = False |
| tmp["port"] = False |
| tmp['conf'] = False |
| tmp['jdk'] = False |
| tmp['log'] = False |
| tmp['jdk_path'] = False |
| tmp['stype'] = 'uninstall' |
| return tmp |
| |
| def exists_nginx_ssl(self, project_name): |
| ''' |
| @name 判断项目是否配置Nginx SSL配置 |
| @author hwliang<2021-08-09> |
| @param project_name: string<项目名称> |
| @return tuple |
| ''' |
| config_file = "{}/nginx/java_{}.conf".format(public.get_vhost_path(), project_name) |
| if not os.path.exists(config_file): |
| return False, False |
| |
| config_body = public.readFile(config_file) |
| if not config_body: |
| return False, False |
| |
| is_ssl, is_force_ssl = False, False |
| if config_body.find('ssl_certificate') != -1: |
| is_ssl = True |
| if config_body.find('HTTP_TO_HTTPS_START') != -1: |
| is_force_ssl = True |
| return is_ssl, is_force_ssl |
| |
| def set_nginx_config(self, project_find): |
| ''' |
| @name 设置Nginx配置 |
| @author hwliang<2021-08-09> |
| @param project_find: dict<项目信息> |
| @return bool |
| ''' |
| project_name = project_find['name'] |
| ports = [] |
| domains = [] |
| for d in project_find['project_config']['domains']: |
| domain_tmp = d.split(':') |
| if len(domain_tmp) == 1: domain_tmp.append(80) |
| if not int(domain_tmp[1]) in ports: |
| ports.append(int(domain_tmp[1])) |
| if not domain_tmp[0] in domains: |
| domains.append(domain_tmp[0]) |
| listen_ipv6 = public.listen_ipv6() |
| is_ssl, is_force_ssl = self.exists_nginx_ssl(project_name) |
| listen_ports_list = [] |
| for p in ports: |
| listen_ports_list.append(" listen {};".format(p)) |
| if listen_ipv6: |
| listen_ports_list.append(" listen [::]:{};".format(p)) |
| |
| ssl_config = '' |
| if is_ssl: |
| http3_header = "" |
| if self.is_nginx_http3(): |
| http3_header = '''\n add_header Alt-Svc 'quic=":443"; h3=":443"; h3-29=":443"; h3-27=":443";h3-25=":443"; h3-T050=":443"; h3-Q050=":443";h3-Q049=":443";h3-Q048=":443"; h3-Q046=":443"; h3-Q043=":443"';''' |
| http3_header += "\n quic_retry on;\n quic_gso on;" |
| if self.ng_ssl_early_data_enabled(): |
| http3_header += "\n ssl_early_data on;" |
|
|
| nginx_ver = public.nginx_version() |
| if nginx_ver: |
| port_str = ["443"] |
| if listen_ipv6: |
| port_str.append("[::]:443") |
| use_http2_on = False |
| for p in port_str: |
| listen_str = " listen {} ssl".format(p) |
| if nginx_ver < [1, 9, 5]: |
| listen_str += ";" |
| elif [1, 9, 5] <= nginx_ver < [1, 25, 1]: |
| listen_str += " http2;" |
| else: |
| listen_str += ";" |
| use_http2_on = True |
| listen_ports_list.append(listen_str) |
| |
| if self.is_nginx_http3(): |
| listen_ports_list.append(" listen {} quic;".format(p)) |
| if use_http2_on: |
| listen_ports_list.append(" http2 on;") |
| if self.is_nginx_http3(): |
| listen_ports_list.append(" http3 on;") |
| |
| else: |
| listen_ports_list.append(" listen 443 ssl;") |
| |
| ssl_config = '''ssl_certificate {vhost_path}/cert/{priject_name}/fullchain.pem; |
| ssl_certificate_key {vhost_path}/cert/{priject_name}/privkey.pem; |
| ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3; |
| ssl_ciphers EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5; |
| ssl_prefer_server_ciphers on; |
| ssl_session_cache shared:SSL:10m; |
| ssl_session_timeout 10m; |
| add_header Strict-Transport-Security "max-age=31536000";{http3_header} |
| error_page 497 https://$host$request_uri;'''.format( |
| vhost_path = self._vhost_path, priject_name = project_name, |
| http3_header = http3_header |
| ) |
| |
| if is_force_ssl: |
| ssl_config += ''' |
| #HTTP_TO_HTTPS_START |
| if ($server_port !~ 443){ |
| rewrite ^(/.*)$ https://$host$1 permanent; |
| } |
| #HTTP_TO_HTTPS_END''' |
| |
| config_file = "{}/nginx/java_{}.conf".format(self._vhost_path, project_name) |
| template_file = "{}/template/nginx/java_http.conf".format(self._vhost_path) |
| |
| listen_ports = "\n".join(listen_ports_list).strip() |
| config_body = public.readFile(template_file) |
| if project_find['project_config']['java_type'] == 'neizhi' or project_find['project_config'][ |
| 'java_type'] == 'duli': |
| host = '{}'.format(project_find['project_config']['project_name']) |
| else: |
| host = '$Host' |
| |
| |
| |
| if 'host_url' in project_find['project_config']: |
| if project_find['project_config']['host_url']: |
| url2 = project_find['project_config']['host_url'] |
| else: |
| url2 = 'http://127.0.0.1:{}'.format(project_find['project_config']['port']) |
| else: |
| url2 = 'http://127.0.0.1:{}'.format(project_find['project_config']['port']) |
| |
| if project_find["project_config"]["java_type"] == "springboot": |
| _site_path = project_find["project_config"]["static_path"] if ( |
| "static_path" in project_find["project_config"] and project_find["project_config"][ |
| "static_path"]) else \ |
| project_find["project_config"]["jar_path"] |
| else: |
| _site_path = project_find['path'] |
| |
| mut_config = { |
| "api_url": '/' if not 'api_url' in project_find['project_config'] else project_find['project_config'][ |
| 'api_url'], |
| "site_path": _site_path, |
| "domains": ' '.join(domains), |
| "url": url2, |
| "listen_ports": listen_ports, |
| "ssl_config": ssl_config, |
| } |
| config_body = config_body.format( |
| api_url = mut_config["api_url"], |
| site_path = mut_config["site_path"], |
| domains = ' '.join(domains), |
| project_name = project_name, |
| panel_path = self._panel_path, |
| log_path = public.get_logs_path(), |
| url = url2, |
| host = host, |
| listen_ports = listen_ports, |
| ssl_config = ssl_config |
| ) |
| |
| |
| |
| |
| |
| |
| rewrite_file = "{panel_path}/vhost/rewrite/java_{project_name}.conf".format( |
| panel_path = self._panel_path, project_name = project_name |
| ) |
| if not os.path.exists(rewrite_file): |
| public.writeFile(rewrite_file, '# 请将伪静态规则或自定义NGINX配置填写到此处\n') |
| if not os.path.exists("/www/server/panel/vhost/nginx/well-known"): |
| os.makedirs("/www/server/panel/vhost/nginx/well-known", 0o600) |
| apply_check = "{}/vhost/nginx/well-known/{}.conf".format(self._panel_path, project_name) |
| from mod.base.web_conf import ng_ext |
| config_body = ng_ext.set_extension_by_config(project_name, config_body) |
| if not os.path.exists(apply_check): |
| public.writeFile(apply_check, '') |
| if not os.path.exists(config_file): |
| public.writeFile(config_file, config_body) |
| else: |
| if not self._replace_nginx_conf(config_file, mut_config): |
| public.writeFile(config_file, config_body) |
| |
| return True |
| |
| @staticmethod |
| def _replace_nginx_conf(config_file, mut_config: dict) -> bool: |
| """尝试替换""" |
| data: str = public.readFile(config_file) |
| tab_spc = " " |
| rep_list = [ |
| ( |
| r"([ \f\r\t\v]*listen[^;\n]*;\n(\s*http2\s+on\s*;[^\n]*\n)?)+", |
| mut_config["listen_ports"] + "\n" |
| ), |
| ( |
| r"[ \f\r\t\v]*root [ \f\r\t\v]*/[^;\n]*;", |
| " root {};".format(mut_config["site_path"]) |
| ), |
| ( |
| r"[ \f\r\t\v]*server_name [ \f\r\t\v]*[^\n;]*;", |
| " server_name {};".format(mut_config["domains"]) |
| ), |
| ( |
| r"[ \f\r\t\v]*location [^{\n]* { *\n *proxy_pass[^\n;]*;\n *proxy_set_header *Host", |
| "{}location {} {{\n{}proxy_pass {};\n{}proxy_set_header Host".format( |
| tab_spc, mut_config["api_url"], tab_spc * 2, mut_config["url"], tab_spc * 2, ) |
| ), |
| ( |
| "[ \f\r\t\v]*#SSL-START(.*\n){2,15}[ \f\r\t\v]*#SSL-END", |
| "{}#SSL-START SSL相关配置\n{}#error_page 404/404.html;\n{}{}\n{}#SSL-END".format( |
| tab_spc, tab_spc, tab_spc, mut_config["ssl_config"], tab_spc |
| ) |
| ) |
| ] |
| for rep, info in rep_list: |
| if re.search(rep, data): |
| data = re.sub(rep, info, data, 1) |
| else: |
| return False |
| |
| public.writeFile(config_file, data) |
| return True |
| |
| def exists_apache_ssl(self, project_name): |
| ''' |
| @name 判断项目是否配置Apache SSL配置 |
| @author hwliang<2021-08-09> |
| @param project_name: string<项目名称> |
| @return bool |
| ''' |
| config_file = "{}/apache/java_{}.conf".format(public.get_vhost_path(), project_name) |
| if not os.path.exists(config_file): |
| return False, False |
| |
| config_body = public.readFile(config_file) |
| if not config_body: |
| return False, False |
| |
| is_ssl, is_force_ssl = False, False |
| if config_body.find('SSLCertificateFile') != -1: |
| is_ssl = True |
| if config_body.find('HTTP_TO_HTTPS_START') != -1: |
| is_force_ssl = True |
| return is_ssl, is_force_ssl |
| |
| def set_apache_config(self, project_find): |
| ''' |
| @name 设置Apache配置 |
| @author hwliang<2021-08-09> |
| @param project_find: dict<项目信息> |
| @return bool |
| ''' |
| project_name = project_find['name'] |
| |
| |
| ports = [] |
| domains = [] |
| for d in project_find['project_config']['domains']: |
| domain_tmp = d.split(':') |
| if len(domain_tmp) == 1: domain_tmp.append(80) |
| if not int(domain_tmp[1]) in ports: |
| ports.append(int(domain_tmp[1])) |
| if not domain_tmp[0] in domains: |
| domains.append(domain_tmp[0]) |
| |
| config_file = "{}/apache/java_{}.conf".format(self._vhost_path, project_name) |
| template_file = "{}/template/apache/java_http.conf".format(self._vhost_path) |
| config_body = public.readFile(template_file) |
| apache_config_body = '' |
| |
| |
| is_ssl, is_force_ssl = self.exists_apache_ssl(project_name) |
| if is_ssl: |
| if not 443 in ports: ports.append(443) |
| |
| from panelSite import panelSite |
| s = panelSite() |
| |
| if project_find["project_config"]["java_type"] == "springboot": |
| _site_path = project_find["project_config"]["jar_path"] |
| else: |
| _site_path = project_find['path'] |
| |
| |
| for p in ports: |
| |
| ssl_config = '' |
| if p == 443 and is_ssl: |
| ssl_key_file = "{vhost_path}/cert/{project_name}/privkey.pem".format( |
| project_name = project_name, vhost_path = public.get_vhost_path() |
| ) |
| if not os.path.exists(ssl_key_file): continue |
| ssl_config = '''#SSL |
| SSLEngine On |
| SSLCertificateFile {vhost_path}/cert/{project_name}/fullchain.pem |
| SSLCertificateKeyFile {vhost_path}/cert/{project_name}/privkey.pem |
| SSLCipherSuite EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5 |
| SSLProtocol All -SSLv2 -SSLv3 -TLSv1 |
| SSLHonorCipherOrder On'''.format(project_name = project_name, vhost_path = public.get_vhost_path()) |
| else: |
| if is_force_ssl: |
| ssl_config = '''#HTTP_TO_HTTPS_START |
| <IfModule mod_rewrite.c> |
| RewriteEngine on |
| RewriteCond %{SERVER_PORT} !^443$ |
| RewriteRule (.*) https://%{SERVER_NAME}$1 [L,R=301] |
| </IfModule> |
| #HTTP_TO_HTTPS_END''' |
| |
| |
| apache_config_body += config_body.format( |
| site_path = _site_path, |
| server_name = '{}.{}'.format(p, project_name), |
| domains = ' '.join(domains), |
| log_path = public.get_logs_path(), |
| server_admin = 'admin@{}'.format(project_name), |
| url = 'http://127.0.0.1:{}'.format(project_find['project_config']['port']), |
| port = p, |
| ssl_config = ssl_config, |
| project_name = project_name |
| ) |
| apache_config_body += "\n" |
| |
| |
| if not p in [80]: |
| s.apacheAddPort(p) |
| |
| |
| if project_find["project_config"]["java_type"] == "springboot": |
| _path = project_find["project_config"]["static_path"] if ( |
| "static_path" in project_find["project_config"] and project_find["project_config"][ |
| "static_path"]) else \ |
| project_find["project_config"]["jar_path"] |
| rewrite_file = "{}/.htaccess".format(_path) |
| else: |
| rewrite_file = "{}/.htaccess".format(project_find['path']) |
| if not os.path.exists(rewrite_file): public.writeFile( |
| rewrite_file, '# 请将伪静态规则或自定义Apache配置填写到此处\n' |
| ) |
| from mod.base.web_conf import ap_ext |
| apache_config_body = ap_ext.set_extension_by_config(project_name, apache_config_body) |
| |
| public.writeFile(config_file, apache_config_body) |
| return True |
| |
| def get_nginx_ssl_config(self, project_name): |
| ''' |
| @name 获取项目Nginx SSL配置 |
| @author hwliang<2021-08-09> |
| @param project_name: string<项目名称> |
| @return string |
| ''' |
| result = '' |
| config_file = "{}/nginx/java_{}".format(self._vhost_path, project_name) |
| if not os.path.exists(config_file): |
| return result |
| |
| config_body = public.readFile(config_file) |
| if not config_body: |
| return result |
| if config_body.find('ssl_certificate') == -1: |
| return result |
| |
| ssl_body = re.search("#SSL-START(.|\n)+#SSL-END", config_body) |
| if not ssl_body: return result |
| result = ssl_body.group() |
| return result |
| |
| def set_config(self, project_name): |
| ''' |
| @name 设置项目配置 |
| @author hwliang<2021-08-09> |
| @param project_name: string<项目名称> |
| @return bool |
| ''' |
| project_find = self.get_project_find(project_name) |
| if not project_find: return False |
| if not project_find['project_config']: return False |
| if not project_find['project_config']['bind_extranet']: return False |
| if not project_find['project_config']['domains']: return False |
| self.set_nginx_config(project_find) |
| self.set_apache_config(project_find) |
| public.serviceReload() |
| return True |
| |
| def clear_nginx_config(self, project_find): |
| ''' |
| @name 清除nginx配置 |
| @author hwliang<2021-08-09> |
| @param project_find: dict<项目信息> |
| @return bool |
| ''' |
| project_name = project_find['name'] |
| config_file = "{}/nginx/java_{}.conf".format(self._vhost_path, project_name) |
| if os.path.exists(config_file): |
| os.remove(config_file) |
| rewrite_file = "{panel_path}/vhost/rewrite/java_{project_name}.conf".format( |
| panel_path = self._panel_path, project_name = project_name |
| ) |
| if os.path.exists(rewrite_file): |
| os.remove(rewrite_file) |
| return True |
| |
| def clear_apache_config(self, project_find): |
| ''' |
| @name 清除apache配置 |
| @author hwliang<2021-08-09> |
| @param project_find: dict<项目信息> |
| @return bool |
| ''' |
| project_name = project_find['name'] |
| config_file = "{}/apache/java_{}.conf".format(self._vhost_path, project_name) |
| if os.path.exists(config_file): |
| os.remove(config_file) |
| return True |
| |
| def clear_config(self, project_name): |
| ''' |
| @name 清除项目配置 |
| @author hwliang<2021-08-09> |
| @param project_name: string<项目名称> |
| @return bool |
| ''' |
| project_find = self.get_project_find(project_name) |
| if not project_find: return False |
| self.clear_nginx_config(project_find) |
| self.clear_apache_config(project_find) |
| public.serviceReload() |
| return True |
| |
| def del_vhost(self, domain, context_path: str = ""): |
| ''' |
| @name 删除虚拟主机 |
| @author lkq |
| @param domain: string |
| @return bool |
| ''' |
| if domain == 'localhost': return False |
| host = self.get_vhost(domain) |
| if not host: return False |
| target_context, other_context_count = None, 0 |
| for i in host: |
| if i.tag == "Context": |
| if i.attrib["path"] == context_path: |
| target_context = i |
| else: |
| other_context_count += 1 |
| if target_context is None and not other_context_count: |
| return False |
| if target_context is not None: |
| host.remove(target_context) |
| if not other_context_count: |
| self.__ENGINE.remove(host) |
| self.save_tomcat() |
| return True |
| |
| def tomcat_vhost_delete(self, version, domains, get): |
| ''' |
| @name 删除内置tomcat虚拟主机 |
| @author lkq |
| @param version: string |
| @param domain: string |
| @return bool |
| ''' |
| if not self.Initialization(version): return public.returnMsg(False, "配置文件错误请检查配置文件") |
| context_path = get.get("project_name", "") |
| domain = domains[0].split(":")[0] |
| if self.del_vhost(domain, context_path): |
| get.version = version |
| get.type = 'reload' |
| self.start_tomcat(get) |
| return public.returnMsg(True, '删除成功') |
| return public.returnMsg(False, '不存在') |
| |
| def set_hosts(self, domain): |
| ''' |
| @name 建立本地HOST |
| ''' |
| pass |
| ret = public.ReadFile('/etc/hosts') |
| |
| |
| |
| |
| |
|
|
| @staticmethod |
| def set_spring_user(): |
| ''' |
| @name 建立本地HOST |
| ''' |
| try: |
| pwd.getpwnam('springboot') |
| except KeyError: |
| public.ExecShell('useradd springboot') |
| |
| def del_hosts(self, domain): |
| ''' |
| @name 删除本地hosts |
| ''' |
| pass |
| |
| |
| |
| |
| |
| |
| |
| |
| def Initialization2(self, version, site): |
| ''' |
| @name 初始独立项目 |
| @author lkq 2021-08-28 |
| @param site: string<项目名称> |
| @param version: string<版本号> |
| ''' |
| |
| if self.xml_init(self.__site_path + site + '/conf/server.xml'): |
| return True |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| def replce_tomcat_port(self, get): |
| ''' |
| @name 更改tomcat端口 |
| @param get.port: int |
| @param get.version: string |
| ''' |
| port = str(get.port) |
| version = str(get.version) |
| if version.startswith('tomcat') or version.startswith('Tomcat'): |
| version = version.replace('tomcat', '').replace('Tomcat', '') |
| if self.IsOpen(port): return public.returnMsg(False, '端口已经被占用!') |
| if not self.Initialization(version): return public.returnMsg(False, "配置文件错误请检查配置文件") |
| ret = self.TomcatSetPort(port = port) |
| if ret: |
| |
| get.type = 'reload' |
| self.start_tomcat(get) |
| return public.returnMsg(True, '端口更改成功') |
| return public.returnMsg(False, '端口更改失败') |
| |
| def replace_duli_port(self, get): |
| ''' |
| @name 更改duli端口 |
| @param get.port: int |
| @param get.version: string |
| @param get.domain string |
| @return bool |
| ''' |
| return self.set_site_port(get.port, "", get.domain.strip()) |
| |
| def TomcatSetPort(self, port): |
| ''' |
| @name 更改tomcat端口 |
| @author lkq |
| @param port: string<端口号> |
| ''' |
| for i in self.__CONNECTROR: |
| if 'protocol' in i.attrib and 'port' in i.attrib: |
| if i.attrib['protocol'] == 'HTTP/1.1': |
| i.attrib['port'] = port |
| self.save_tomcat() |
| if self.get_port() == int(port): |
| return True |
| else: |
| return False |
| |
| |
| def Set_Domain_path(self, domain, docBase): |
| try: |
| Hosts = self.__ENGINE.getchildren() |
| except: |
| Hosts = list(self.__ENGINE) |
| flag = False |
| for host in Hosts: |
| if host.tag != 'Host': continue |
| if host.attrib['name'] == domain: |
| try: |
| ch = host.getchildren() |
| except: |
| ch = list(host) |
| for i in ch: |
| print(i.attrib) |
| if 'docBase' in i.attrib: |
| i.attrib['docBase'] = docBase |
| flag = True |
| if flag: |
| self.save_tomcat() |
| return True |
| return False |
| |
| def TomcatSetPath(self, port): |
| ''' |
| @name 更改tomcat 项目路径 |
| @author lkq |
| @param port: string<端口号> |
| ''' |
| for i in self.__CONNECTROR: |
| if 'protocol' in i.attrib and 'port' in i.attrib: |
| if i.attrib['protocol'] == 'HTTP/1.1': |
| i.attrib['port'] = port |
| self.save_tomcat() |
| if self.get_port() == int(port): |
| return True |
| else: |
| return False |
| |
| def set_site_port(self, port, version, domain): |
| ''' |
| @name 更改独立项目端口 |
| @param port: int<端口> |
| @param version: string<版本> |
| @param domain: string<域名> |
| @author lkq 2021-08-28 |
| ''' |
| if self.IsOpen(port): return public.returnMsg(False, '端口已经被占用!') |
| if not self.Initialization2(version, domain): return public.returnMsg(False, "配置文件错误请检查配置文件") |
| ret = self.TomcatSetPort(port = port) |
| if ret: |
| fs = firewalls.firewalls() |
| get = mobj() |
| get.port = port |
| get.ps = 'tomcat外部端口' |
| fs.AddAcceptPort(get) |
| return public.returnMsg(True, '更改成功!') |
| else: |
| return public.returnMsg(False, '更改失败') |
| |
| def _get_jdk_status(self): |
| default_version = { |
| "x64": [ |
| "jdk1.7.0_80", |
| "jdk1.8.0_371", |
| "jdk-9.0.4", |
| "jdk-10.0.2", |
| "jdk-11.0.19", |
| "jdk-12.0.2", |
| "jdk-13.0.2", |
| "jdk-14.0.2", |
| "jdk-15.0.2", |
| "jdk-16.0.2", |
| "jdk-17.0.8", |
| "jdk-18.0.2.1", |
| "jdk-19.0.2", |
| "jdk-20.0.2" |
| ], |
| "arm": [ |
| "jdk1.8.0_371", |
| "jdk-11.0.19", |
| "jdk-15.0.2", |
| "jdk-16.0.2", |
| "jdk-17.0.8", |
| "jdk-18.0.2.1", |
| "jdk-19.0.2", |
| "jdk-20.0.2" |
| ], |
| "loongarch64": [ |
| "jdk-8.1.18", "jdk-11.0.22", "jdk-17.0.10", "jdk-21.0.2" |
| ] |
| } |
| tmp_file = '/www/server/panel/data/jdk.json' |
| tmp_pl = '/www/server/panel/data/jdk.json.pl' |
| download_url = '{}/src/jdk/jdk.json'.format(public.get_url()) |
| setup_path = public.GetConfigValue('setup_path') + '/java' |
| file_data = public.readFile(tmp_pl) |
| if not file_data and os.path.exists(tmp_pl): |
| os.remove(tmp_pl) |
| if not os.path.exists(setup_path): |
| public.ExecShell('mkdir -p ' + setup_path) |
| public.ExecShell('chown 755 ' + setup_path) |
| if not os.path.exists(tmp_pl) or time.time() - int(file_data) > 3600: |
| public.run_thread(public.downloadFile, (download_url, tmp_file)) |
| public.writeFile(tmp_pl, str(int(time.time()))) |
| versions = default_version |
| else: |
| try: |
| import json |
| versions = json.loads(public.readFile(tmp_file)) |
| except: |
| versions = default_version |
| |
| import platform |
| arce = platform.machine() |
| if arce == 'x86_64': |
| arce = 'x64' |
| elif arce == 'aarch64' or 'arm' in arce: |
| arce = 'arm' |
| try: |
| versions = versions.get(arce, []) |
| data = { |
| "name": "jdk", |
| "check": "/usr/local/java/VERSION/bin/java", |
| "msg": "Java 语言是一种通用的、面向对象的编程语言", |
| "shell": "java.sh", |
| "task": "1", |
| "type": "语言解释器", |
| "versions": [ |
| {"status": True if os.path.exists('/www/server/java/' + i) else False, "version": i} |
| for i in versions] |
| } |
| return data |
| except: |
| import json |
| versions_data = public.readFile(tmp_file) |
| if not versions_data: |
| versions = default_version |
| versions = versions.get(arce, []) |
| else: |
| versions = json.loads(versions_data).get(arce, []) |
| data = { |
| "name": 'jdk', |
| "check": "/usr/local/java/VERSION/bin/java", |
| "msg": "Java 语言是一种通用的、面向对象的编程语言", |
| "shell": "java.sh", |
| "task": "1", |
| "type": "语言解释器", |
| "versions": [{'status': False, "name": i} for i in versions] |
| } |
| return data |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| def get_local_jdk_version(self, get=None): |
| import os |
| import json |
| |
| ret = [] |
| if os.path.exists(self._panel_path + '/data/get_local_jdk.json'): |
| ret2 = public.ReadFile(self._panel_path + '/data/get_local_jdk.json') |
| if isinstance(ret2, str): |
| ret2 = json.loads(ret2) |
| for i in range(len(ret2)): |
| ret.append({'name': '自定义JDK', 'path': ret2[i], 'operation': 1, 'is_current': False}) |
| |
| |
| bashrc_path = os.path.expanduser('/etc/profile') |
| |
| current_java_home = '' |
| |
| if os.path.exists(bashrc_path): |
| profile_data = public.readFile(bashrc_path) |
| if profile_data: |
| for line in profile_data.strip("\n"): |
| if 'export JAVA_HOME=' in line: |
| current_java_home = line.split('=')[1].strip().replace('"', '').replace("'", "") |
| |
| |
| jdks = self._get_jdk_status()['versions'] |
| jdks = sorted(jdks, key = lambda x: x['status'], reverse = True) |
| for jdk in jdks: |
| jdk_path = '/www/server/java/' + jdk['version'] + '/bin/java' |
| is_current = os.path.dirname(os.path.dirname(jdk_path)) == current_java_home |
| if jdk['status']: |
| ret.append({'name': jdk['version'], 'path': jdk_path, 'operation': 1, 'is_current': is_current}) |
| else: |
| ret.append({'name': jdk['version'], 'path': '', 'operation': 0, 'is_current': False}) |
| |
| |
| jdk_paths = [ |
| ('JDK', '/usr/bin/java'), |
| ('jdk8', '/usr/java/jdk1.8.0_121/bin/java'), |
| ('openjdk8', '/usr/local/btjdk/jdk8/bin/java'), |
| ('jdk7', '/usr/java/jdk1.7.0_80/bin/java') |
| ] |
| for name, path in jdk_paths: |
| if os.path.exists(path): |
| is_current = os.path.dirname(os.path.dirname(path)) == current_java_home |
| ret.append({'name': name, 'path': path, 'operation': 2, 'is_current': is_current}) |
| |
| |
| for i in ret: |
| import psutil |
| try: |
| if os.path.exists('/www/server/java/' + i['name'] + '.pl'): |
| pid = int(public.readFile('/www/server/java/' + i['name'] + '.pl')) |
| psutil.Process(pid) |
| i['operation'] = 3 |
| except UnicodeEncodeError: |
| continue |
| except: |
| public.ExecShell('rm -rf /www/server/java/' + i['name'] + '.pl') |
| return ret |
| |
| def get_system_info(self, get): |
| ''' |
| @name 获取基础信息 |
| ''' |
| reuslt = {} |
| reuslt['jdk_info'] = self.get_local_jdk_version(get) |
| reuslt['tomcat_info'] = self.get_tomcat_version(get) |
| return public.returnMsg(True, reuslt) |
| |
| def install_jdk_new(self, get): |
| try: |
| if not hasattr(get, 'version'): |
| return public.returnMsg(False, '版本号不能为空') |
| if not os.path.exists('/www/server/panel/install/jdk.sh'): |
| public.ExecShell('wget -O /www/server/panel/install/jdk.sh ' + public.get_url() + '/install/0/jdk.sh') |
| jdk_version = self.get_local_jdk_version() |
| jdk_version = [i["name"] for i in jdk_version if i["operation"] == 0] |
| if os.path.exists('/www/server/java/' + get['version']): |
| return public.returnMsg(False, '版本已经存在') |
| if get['version'] not in jdk_version: |
| return public.returnMsg(False, '版本号不存在') |
| public.writeFile('/www/server/java/{}.pl'.format(get['version']), str(os.getpid())) |
| res = public.ExecShell('bash /www/server/panel/install/jdk.sh install ' + get['version']) |
| public.ExecShell('rm -rf /www/server/java/{}.*'.format(get['version'])) |
| |
| if res[0].find('安装java成功') == -1: |
| return public.returnMsg(False, '安装java失败') |
| return public.returnMsg(True, '安装java成功') |
| except: |
| public.ExecShell('rm -rf /www/server/java/{}.*'.format(get['version'])) |
| return public.returnMsg(False, '安装java失败') |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| def add_local_jdk(self, get): |
| ''' |
| @name 添加本地JDK |
| @parcm get.jdk<> |
| @return list |
| ''' |
| jdk = get.jdk.strip() |
| loacl_jdk = self.get_local_jdk_version() |
| local_jdk = [i['path'] for i in loacl_jdk if i['operation'] in [1, 2]] |
| if jdk in local_jdk: return public.returnMsg(False, 'jdk路径已经存在') |
| jdk_path = jdk.split('/') |
| if jdk_path[-1] != 'java': return public.returnMsg(False, '请填写完整的路径,例如:/www/server/jdk1.8/bin/java') |
| if not os.path.exists(jdk): return public.returnMsg(False, 'JDK路径不存在') |
| if not os.path.exists(self._panel_path + '/data/get_local_jdk.json'): |
| |
| |
| ret = public.ExecShell(jdk + ' -version') |
| if ret[0].find('Error occurred') != -1: |
| return public.returnMsg(False, 'JDK不可用') |
| public.writeFile(self._panel_path + '/data/get_local_jdk.json', json.dumps([jdk])) |
| return public.returnMsg(True, '保存成功') |
| else: |
| ret = public.ExecShell(jdk + ' -version') |
| if ret[0].find('Error occurred') != -1: |
| return public.returnMsg(False, 'JDK不可用') |
| data = public.readFile(self._panel_path + '/data/get_local_jdk.json') |
| if isinstance(data, str): |
| data = json.loads(data) |
| if jdk in data: return public.returnMsg(False, '已经存在') |
| data.append(jdk) |
| public.writeFile(self._panel_path + '/data/get_local_jdk.json', json.dumps(data)) |
| return public.returnMsg(True, '保存成功') |
| else: |
| public.writeFile(self._panel_path + '/data/get_local_jdk.json', json.dumps([jdk])) |
| return public.returnMsg(True, '保存成功') |
| |
| |
| def del_local_jdk(self, get): |
| jdk = get.jdk.strip() |
| if '/www/server/java/' in jdk: |
| jdk_version = jdk.split('/')[-3] |
| public.ExecShell('rm -rf ' + '/www/server/java/' + jdk_version) |
| data = public.readFile(self._panel_path + '/data/get_local_jdk.json') |
| if isinstance(data, str): |
| data = json.loads(data) |
| if jdk in data: |
| data.remove(jdk) |
| public.writeFile(self._panel_path + '/data/get_local_jdk.json', json.dumps(data)) |
| return public.returnMsg(True, '删除成功') |
| |
| if not os.path.exists(self._panel_path + '/data/get_local_jdk.json'): |
| return public.returnMsg(False, '删除失败') |
| data = public.readFile(self._panel_path + '/data/get_local_jdk.json') |
| if isinstance(data, str): |
| data = json.loads(data) |
| if jdk in data: |
| data.remove(jdk) |
| public.writeFile(self._panel_path + '/data/get_local_jdk.json', json.dumps(data)) |
| return public.returnMsg(True, '删除成功') |
| else: |
| return public.returnMsg(False, '删除失败') |
| else: |
| return public.returnMsg(False, '删除失败') |
| |
| def get_process_cpu_time(self, cpu_times): |
| cpu_time = 0.00 |
| for s in cpu_times: cpu_time += s |
| return cpu_time |
| |
| def get_cpu_precent(self, p): |
| ''' |
| @name 获取进程cpu使用率 |
| @author hwliang<2021-08-09> |
| @param p: Process<进程对像> |
| @return dict |
| ''' |
| skey = "cpu_pre_{}".format(p.pid) |
| old_cpu_times = cache.get(skey) |
| |
| process_cpu_time = self.get_process_cpu_time(p.cpu_times()) |
| if not old_cpu_times: |
| cache.set(skey, [process_cpu_time, time.time()], 3600) |
| |
| old_cpu_times = cache.get(skey) |
| process_cpu_time = self.get_process_cpu_time(p.cpu_times()) |
| |
| old_process_cpu_time = old_cpu_times[0] |
| old_time = old_cpu_times[1] |
| new_time = time.time() |
| cache.set(skey, [process_cpu_time, new_time], 3600) |
| percent = round( |
| 100.00 * (process_cpu_time - old_process_cpu_time) / (new_time - old_time) / psutil.cpu_count(), 2 |
| ) |
| return percent |
| |
| def get_project_run_state(self, get=None, project_name=None): |
| ''' |
| @name 获取项目运行状态 |
| @author hwliang<2021-08-12> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @param project_name<string> 项目名称 |
| @return bool |
| ''' |
| if get: project_name = get.project_name.strip() |
| project_info = self.get_project_find(project_name) |
| if not project_info: return False |
| if not 'project_config' in project_info: return False |
| if not 'pids' in project_info['project_config']: return self.check_project_run_status_by_ps(project_info) |
| pid_file = project_info['project_config']['pids'] |
| if not os.path.exists(pid_file): return self.check_project_run_status_by_ps(project_info) |
| try: |
| pid = int(public.readFile(pid_file)) |
| except: |
| return self.check_project_run_status_by_ps(project_info) |
| pids = self.get_project_pids(pid = pid) |
| if not pids: return self.check_project_run_status_by_ps(project_info) |
| return True |
| |
| @staticmethod |
| def check_project_run_status_by_ps(project_conf: dict) -> bool: |
| cmd_str = project_conf["project_config"]['project_cmd'] |
| if not isinstance(cmd_str, str): |
| return False |
| cmd_str = re.sub(r' {2,}', ' ', cmd_str) |
| tmp: str = public.ExecShell('ps aux| grep "%s" |grep -v grep' % cmd_str)[0] |
| if not tmp.strip(): |
| return False |
| try: |
| tmp = re.sub(r' {2,}', ' ', tmp) |
| pids = [int(i.split(' ')[1]) for i in tmp.split("\n") if bool(i)] |
| except (IndexError, ValueError, TypeError): |
| return False |
| running_pid = [] |
| for pid in pids: |
| if pid in psutil.pids(): |
| running_pid.append(pid) |
| if not running_pid: |
| return False |
| if len(running_pid) == 1: |
| public.writeFile(project_conf["project_config"]['pids'], str(running_pid[0])) |
| return True |
| for pid in running_pid: |
| p = psutil.Process(pid) |
| if p.ppid() not in running_pid: |
| public.writeFile(project_conf["project_config"]['pids'], str(pid)) |
| return True |
| return False |
| |
| def get_duli_run_state(self, get=None, project_name=None, bt_tomcat_web='/www/server/bt_tomcat_web', neizhi=False): |
| ''' |
| @name 获取项目运行状态 |
| @author hwliang<2021-08-12> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @param project_name<string> 项目名称 |
| @return bool |
| ''' |
| if get: project_name = get.project_name.strip() |
| if neizhi: |
| pid_file = "{}/logs/catalina-daemon.pid".format(bt_tomcat_web, project_name) |
| else: |
| pid_file = "{}/{}/logs/catalina-daemon.pid".format(bt_tomcat_web, project_name) |
| if not os.path.exists(pid_file): |
| return False |
| try: |
| pid_data = public.readFile(pid_file) |
| if isinstance(pid_data, str) and bool(pid_data.strip()): |
| tmp_pid_data = pid_data.split() |
| if len(tmp_pid_data) < 1: |
| return False |
| pid = int(tmp_pid_data[0]) |
| pids = self.get_project_pids(pid = pid) |
| if not pids: return False |
| return True |
| else: |
| return False |
| except: |
| return False |
| |
| def format_connections(self, connects): |
| ''' |
| @name 获取进程网络连接信息 |
| @author hwliang<2021-08-09> |
| @param connects<pconn> |
| @return list |
| ''' |
| result = [] |
| for i in connects: |
| raddr = i.raddr |
| if not i.raddr: |
| raddr = ('', 0) |
| laddr = i.laddr |
| if not i.laddr: |
| laddr = ('', 0) |
| result.append( |
| { |
| "fd": i.fd, |
| "family": i.family, |
| "local_addr": laddr[0], |
| "local_port": laddr[1], |
| "client_addr": raddr[0], |
| "client_rport": raddr[1], |
| "status": i.status |
| } |
| ) |
| return result |
| |
| def get_project_load_info(self, get=None, project_name=None): |
| ''' |
| @name 获取项目负载信息 |
| @author hwliang<2021-08-12> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| if get: project_name = get.project_name.strip() |
| load_info = {} |
| |
| project_info = self.get_project_find(project_name) |
| if not project_info: return load_info |
| if not 'project_config' in project_info: return load_info |
| if not 'pids' in project_info['project_config']: return load_info |
| pid_file = project_info['project_config']['pids'] |
| if not os.path.exists(pid_file): return load_info |
| try: |
| pid = int(public.readFile(pid_file)) |
| except: |
| return load_info |
| pids = self.get_project_pids(pid = pid) |
| if not pids: return load_info |
| for i in pids: |
| process_info = self.get_process_info_by_pid(i) |
| if process_info: load_info[i] = process_info |
| return load_info |
| |
| def get_duli_load_info(self, get=None, project_name=None, bt_tomcat_web='/www/server/bt_tomcat_web/', neizhi=False): |
| ''' |
| @name 获取项目负载信息 |
| @author hwliang<2021-08-12> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| if get: project_name = get.project_name.strip() |
| load_info = {} |
| if neizhi: |
| pid_file = "{}/logs/catalina-daemon.pid".format(bt_tomcat_web, project_name) |
| else: |
| pid_file = "{}/{}/logs/catalina-daemon.pid".format(bt_tomcat_web, project_name) |
| if not os.path.exists(pid_file): return load_info |
| try: |
| pid_data = public.readFile(pid_file) |
| except: |
| return load_info |
| |
| if isinstance(pid_data, str): |
| pid = pid_data.split()[0] |
| pid = int(pid) |
| else: |
| return load_info |
| pids = self.get_project_pids(pid = pid) |
| if not pids: return load_info |
| for i in pids: |
| process_info = self.get_process_info_by_pid(i) |
| if process_info: load_info[i] = process_info |
| return load_info |
| |
| def get_connects(self, pid): |
| ''' |
| @name 获取进程连接信息 |
| @author hwliang<2021-08-09> |
| @param pid<int> |
| @return dict |
| ''' |
| connects = 0 |
| try: |
| if pid == 1: return connects |
| tp = '/proc/' + str(pid) + '/fd/' |
| if not os.path.exists(tp): return connects |
| for d in os.listdir(tp): |
| fname = tp + d |
| if os.path.islink(fname): |
| l = os.readlink(fname) |
| if l.find('socket:') != -1: connects += 1 |
| except: |
| pass |
| return connects |
| |
| def object_to_dict(self, obj): |
| ''' |
| @name 将对象转换为字典 |
| @author hwliang<2021-08-09> |
| @param obj<object> |
| @return dict |
| ''' |
| result = {} |
| for name in dir(obj): |
| value = getattr(obj, name) |
| if not name.startswith('__') and not callable(value) and not name.startswith('_'): result[name] = value |
| return result |
| |
| def list_to_dict(self, data): |
| ''' |
| @name 将列表转换为字典 |
| @author hwliang<2021-08-09> |
| @param data<list> |
| @return dict |
| ''' |
| result = [] |
| for s in data: |
| result.append(self.object_to_dict(s)) |
| return result |
| |
| def get_process_info_by_pid(self, pid): |
| ''' |
| @name 获取进程信息 |
| @author hwliang<2021-08-12> |
| @param pid: int<进程id> |
| @return dict |
| ''' |
| process_info = {} |
| try: |
| if not os.path.exists('/proc/{}'.format(pid)): return process_info |
| p = psutil.Process(pid) |
| status_ps = {'sleeping': '睡眠', 'running': '活动'} |
| with p.oneshot(): |
| p_mem = p.memory_full_info() |
| if p_mem.uss + p_mem.rss + p_mem.pss + p_mem.data == 0: return process_info |
| p_state = p.status() |
| if p_state in status_ps: p_state = status_ps[p_state] |
| |
| process_info['name'] = p.name() |
| process_info['pid'] = pid |
| process_info['ppid'] = p.ppid() |
| process_info['create_time'] = int(p.create_time()) |
| process_info['status'] = p_state |
| process_info['user'] = p.username() |
| process_info['memory_used'] = p_mem.uss |
| process_info['cpu_percent'] = self.get_cpu_precent(p) |
| try: |
| process_info['io_write_bytes'], process_info['io_read_bytes'] = p.io_counters() |
| except: |
| process_info['io_write_bytes'], process_info['io_read_bytes'] = 0, 0 |
| process_info['connections'] = self.format_connections(p.connections()) |
| process_info['connects'] = self.get_connects(pid) |
| process_info['open_files'] = self.list_to_dict(p.open_files()) |
| process_info['threads'] = p.num_threads() |
| process_info['exe'] = ' '.join(p.cmdline()) |
| return process_info |
| except: |
| return process_info |
| |
| def get_io_speed(self, p): |
| ''' |
| @name 获取磁盘IO速度 |
| @author hwliang<2021-08-12> |
| @param p: Process<进程对像> |
| @return list |
| ''' |
| skey = "io_speed_{}".format(p.pid) |
| old_pio = cache.get(skey) |
| if not hasattr(p, 'io_counters'): return 0, 0 |
| pio = p.io_counters() |
| if not old_pio: |
| cache.set(skey, [pio, time.time()], 3600) |
| |
| old_pio = cache.get(skey) |
| pio = p.io_counters() |
| old_write_bytes = old_pio[0].write_bytes |
| old_read_bytes = old_pio[0].read_bytes |
| old_time = old_pio[1] |
| new_time = time.time() |
| write_bytes = pio.write_bytes |
| read_bytes = pio.read_bytes |
| cache.set(skey, [pio, new_time], 3600) |
| write_speed = int((write_bytes - old_write_bytes) / (new_time - old_time)) |
| read_speed = int((read_bytes - old_read_bytes) / (new_time - old_time)) |
| return write_speed, read_speed |
| |
| def get_project_find(self, project_name): |
| ''' |
| @name 获取指定项目配置 |
| @author hwliang<2021-08-09> |
| @param project_name<string> 项目名称 |
| @return dict |
| ''' |
| project_info = public.M('sites').where('project_type=? AND name=?', ('Java', project_name)).find() |
| if isinstance(project_info, str): |
| raise public.PanelError('数据库查询错误：' + project_info) |
| if not project_info: return False |
| project_info['project_config'] = json.loads(project_info['project_config']) |
| return project_info |
| |
| def project_remove_domain(self, get): |
| ''' |
| @name 为指定项目删除域名 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| domain: string<域名> |
| } |
| @return dict |
| ''' |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return public.returnMsg(False, '指定项目不存在') |
| last_domain = get.domain |
| domain_arr = get.domain.split(':') |
| if len(domain_arr) == 1: |
| domain_arr.append(80) |
| if domain_arr[0] == get.project_name: return public.returnMsg(False, '不能删除当前项目域名') |
| project_id = public.M('sites').where('name=?', (get.project_name,)).getField('id') |
| if len(public.M('domain').where('pid=?', (project_find['id'],)).select()) == 1: |
| return public.returnMsg(False, '项目至少需要一个域名') |
| domain_id = public.M('domain').where('name=? AND pid=?', (domain_arr[0], project_id)).getField('id') |
| if not domain_id: |
| return public.returnMsg(False, '指定域名不存在') |
| public.M('domain').where('id=?', (domain_id,)).delete() |
| if get.domain in project_find['project_config']['domains']: |
| project_find['project_config']['domains'].remove(get.domain) |
| if get.domain + ":80" in project_find['project_config']['domains']: |
| project_find['project_config']['domains'].remove(get.domain + ":80") |
| public.M('sites').where('id=?', (project_id,)).save( |
| 'project_config', json.dumps(project_find['project_config']) |
| ) |
| public.WriteLog(self._log_name, '从项目：{}，删除域名{}'.format(get.project_name, get.domain)) |
| self.set_config(get.project_name) |
| self.del_hosts(domain_arr[0]) |
| return public.returnMsg(True, '删除域名成功') |
| |
| def project_get_domain(self, get): |
| ''' |
| @name 获取指定项目的域名列表 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| project_id = public.M('sites').where('name=?', (get.project_name,)).getField('id') |
| if not project_id: |
| return public.return_data(False, '站点查询失败') |
| domains = public.M('domain').where('pid=?', (project_id,)).order('id desc').select() |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| return domains |
| |
| def project_add_domain(self, get): |
| ''' |
| @name 为指定项目添加域名 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| domains: list<域名列表> |
| } |
| @return dict |
| ''' |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return public.returnMsg(False, '指定项目不存在') |
| project_id = project_find['id'] |
| domains = get.domains |
| flag = False |
| res_domains = [] |
| for domain in domains: |
| domain = domain.strip() |
| if not domain: continue |
| domain_arr = domain.split(':') |
| domain_arr[0] = self.check_domain(domain_arr[0]) |
| if domain_arr[0] is False: |
| res_domains.append({"name": domain, "status": False, "msg": '域名格式错误'}) |
| continue |
| if len(domain_arr) == 1: |
| domain_arr.append("") |
| if domain_arr[1] == "": |
| domain_arr[1] = 80 |
| domain += ':80' |
| try: |
| if not (0 < int(domain_arr[1]) < 65535): |
| res_domains.append({"name": domain, "status": False, "msg": '域名格式错误'}) |
| continue |
| except ValueError: |
| res_domains.append({"name": domain, "status": False, "msg": '域名格式错误'}) |
| continue |
| if not public.M('domain').where('name=?', (domain_arr[0],)).count(): |
| public.M('domain').add( |
| 'name,pid,port,addtime', (domain_arr[0], project_id, domain_arr[1], public.getDate()) |
| ) |
| if not domain in project_find['project_config']['domains']: |
| project_find['project_config']['domains'].append(domain) |
| public.WriteLog(self._log_name, '成功添加域名{}到项目{}'.format(domain, get.project_name)) |
| res_domains.append({"name": domain_arr[0], "status": True, "msg": '添加成功'}) |
| flag = True |
| else: |
| public.WriteLog(self._log_name, '添加域名错误，域名{}已存在'.format(domain)) |
| res_domains.append( |
| {"name": domain_arr[0], "status": False, "msg": '添加错误，域名{}已存在'.format(domain)} |
| ) |
| if flag: |
| public.M('sites').where('id=?', (project_id,)).save( |
| 'project_config', json.dumps(project_find['project_config']) |
| ) |
| self.set_config(get.project_name) |
| |
| return self._ckeck_add_domain(get.project_name, res_domains) |
| |
| def get_other_pids(self, pid): |
| ''' |
| @name 获取其他进程pid列表 |
| @author hwliang<2021-08-10> |
| @param pid: string<项目pid> |
| @return list |
| ''' |
| plugin_name = None |
| for pid_name in os.listdir(self._springboot_pid_path): |
| pid_file = '{}/{}'.format(self._springboot_pid_path, pid_name) |
| try: |
| s_pid = int(public.readFile(pid_file)) |
| except: |
| continue |
| if pid == s_pid: |
| plugin_name = pid_name[:-4] |
| break |
| project_find = self.get_project_find(plugin_name) |
| if not project_find: return [] |
| if not self._pids: self._pids = psutil.pids() |
| all_pids = [] |
| for i in self._pids: |
| try: |
| p = psutil.Process(i) |
| if p.cwd() == project_find['project_config']['jar_path'] and p.username() == \ |
| project_find['project_config']['run_user']: |
| if p.name() in ['java', 'jsvc', 'jsvc.exec']: |
| all_pids.append(i) |
| except: |
| continue |
| return all_pids |
| |
| def get_project_pids(self, get=None, pid=None): |
| ''' |
| @name 获取项目进程pid列表 |
| @author hwliang<2021-08-10> |
| @param pid: string<项目pid> |
| @return list |
| ''' |
| if get: pid = int(get.pid) |
| if not self._pids: self._pids = psutil.pids() |
| project_pids = [] |
| if pid not in self._pids: return [] |
| for i in self._pids: |
| try: |
| p = psutil.Process(i) |
| if p.status() == "zombie": |
| continue |
| if p.ppid() == pid: |
| if i in project_pids: |
| continue |
| project_pids.append(i) |
| except: |
| continue |
| other_pids = [] |
| for i in project_pids: |
| other_pids += self.get_project_pids(pid = i) |
| if os.path.exists('/proc/{}'.format(pid)): |
| project_pids.append(pid) |
| |
| all_pids = list(set(project_pids + other_pids)) |
| |
| |
| return sorted(all_pids) |
| |
| def stop_project(self, get): |
| ''' |
| @name 停止项目 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| project_info = self.get_project_find(get.project_name.strip()) |
| if not project_info: return public.returnMsg(False, '项目不存在') |
| |
| project_find = self.get_project_find(get.project_name) |
| if project_find['edate'] != "0000-00-00" and project_find['edate'] < datetime.datetime.today().strftime("%Y-%m-%d"): |
| return public.return_error('当前项目已过期，请重新设置项目到期时间') |
| |
| if project_info['project_config']['java_type'] == 'springboot': |
| |
| pid_file = project_info['project_config']['pids'] |
| if not os.path.exists(pid_file): return public.returnMsg(False, '项目未启动') |
| try: |
| pid = int(public.readFile(pid_file)) |
| except: |
| return public.returnMsg(False, '项目未启动') |
| pids = self.get_project_pids(pid = pid) |
| if not pids: return public.returnMsg(False, '项目未启动') |
| self.kill_pids(pids = pids) |
| if os.path.exists(pid_file): os.remove(pid_file) |
| self.stop_by_user(project_info["id"]) |
| return public.returnMsg(True, '停止成功') |
| if project_info['project_config']['java_type'] == 'duli': |
| get.domain = project_info['name'] |
| get.type = 'stop' |
| return self.pendent_tomcat_start(get) |
| if project_info['project_config']['java_type'] == 'neizhi': |
| get.version = project_info['project_config']['tomcat_version'] |
| get.type = 'stop' |
| return self.start_tomcat(get) |
| |
| def restart_project(self, get): |
| ''' |
| @name 重启项目 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| project_find = self.get_project_find(get.project_name) |
| if project_find['edate'] != "0000-00-00" and project_find['edate'] < datetime.datetime.today().strftime("%Y-%m-%d"): |
| return public.return_error('当前项目已过期，请重新设置项目到期时间') |
| res = self.stop_project(get) |
| if not res['status']: return res |
| res = self.start_project(get) |
| if not res['status']: return res |
| return public.returnMsg(True, '重启成功') |
| |
| def start_project(self, get): |
| ''' |
| @name 启动项目 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: return public.returnMsg(False, '项目不存在') |
| |
| project_find = self.get_project_find(get.project_name) |
| if project_find['edate'] != "0000-00-00" and project_find['edate'] < datetime.datetime.today().strftime("%Y-%m-%d"): |
| return public.return_error('当前项目已过期，请重新设置项目到期时间') |
| |
| self._update_project(get.project_name, project_find) |
| if project_find['project_config']['java_type'] == 'duli': |
| get.domain = project_find['name'] |
| get.type = 'start' |
| return self.pendent_tomcat_start(get) |
| if project_find['project_config']['java_type'] == 'neizhi': |
| get.version = project_find['project_config']['tomcat_version'] |
| get.type = 'start' |
| return self.start_tomcat(get) |
| if project_find['project_config']['java_type'] == 'springboot': |
| project_cmd = project_find["project_config"]['project_cmd'] |
| |
| log_file = project_find["project_config"]['logs'] |
| pid_file = project_find["project_config"]['pids'] |
| nohup_log = ' &>> {log_file}'.format(log_file = log_file) |
| if not int(project_find["project_config"].get('nohup_log', 1)): |
| nohup_log = '' |
| if 'jar_path' in project_find['project_config']: |
| jar_path = project_find['project_config']['jar_path'] |
| else: |
| jar_path = '{}'.format(self._springboot) |
| |
| start_cmd = '''#!/bin/bash |
| PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin |
| export PATH |
| cd {jar_path} |
| nohup {project_cmd}{nohup_log} & |
| echo $! > {pid_file} |
| '''.format( |
| jar_path = jar_path, |
| project_cmd = project_cmd, |
| pid_file = pid_file, |
| log_file = log_file, |
| nohup_log = nohup_log |
| ) |
| script_file = project_find["project_config"]['scripts'] |
| |
| public.writeFile(script_file, start_cmd) |
| if os.path.exists(pid_file): os.remove(pid_file) |
| public.ExecShell("chmod -R 777 /var/tmp/springboot/") |
| |
| public.set_mode(script_file, 755) |
| public.ExecShell( |
| "chown {}:{} {}".format( |
| project_find['project_config']['run_user'], project_find['project_config']['run_user'], |
| project_find['path'] |
| ) |
| ) |
| if not os.path.exists(log_file): public.ExecShell("touch {}".format(log_file)) |
| public.ExecShell( |
| "chown {}:{} {}".format( |
| project_find['project_config']['run_user'], project_find['project_config']['run_user'], log_file |
| ) |
| ) |
| self._pass_dir_for_user(os.path.dirname(log_file), project_find['project_config']['run_user']) |
| |
| |
| |
| p = public.ExecShell( |
| "bash {}".format(script_file), user = project_find['project_config']['run_user'], |
| env = os.environ.copy() |
| ) |
| time.sleep(1) |
| if not os.path.exists(pid_file): |
| return public.returnMsg(False, '启动失败,请尝试切换启动用户') |
| |
| |
| try: |
| pid = int(public.readFile(pid_file)) |
| except: |
| return public.returnMsg(True, '启动失败') |
| time.sleep(0.4) |
| pids = self.get_project_pids(pid = pid) |
| |
| |
| |
| self.start_by_user(project_find["id"]) |
| return public.returnMsg(True, '启动成功') |
| |
| def return_jdkcmd(self, get): |
| ''' |
| @name 修改JDK 返回所需命令 |
| @param jdK_path |
| @param cmd |
| @return string cmd |
| ''' |
| jdK_path = get.jdK_path.strip() |
| cmd = get.cmd.strip() |
| if not os.path.exists(jdK_path): return public.returnMsg(False, 'JDK路径不存在') |
| cmd2 = cmd.split() |
| if 'debug' in get: |
| debug = 1 |
| else: |
| debug = 0 |
| return_cmd = [] |
| for i in cmd2: |
| if '/java' in i: |
| return_cmd.append(jdK_path) |
| elif '-agentlib:' in i and debug: |
| continue |
| else: |
| return_cmd.append(i) |
| |
| return public.returnMsg(True, ' '.join(return_cmd)) |
| |
| def send_cmd(self, get): |
| port = get.port if 'port' in get else self.generate_random_port() |
| if not hasattr(get, 'project_jdk'): |
| return public.returnMsg(False, '缺少参数! project_jdk') |
| project_jdk = get.project_jdk |
| if not os.path.exists(project_jdk): return public.returnMsg(False, '项目JDK不存在') |
| project_jar = get.project_jar.strip() |
| if not os.path.exists(project_jar): return public.returnMsg(False, '项目jar不存在') |
| jmx_cmd = "" |
| if hasattr(get, 'jmx_status'): |
| if get.jmx_status: |
| jmx_port = self.generate_random_port() |
| jmx_cmd = "-Dcom.sun.management.jmxremote.port={} -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=127.0.0.1".format( |
| jmx_port |
| ) |
| |
| if 'debug' in get: |
| debug_port = self.generate_random_port() |
| return public.returnMsg( |
| True, |
| '{} -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address={} {} -jar -Xmx1024M -Xms256M {} --server.port={}'.format( |
| project_jdk, debug_port, jmx_cmd, project_jar, port |
| ) |
| ) |
| |
| lib_path_cmd = "" |
| if hasattr(get, 'lib_path') and get.lib_path: |
| lib_path_cmd = "-Dloader.path={}".format(get.lib_path) |
| return public.returnMsg( |
| True, '{} {} {} -jar -Xmx1024M -Xms256M {} --server.port={}'.format( |
| project_jdk, lib_path_cmd, jmx_cmd, project_jar, |
| port |
| ) |
| ) |
| |
| def return_cmd(self, get): |
| ''' |
| @name 获取启动的命令 |
| @author lkq<2021-08-27> |
| @param project_jar 项目jar路径 |
| @param port 项目端口号 |
| @param project_jdk 项目JDK |
| ''' |
| if 'project_cmd' not in get or not get.project_cmd.strip(): |
| return self.send_cmd(get) |
| else: |
| if not get.project_cmd: |
| return self.send_cmd(get) |
| |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return self.send_cmd(get) |
| project_cmd = get.project_cmd.strip() |
| cmd_type = int(get.type) |
| jmx_cmd = "" |
| if hasattr(get, 'jmx_status'): |
| project_find['project_config']['jmx_status'] = get.jmx_status |
| if get.jmx_status: |
| jmx_port = self.generate_random_port() |
| jmx_cmd = "-Dcom.sun.management.jmxremote.port={} -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=127.0.0.1".format( |
| jmx_port |
| ) |
| jmx_url = "service:jmx:rmi:///jndi/rmi://127.0.0.1:{}/jmxrmi".format(jmx_port) |
| project_find['project_config']['jmx_status'] = get.jmx_status |
| project_find['project_config']['jmx_info'] = { |
| "jmx_url": jmx_url, |
| "username": "", |
| "password": "", |
| } |
| |
| if cmd_type == 1: |
| old_port = str(project_find['project_config']['port']).strip() |
| if old_port: |
| project_cmd = project_find['project_config']['project_cmd'].replace(old_port, str(get.port)) |
| else: |
| res = self.send_cmd(get) |
| if not res["status"]: |
| return res |
| else: |
| project_cmd = res["msg"] |
| |
| project_find['project_config']['project_cmd'] = project_cmd |
| project_find['project_config']['port'] = get.port |
| project_find['project_config']['project_jdk'] = get.project_jdk.strip() |
| pdata = { |
| 'name': get.project_name.strip(), |
| 'project_config': json.dumps(project_find['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| return public.returnMsg(True, project_cmd) |
| if cmd_type == 2: |
| if 'project_jdk' in project_find['project_config']: |
| project_cmd = project_find['project_config']['project_cmd'].replace( |
| str(project_find['project_config']['project_jdk']), str(get.project_jdk.strip()) |
| ) |
| project_cmd = project_cmd.replace(str(project_find['project_config']['port']), str(get.port)) |
| else: |
| project_cmd = '{} {} -jar -Xmx1024M -Xms256M {} --server.port={}'.format( |
| get.project_jdk.strip(), jmx_cmd, get.project_jar.strip(), get.port |
| ) |
| |
| project_find['project_config']['project_cmd'] = project_cmd |
| project_find['project_config']['port'] = get.port |
| project_find['project_config']['project_jdk'] = get.project_jdk.strip() |
| pdata = { |
| 'name': get.project_name.strip(), |
| 'project_config': json.dumps(project_find['project_config']) |
| } |
| |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| return public.returnMsg(True, project_cmd) |
| if cmd_type == 3: |
| if 'debug' in get and get.debug in (True, 1, "1", "true"): |
| if get.debug: |
| debug_port = self.generate_random_port() |
| cmd = '{} -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address={} {} -jar -Xmx1024M -Xms256M {} --server.port={}'.format( |
| get.project_jdk, debug_port, jmx_cmd, |
| project_find['project_config'][ |
| 'project_jar'], |
| project_find['project_config']['port'] |
| ) |
| |
| project_find['project_config']['project_cmd'] = cmd |
| project_find['project_config']['port'] = get.port |
| project_find['project_config']['project_jdk'] = get.project_jdk.strip() |
| pdata = { |
| 'name': get.project_name.strip(), |
| 'project_config': json.dumps(project_find['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| return public.returnMsg(True, cmd) |
| cmd = '{} {} -jar -Xmx1024M -Xms256M {} --server.port={}'.format( |
| get.project_jdk, jmx_cmd, project_find['project_config']['project_jar'], |
| project_find['project_config']['port'] |
| ) |
| project_find['project_config']['project_cmd'] = cmd |
| project_find['project_config']['port'] = get.port |
| project_find['project_config']['project_jdk'] = get.project_jdk.strip() |
| pdata = { |
| 'name': get.project_name.strip(), |
| 'project_config': json.dumps(project_find['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| return public.returnMsg(True, cmd) |
| if cmd_type == 4: |
| cmd = '{} {} -jar -Xmx1024M -Xms256M {} --server.port={}'.format( |
| get.project_jdk, jmx_cmd, project_find['project_config']['project_jar'], |
| project_find['project_config']['port'] |
| ) |
| project_find['project_config']['project_cmd'] = cmd |
| project_find['project_config']['port'] = get.port |
| project_find['project_config']['project_jdk'] = get.project_jdk.strip() |
| pdata = { |
| 'name': get.project_name.strip(), |
| 'project_config': json.dumps(project_find['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| return public.returnMsg(True, cmd) |
| |
| def unbind_extranet(self, get): |
| ''' |
| @name 解绑外网 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| project_name = get.project_name.strip() |
| self.clear_config(project_name) |
| public.serviceReload() |
| project_find = self.get_project_find(project_name) |
| project_find['project_config']['bind_extranet'] = 0 |
| public.M('sites').where("id=?", (project_find['id'],)).setField( |
| 'project_config', |
| json.dumps(project_find['project_config']) |
| ) |
| public.WriteLog(self._log_name, 'Java项目{}, 关闭外网映射'.format(project_name)) |
| return public.returnMsg(True, '关闭成功') |
| |
| def bind_extranet(self, get): |
| ''' |
| @name 绑定外网 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| res_msg = self._check_webserver() |
| if res_msg: |
| return public.returnMsg(False, res_msg) |
| if not public.is_apache_nginx(): return public.returnMsg(False, '请先安装Apache或者Nginx!') |
| project_name = get.project_name.strip() |
| project_find = self.get_project_find(project_name) |
| if not project_find: return public.returnMsg(False, '项目不存在') |
| if not project_find['project_config']['domains']: return public.returnMsg( |
| False, '请先到【域名管理】选项中至少添加一个域名' |
| ) |
| project_find['project_config']['bind_extranet'] = 1 |
| public.M('sites').where("id=?", (project_find['id'],)).setField( |
| 'project_config', json.dumps(project_find['project_config']) |
| ) |
| self.set_config(project_name) |
| public.WriteLog(self._log_name, 'Java项目{}, 开启外网映射'.format(project_name)) |
| return public.returnMsg(True, '开启外网映射成功') |
| |
| def create_project(self, get): |
| ''' |
| @name 创建项目 |
| @author lkq<2021-08-27> |
| @param project_type 项目类型 1 内置 2 独立 3 Spring_boot 项目 |
| @return string |
| ''' |
| try: |
| project_type = int(get.project_type) |
| except: |
| return public.returnMsg(False, '项目类型参数错误') |
| if project_type == 1: |
| |
| isError = public.checkWebConfig() |
| if isError != True: |
| return public.returnMsg( |
| False, 'WEB服务器配置配置文件错误ERROR:<br><font style="color:red;">' + isError.replace( |
| "\n", '<br>' |
| ) + '</font>' |
| ) |
| return self.create_internal_project(get) |
| elif project_type == 2: |
| |
| isError = public.checkWebConfig() |
| if isError != True: |
| return public.returnMsg( |
| False, 'WEB服务器配置配置文件错误ERROR:<br><font style="color:red;">' + isError.replace( |
| "\n", '<br>' |
| ) + '</font>' |
| ) |
| return self.create_independent_project(get) |
| elif project_type == 3: |
| return self.create_spring_boot_project(get) |
| |
| def create_internal_project(self, get): |
| ''' |
| @name 创建内置项目 |
| @author lkq<2021-08-27> |
| @param domain 域名 |
| @param tomcat_version tomcat版本 7 8 9 |
| @param project_path 项目路径 |
| @param project_ps 项目描述 |
| @param bind_extranet 绑定外网 默认不需要传递 |
| @return string |
| ''' |
| if not public.is_apache_nginx(): return public.returnMsg(False, '未安装Apache或Nginx') |
| if not 'domain' in get: return public.returnMsg(False, '请指定域名!') |
| if not 'tomcat_version' in get: return public.returnMsg(False, '请指定tomcat版本!') |
| if not 'project_path' in get: return public.returnMsg(False, '请指定项目路径!') |
| if not 'project_name' in get: |
| get.project_name = get.domain |
| else: |
| get.project_name = get.domain |
| if not 'bind_extranet' in get: |
| get.bind_extranet = 1 |
| else: |
| get.bind_extranet = 1 |
| domain = get.domain.strip() |
| |
| if not self.is_domain(domain): return public.returnMsg(False, "请输入正确的域名") |
| |
| if public.M('domain').where('name=?', domain).count(): |
| return public.returnMsg(False, '指定域名已存在: {}'.format(domain)) |
| tomcat_version = str(get.tomcat_version) |
| project_path = get.project_path.strip() |
| if not os.path.exists(project_path): |
| os.makedirs(project_path) |
| public.set_own(project_path, 'www') |
| |
| tomcat_list = ["7", "8", "9"] |
| if not tomcat_version in tomcat_list: return public.returnMsg(False, '请指定tomcat版本!') |
| |
| tomcat_info = self.get_tomcat_info(tomcat_version) |
| if tomcat_info['stype'] == 'uninstall': return public.returnMsg(False, '选择的tomcat不存在!') |
| |
| |
| res = public.ExecShell('sed -n "142p" /usr/local/bttomcat/tomcat{}/bin/daemon.sh'.format(tomcat_version))[0] |
| _path = '/www/wwwlogs/java/neizhi{}'.format(tomcat_version) |
| if not os.path.exists(_path): |
| os.makedirs(_path) |
| if not res.startswith('test ".$CATALINA_OUT" = . && CATALINA_OUT="$CATALINA_BASE/logs/catalina-daemon.out"'): |
| self._change_daemom_sh("/usr/local/bttomcat/tomcat%s/bin/daemon.sh" % tomcat_version, _path) |
| |
| |
| if not self.Initialization(tomcat_version): return public.returnMsg( |
| False, "tomcat%s配置文件错误或者服务未安装" % tomcat_version |
| ) |
| |
| tomcat_port = tomcat_info['port'] |
| |
| if self.add_vhost(path = project_path, domain = domain): |
| |
| |
| pdata = { |
| 'name': domain, |
| 'path': project_path, |
| 'ps': get.project_ps, |
| 'status': 1, |
| 'type_id': 0, |
| 'project_type': 'Java', |
| 'project_config': json.dumps( |
| { |
| 'ssl_path': '/www/wwwroot/java_node_ssl', |
| 'project_name': domain, |
| 'project_cwd': project_path, |
| 'bind_extranet': 1, |
| 'domains': [], |
| 'tomcat_version': tomcat_version, |
| 'java_type': 'neizhi', |
| 'server_xml': '/usr/local/bttomcat/tomcat%s/conf/server.xml' % tomcat_version, |
| 'port': int(tomcat_port), |
| 'auth': '1', |
| 'nohup_log': get.nohup_log if hasattr(get, 'nohup_log') else 1 |
| } |
| ), |
| 'addtime': public.getDate() |
| } |
| domains = [] |
| if get.bind_extranet == 1: |
| domains.append(domain) |
| project_id = public.M('sites').insert(pdata) |
| self.set_hosts(domain) |
| |
| if get.bind_extranet == 1: |
| format_domains = [] |
| for domain in domains: |
| if domain.find(':') == -1: domain += ':80' |
| format_domains.append(domain) |
| get.domains = format_domains |
| self.project_add_domain(get) |
| self.set_config(domain) |
| public.WriteLog(self._log_name, '添加Java项目{}'.format(domain)) |
| |
| |
| get.version = tomcat_version |
| get.type = 'reload' |
| self.start_tomcat(get) |
| return public.returnMsg(True, "添加成功") |
| else: |
| return public.returnMsg(False, "添加失败") |
| |
| def create_independent_project(self, get): |
| ''' |
| @name 创建独立项目 |
| @author lkq<2021-08-27> |
| @param domain 域名 |
| @param project_path 项目路径 |
| @param port 端口号 |
| @param tomcat_version 项目tomcat版本 7 8 9 |
| #param project_ps 项目描述 |
| @param auth 开机自动启动 |
| ''' |
| |
| if not public.is_apache_nginx(): return public.returnMsg(False, '未安装Apache或Nginx') |
| if 'auto' not in get: get.auto = '0' |
| port = get.port |
| project_path = get.project_path.strip() |
| |
| if not hasattr(get, "tomcat_version"): |
| return public.returnMsg(False, '未指定Tomcat版本') |
| tomcat_version = str(get.tomcat_version) |
| domain = get.domain.strip() |
| if not 'project_name' in get: |
| get.project_name = get.domain |
| else: |
| get.project_name = get.domain |
| if hasattr(get, 'jdk_path'): |
| jdk_path = get.jdk_path.strip() |
| else: |
| jdk_path = "/usr/local/btjdk/jdk8" |
| |
| if not self.is_domain(domain): return public.returnMsg(False, "请输入正确的域名") |
| |
| if public.M('domain').where('name=?', domain).count(): |
| return public.returnMsg(False, '指定域名已存在: {}'.format(domain)) |
| if 'bind_extranet' in get: |
| get.bind_extranet = 1 |
| else: |
| get.bind_extranet = 1 |
| tomcat_list = ["7", "8", "9"] |
| if not tomcat_version in tomcat_list: return public.returnMsg(False, '请指定tomcat版本!') |
| if int(port) < 1 or int(port) > 65535: return public.returnMsg(False, '端口范围不合法') |
| if self.check_port(port): return public.returnMsg(False, "端口被占用, 请更换其他端口") |
| |
| if os.path.exists(self.__site_path + domain): return public.returnMsg( |
| False, "该网站已经存在。如想建立请删除%s" % self.__site_path + domain |
| ) |
| if not os.path.exists(project_path): |
| os.makedirs(project_path) |
| public.set_own(project_path, 'www') |
| |
| if not os.path.exists(self.__site_path + domain): |
| public.ExecShell('mkdir -p %s' % self.__site_path + domain) |
| if tomcat_version == 'tomcat7' or tomcat_version == '7': |
| if not os.path.exists(self.__tomcat7_path_bak + '/conf/server.xml'): return public.returnMsg( |
| False, "tomcat7的配置文件不存在，请重新安装tomcat7" |
| ) |
| public.ExecShell( |
| 'cp -r %s/* %s && chown -R www:www %s' % ( |
| self.__tomcat7_path_bak, self.__site_path + domain, self.__site_path + domain) |
| ) |
| if tomcat_version == 'tomcat8' or tomcat_version == '8': |
| if not os.path.exists(self.__tomcat8_path_bak + '/conf/server.xml'): return public.returnMsg( |
| False, "tomcat8的配置文件不存在，请重新安装tomcat8" |
| ) |
| public.ExecShell( |
| 'cp -r %s/* %s && chown -R www:www %s' % ( |
| self.__tomcat8_path_bak, self.__site_path + domain, self.__site_path + domain) |
| ) |
| if tomcat_version == 'tomcat9' or tomcat_version == '9': |
| if not os.path.exists(self.__tomcat9_path_bak + '/conf/server.xml'): return public.returnMsg( |
| False, "tomcat9的配置文件不存在，请重新安装tomcat9" |
| ) |
| public.ExecShell( |
| 'cp -r %s/* %s && chown -R www:www %s' % ( |
| self.__tomcat9_path_bak, self.__site_path + domain, self.__site_path + domain) |
| ) |
| |
| if os.path.exists(self.__site_path + domain + '/conf/server.xml'): |
| ret = '''<Server port="{}" shutdown="SHUTDOWN"> |
| <Listener className="org.apache.catalina.startup.VersionLoggerListener" /> |
| <Listener SSLEngine="on" className="org.apache.catalina.core.AprLifecycleListener" /> |
| <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" /> |
| <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" /> |
| <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" /> |
| <GlobalNamingResources> |
| <Resource auth="Container" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" name="UserDatabase" pathname="conf/tomcat-users.xml" type="org.apache.catalina.UserDatabase" /> |
| </GlobalNamingResources> |
| <Service name="Catalina"> |
| <Connector connectionTimeout="20000" port="8083" protocol="HTTP/1.1" redirectPort="8490" /> |
| <Engine defaultHost="localhost" name="Catalina"> |
| <Realm className="org.apache.catalina.realm.LockOutRealm"> |
| <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase" /> |
| </Realm> |
| <Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true"> |
| <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" pattern="%h %l %u %t "%r" %s %b" prefix="localhost_access_log" suffix=".txt" /> |
| </Host> |
| </Engine> |
| </Service> |
| </Server>'''.format(self.generate_random_port()) |
| log_path = "/www/wwwlogs/java/{}".format(get.project_name) |
| if not os.path.exists(log_path) or os.path.isfile(log_path): |
| os.makedirs(log_path, mode = 0o777) |
| if not self._change_daemom_sh( |
| self.__site_path + domain + '/bin/daemon.sh', log_path, domain.replace(".", '_') |
| ): |
| os.system('rm -rf %s' % self.__site_path + domain) |
| return public.returnMsg(False, "配置文件不存在请重新安装tomcat后尝试新建网站") |
| public.WriteFile(self.__site_path + domain + '/conf/server.xml', ret) |
| else: |
| os.system('rm -rf %s' % self.__site_path + domain) |
| return public.returnMsg(False, "配置文件不存在请重新安装tomcat后尝试新建网站") |
| |
| if not self.Initialization2(tomcat_version, domain): return public.returnMsg( |
| False, "配置文件错误或者服务未安装" |
| ) |
| |
| ret = self.set_site_port(port, tomcat_version, domain) |
| if not ret['status']: return ret |
| ret = self.add_vhost(path = project_path, domain = domain) |
| if ret: |
| self.set_hosts(domain) |
| |
| pid_path = '/www/server/web_site/%s/logs/catalina-daemon.pid' % domain |
| if os.path.exists(pid_path): |
| os.remove(pid_path) |
| public.ExecShell('sh %s' % self.__site_path + domain + '/bin/daemon.sh start') |
| |
| pdata = { |
| 'name': domain, |
| 'path': project_path, |
| 'ps': get.project_ps, |
| 'status': 1, |
| 'type_id': 0, |
| 'project_type': 'Java', |
| 'project_config': json.dumps( |
| { |
| 'ssl_path': '/www/wwwroot/java_node_ssl', |
| 'project_name': domain, |
| 'project_cwd': project_path, |
| 'bind_extranet': 1, |
| 'domains': [], |
| 'java_type': 'duli', |
| 'tomcat_version': tomcat_version, |
| 'server_xml': self.__site_path + domain + '/conf/server.xml', |
| 'jdk_path': jdk_path, |
| 'port': int(port), |
| 'auth': get.auth, |
| 'logs': "/www/wwwlogs/java/{}/".format(domain), |
| 'nohup_log': get.nohup_log if hasattr(get, 'nohup_log') else 1 |
| } |
| ), |
| 'addtime': public.getDate() |
| } |
| domains = [] |
| if get.bind_extranet == 1: |
| domains.append(domain) |
| project_id = public.M('sites').insert(pdata) |
| self.set_hosts(domain) |
| |
| if get.bind_extranet == 1: |
| format_domains = [] |
| for domain in domains: |
| if domain.find(':') == -1: domain += ':80' |
| format_domains.append(domain) |
| get.domains = format_domains |
| self.project_add_domain(get) |
| self.set_config(domain) |
| if jdk_path != "/usr/local/btjdk/jdk8": |
| self.change_duli_tomcat_jdk(domain, jdk_path) |
| |
| public.WriteLog(self._log_name, '添加Java项目{}'.format(domain)) |
| return public.returnMsg(True, "添加成功") |
| else: |
| return public.returnMsg(False, "域名存在") |
| |
| def check_port_is_used(self, port, sock=False): |
| ''' |
| @name 检查端口是否被占用 |
| @author hwliang<2021-08-09> |
| @param port: int<端口> |
| @return bool |
| ''' |
| if not isinstance(port, int): port = int(port) |
| if port == 0: return False |
| project_list = public.M('sites').where('status=? AND project_type=?', (1, 'Java')).field( |
| 'name,path,project_config' |
| ).select() |
| for project_find in project_list: |
| project_config = json.loads(project_find['project_config']) |
| if not 'port' in project_config: continue |
| try: |
| if int(project_config['port']) == port: |
| return True |
| except: |
| continue |
| if sock: return False |
| return public.check_tcp('127.0.0.1', port) |
| |
| def get_host_url(self, get): |
| if 'port' in get: |
| port = get['port'] |
| return 'http://127.0.0.1:'.format(port) |
| else: |
| return 'http://127.0.0.1:6611' |
| |
| def create_spring_boot_project(self, get): |
| ''' |
| @name 创建Spring_boot项目 |
| @author lkq<2021-08-27> |
| @param domains 域名 可选 |
| @param project_jar 项目jar路径 |
| @param project_name 项目名称 |
| @param port 项目端口号 |
| @param project_jdk 项目JDK |
| @param project_cmd 最终执行的命令 |
| @parcm run_user 项目用户 |
| @parcm bind_extranet 是否绑定外网 |
| @param auth 开启自启动 |
| @parcm project_ps 描述 |
| ''' |
| self.set_spring_user() |
| if get.run_user != 'root': |
| ret = public.ReadFile('/etc/passwd') |
| if isinstance(ret, str): |
| rec = 'springboot' |
| if not re.search(rec, ret): |
| return public.returnMsg( |
| False, 'springboot用户建立失败,疑是安全软件拦截。手动建立用户操作如下: useradd -s /sbin/nologin springboot' |
| ) |
| else: |
| return public.returnMsg( |
| False, 'springboot用户建立失败,疑是安全软件拦截。手动建立用户操作如下: useradd -s /sbin/nologin springboot' |
| ) |
| if not 'project_jdk' in get: return public.returnMsg(False, "请输入你的JDK路径") |
| if not 'project_jar' in get: return public.returnMsg(False, "请输入你的jar路径") |
| if not 'project_name' in get and get.project_name.strip(): return public.returnMsg(False, "请输入你的项目名称") |
| if not 'port' in get: return public.returnMsg(False, "请输入你的项目端口号") |
| if not 'run_user' in get: return public.returnMsg(False, "请输入你的项目用户") |
| |
| if not 'project_cmd' in get: return public.returnMsg(False, "请输入你的项目启动命令") |
| if not hasattr(get, 'project_ps'): return public.returnMsg(False, "请输入你的项目启动命令") |
| if not 'project_ps' in get: get.project_ps = '' |
| if not 'is_separation' in get: get.is_separation = 0 |
| get.project_name = get.project_name.strip() |
| if public.M('sites').where('name=? ', (get.project_name,)).count(): |
| return public.return_error('指定项目名称已存在: {}'.format(get.project_name)) |
| project_path = os.path.dirname(get.project_jar) |
| if not public.check_site_path(project_path): |
| a, c = public.get_sys_path() |
| return public.returnMsg(False, '请不要项目文件放到以下关键目录中: <br>{}'.format("<br>".join(a + c))) |
| |
| if get.is_separation: |
| if public.get_webserver() == 'apache': |
| return public.returnMsg(False, "前后端分离不支持Apache") |
| get.is_separation = 1 |
| |
| if get.is_separation and ('static_path' not in get or not get.static_path.strip()): |
| get.static_path = '/www/wwwroot/' + get.project_name.split('/')[0] |
| if 'api_url' not in get or not get.api_url.strip(): |
| get.api_url = '/' |
| elif get.api_url != '/' and get.api_url[-1] == '/': |
| get.api_url = get.api_url[:-1] |
| if not hasattr(get, 'auth'): |
| get.auth = '0' |
| if get.is_separation: |
| if 'host_url' not in get or not get.host_url.strip(): |
| return public.returnMsg(False, "请输入你需要的后端地址") |
| else: |
| if get.host_url[-1] == '/': |
| get.host_url = get.host_url[:-1] |
| if 'domains' in get: |
| domains = get.domains |
| if len(domains) >= 1: |
| get.bind_extranet = 1 |
| |
| isError = public.checkWebConfig() |
| if isError != True: |
| return public.returnMsg( |
| False, 'WEB服务器配置配置文件错误ERROR:<br><font style="color:red;">' + isError.replace( |
| "\n", '<br>' |
| ) + '</font>' |
| ) |
| else: |
| get.bind_extranet = 0 |
| else: |
| get.domains = [] |
| get.bind_extranet = 0 |
| if public.M('sites').where('name=?', (get.project_name,)).count(): |
| return public.returnMsg(False, '指定项目名称已存在: {}'.format(get.project_name)) |
| project_name = get.project_name.strip() |
| |
| |
| |
| if self.check_port(get.port): |
| return public.returnMsg( |
| False, '指定端口已被其它应用占用，请修改您的项目配置使用其它端口, 端口: {}'.format(get.port) |
| ) |
| |
| if not os.path.exists(get.project_jdk): return public.returnMsg(False, '请输入正确的JDK路径') |
| domains = [] |
| if get.bind_extranet == 1: |
| domains = get.domains |
| for domain in domains: |
| domain_arr = domain.split(':') |
| if public.M('domain').where('name=?', domain_arr[0]).count(): |
| return public.returnMsg(False, '指定域名已存在: {}'.format(domain)) |
| |
| project_jar = get.project_jar.strip() |
| if not os.path.exists(project_jar): return public.returnMsg(False, '请输入正确的jar包路径') |
| |
| if not get.is_separation: |
| get.host_url = False |
| pdata = { |
| 'name': get.project_name, |
| 'path': get.project_jar, |
| 'ps': get.project_ps, |
| 'status': 1, |
| 'type_id': 0, |
| 'project_type': 'Java', |
| 'project_config': json.dumps( |
| { |
| 'project_jdk': get.project_jdk.strip(), |
| 'ssl_path': '/www/wwwroot/java_node_ssl', |
| 'project_name': get.project_name.strip(), |
| 'project_jar': get.project_jar.strip(), |
| 'bind_extranet': get.bind_extranet, |
| 'domains': [], |
| 'run_user': get.run_user.strip(), |
| 'jmx_status': getattr(get, "jmx_status", False), |
| 'jmx_info': { |
| "jmx_url": "service:jmx:rmi:///jndi/rmi://127.0.0.1:{}/jmxrmi".format(get.jmx_port) if hasattr( |
| get, "jmx_port" |
| ) else None, |
| "username": "", |
| "password": "", |
| }, |
| 'port': int(get.port), |
| 'auth': get.auth, |
| 'project_cmd': get.project_cmd.strip(), |
| 'java_type': 'springboot', |
| 'jar_path': project_path, |
| 'pids': self._springboot_pid_path + '/' + get.project_name.strip() + '.pid', |
| 'logs': self._springboot_logs_path + '/' + get.project_name.strip() + '.log', |
| 'scripts': self._springboot_run_scripts + '/' + get.project_name.strip() + '.sh', |
| 'is_separation': get.is_separation, |
| 'static_path': getattr(get, "static_path", None), |
| 'api_url': get.api_url, |
| 'host_url': get.host_url, |
| 'nohup_log': get.nohup_log if hasattr(get, 'nohup_log') else 1 |
| } |
| ), |
| 'addtime': public.getDate() |
| } |
| project_id = public.M('sites').insert(pdata) |
| if get.bind_extranet == 1: |
| format_domains = [] |
| for domain in domains: |
| if domain.find(':') == -1: domain += ':80' |
| format_domains.append(domain) |
| get.domains = format_domains |
| self.project_add_domain(get) |
| self.set_config(get.project_name) |
| |
| public.ExecShell("chown {}:{} {}".format(get.run_user.strip(), get.run_user.strip(), project_path)) |
| if get.is_separation: |
| if not os.path.exists(get.static_path): |
| public.ExecShell("mkdir -p {}".format(get.static_path)) |
| public.ExecShell("chown {}:{} {}".format(get.run_user.strip(), get.run_user.strip(), get.static_path)) |
| else: |
| public.ExecShell( |
| "chown -R {}:{} {}".format(get.run_user.strip(), get.run_user.strip(), get.static_path) |
| ) |
| |
| public.WriteLog(self._log_name, '添加Java Springboot项目{}'.format(get.project_name)) |
| self.start_project(get) |
| |
| load_info = self.get_project_load_info(project_name = get.project_name) |
| if load_info: |
| listen = [] |
| for pid in load_info.keys(): |
| if 'connections' not in load_info[pid]: |
| continue |
| for conn in load_info[pid]['connections']: |
| if not conn['status'] == 'LISTEN': |
| continue |
| if not conn['local_port'] in listen: |
| listen.append(str(conn['local_port'])) |
| if listen: |
| get.port = ",".join(listen) |
| |
| flag, tip = self._release_firewall(get) |
| msg = '添加项目成功' + ("" if flag else "<br>" + tip) |
| if "use_project_watch" in get and get.use_project_watch in ("1", "true", "yes", 1): |
| add_project_watch( |
| p_name = get.project_name.strip(), |
| p_type = "java", |
| site_id = project_id, |
| watch_path = get.project_jar.strip() |
| ) |
| return public.returnMsg(True, msg, project_id) |
| |
| def kill_pids(self, get=None, pids=None): |
| ''' |
| @name 结束进程列表 |
| @author hwliang<2021-08-10> |
| @param pids: string<进程pid列表> |
| @return dict |
| ''' |
| if get: pids = get.pids |
| if not pids: return public.returnMsg(True, '没有进程') |
| pids = sorted(pids, reverse = True) |
| for i in pids: |
| try: |
| p = psutil.Process(i) |
| p.terminate() |
| except: |
| pass |
| return public.returnMsg(True, '进程已全部结束') |
| |
| def get_project_list2(self, get): |
| ''' |
| @name 取项目列表 |
| @author lkq<2021-08-27> |
| @param domain 域名 |
| @return string |
| ''' |
| if not 'p' in get: get.p = 1 |
| if not 'limit' in get: get.limit = 12 |
| if not 'callback' in get: get.callback = '' |
| if not 'order' in get: get.order = 'id desc' |
| |
| if 'search' in get: |
| get.project_name = get.search.strip() |
| search = "%{}%".format(get.project_name) |
| count = public.M('sites').where( |
| 'project_type=? AND (name LIKE ? OR ps LIKE ?)', ('Java', search, search) |
| ).count() |
| data = public.get_page(count, int(get.p), int(get.limit), get.callback) |
| data['data'] = public.M('sites').where( |
| 'project_type=? AND (name LIKE ? OR ps LIKE ?)', ('Java', search, search) |
| ).limit(data['shift'] + ',' + data['row']).order(get.order).select() |
| else: |
| count = public.M('sites').where('project_type=?', 'Java').count() |
| data = public.get_page(count, int(get.p), int(get.limit), get.callback) |
| data['data'] = public.M('sites').where('project_type=?', 'Java').limit( |
| data['shift'] + ',' + data['row'] |
| ).order(get.order).select() |
| |
| for i in range(len(data['data'])): |
| project_config = json.loads(data['data'][i]['project_config']) |
| |
| if project_config['java_type'] == 'neizhi' or project_config['java_type'] == 'duli': |
| if not os.path.exists(project_config['server_xml']): |
| |
| data['data'][i]['is_file_ok'] = False |
| else: |
| data['data'][i]['is_file_ok'] = True |
| |
| |
| |
| |
| for i in range(len(data['data'])): |
| data['data'][i] = self.get_project_stat(data['data'][i]) |
| return data |
| |
| def get_tomcat_domain(self, get): |
| verison = str(get.version).strip() |
| version_list = ["7", "8", "9"] |
| if verison not in version_list: return public.returnMsg(False, '请选择版本') |
| data = public.M('sites').where('project_type=?', ('Java')).select() |
| ret = [] |
| for i in data: |
| project_config = json.loads(i['project_config']) |
| if project_config['java_type'] == 'neizhi': |
| if project_config["tomcat_version"] == verison: |
| ret.append(i['name']) |
| return ret |
| |
| def get_project_list(self, get): |
| ''' |
| @name 取项目列表 |
| @author lkq<2021-08-27> |
| @param domain 域名 |
| @return string |
| ''' |
| if not 'p' in get: get.p = 1 |
| if not 'limit' in get: get.limit = 20 |
| if not 'callback' in get: get.callback = '' |
| if not 'order' in get: get.order = 'id desc' |
| type_id = None |
| if "type_id" in get: |
| try: |
| type_id = int(get.type_id) |
| except: |
| type_id = None |
| |
| if 'search' in get: |
| get.project_name = get.search.strip() |
| search = "%{}%".format(get.project_name) |
| if type_id is None: |
| count = public.M('sites').where( |
| 'project_type=? AND (name LIKE ? OR ps LIKE ?)', |
| ('Java', search, search) |
| ).count() |
| data = public.get_page(count, int(get.p), int(get.limit), get.callback) |
| data['data'] = public.M('sites').where( |
| 'project_type=? AND (name LIKE ? OR ps LIKE ?)', |
| ('Java', search, search) |
| ).limit( |
| data['shift'] + ',' + data['row'] |
| ).order(get.order).select() |
| else: |
| count = public.M('sites').where( |
| 'project_type=? AND (name LIKE ? OR ps LIKE ?) AND type_id = ?', |
| ('Java', search, search, type_id) |
| ).count() |
| data = public.get_page(count, int(get.p), int(get.limit), get.callback) |
| data['data'] = public.M('sites').where( |
| 'project_type=? AND (name LIKE ? OR ps LIKE ?) AND type_id = ?', |
| ('Java', search, search, type_id) |
| ).limit( |
| data['shift'] + ',' + data['row'] |
| ).order(get.order).select() |
| |
| else: |
| if type_id is None: |
| count = public.M('sites').where('project_type=?', 'Java').count() |
| data = public.get_page(count, int(get.p), int(get.limit), get.callback) |
| data['data'] = public.M('sites').where('project_type=?', 'Java').limit( |
| data['shift'] + ',' + data['row'] |
| ).order(get.order).select() |
| else: |
| count = public.M('sites').where('project_type=? AND type_id = ?', ('Java', type_id)).count() |
| data = public.get_page(count, int(get.p), int(get.limit), get.callback) |
| data['data'] = public.M('sites').where('project_type=? AND type_id = ?', ('Java', type_id)).limit( |
| data['shift'] + ',' + data['row'] |
| ).order(get.order).select() |
| |
| if isinstance(data["data"], str) and data["data"].startswith("error"): |
| raise public.PanelError("数据库查询错误：" + data["data"]) |
| |
| |
| for i in range(len(data['data'])): |
| project_config = json.loads(data['data'][i]['project_config']) |
| |
| if project_config['java_type'] == 'neizhi': |
| if not os.path.exists(project_config['server_xml']): |
| |
| data['data'][i]['is_file_ok'] = False |
| else: |
| |
| if not self.Initialization(project_config['tomcat_version']): data['data'][i]['is_file_ok'] = False |
| if self.get_vhost(data['data'][i]['name']): |
| data['data'][i]['is_file_ok'] = True |
| else: |
| data['data'][i]['is_file_ok'] = False |
| if project_config['java_type'] == 'duli': |
| if not os.path.exists(project_config['server_xml']): |
| data['data'][i]['is_file_ok'] = False |
| else: |
| if not self.Initialization2(version = '7', site = data['data'][i]['name']): data['data'][i][ |
| 'is_file_ok'] = False |
| if self.get_vhost(data['data'][i]['name']): |
| data['data'][i]['is_file_ok'] = True |
| else: |
| data['data'][i]['is_file_ok'] = False |
| for i in range(len(data['data'])): |
| data['data'][i] = self.get_project_stat(data['data'][i]) |
| project_config = data['data'][i]['project_config'] |
| project_config["use_project_watch"] = use_project_watch(project_config['project_name']) |
| if 'project_cmd' in project_config: |
| |
| if '-Dloader.path=' in project_config['project_cmd']: |
| |
| lib_path = project_config['project_cmd'].split("-Dloader.path=")[1].split(" ")[0] |
| |
| data['data'][i]['lib_path'] = lib_path |
| |
| |
| return data |
| |
| |
| def fix_project(self, get): |
| ''' |
| @name 修复项目 |
| @author lkq<2021-08-27> |
| @param project_name 域名 |
| @return string |
| ''' |
| if not public.is_apache_nginx(): return public.returnMsg(False, '未安装Apache或Nginx') |
| project_info = self.get_project_find(get.project_name.strip()) |
| if not project_info: return public.returnMsg(False, '项目不存在') |
| project_config = project_info['project_config'] |
| if project_config['java_type'] == 'duli': |
| if not os.path.exists( |
| self.__bttomcat_path + "/tomcat_bak{}/conf/server.xml".format( |
| project_config['tomcat_version'] |
| ) |
| ): return public.returnMsg(False, '修复失败当前Tomcat版本未安装') |
| tomcat_list = ["7", "8", "9"] |
| if not project_config['tomcat_version'] in tomcat_list: return public.returnMsg(False, '请指定tomcat版本!') |
| if self.check_port(str(project_config['port'])): |
| return public.returnMsg(False, "%s端口被占用,修复失败" % str(project_config['port'])) |
| |
| if not os.path.exists(project_info['path']): |
| os.makedirs(project_info['path']) |
| public.set_own(project_info['path'], 'www') |
| |
| domain = project_info['name'] |
| if os.path.exists(self.__site_path + domain): |
| public.ExecShell('rm -rf ' + self.__site_path + domain) |
| tomcat_version = project_config['tomcat_version'] |
| |
| if not os.path.exists(self.__site_path + domain): |
| public.ExecShell('mkdir -p %s' % self.__site_path + domain) |
| if tomcat_version == 'tomcat7' or tomcat_version == '7': |
| if not os.path.exists(self.__tomcat7_path_bak + '/conf/server.xml'): return public.returnMsg( |
| False, "tomcat7的配置文件不存在，请重新安装tomcat7" |
| ) |
| public.ExecShell( |
| 'cp -r %s/* %s && chown -R www:www %s' % ( |
| self.__tomcat7_path_bak, self.__site_path + domain, self.__site_path + domain) |
| ) |
| if tomcat_version == 'tomcat8' or tomcat_version == '8': |
| if not os.path.exists(self.__tomcat8_path_bak + '/conf/server.xml'): return public.returnMsg( |
| False, "tomcat8的配置文件不存在，请重新安装tomcat8" |
| ) |
| public.ExecShell( |
| 'cp -r %s/* %s && chown -R www:www %s' % ( |
| self.__tomcat8_path_bak, self.__site_path + domain, self.__site_path + domain) |
| ) |
| if tomcat_version == 'tomcat9' or tomcat_version == '9': |
| if not os.path.exists(self.__tomcat9_path_bak + '/conf/server.xml'): return public.returnMsg( |
| False, "tomcat9的配置文件不存在，请重新安装tomcat9" |
| ) |
| public.ExecShell( |
| 'cp -r %s/* %s && chown -R www:www %s' % ( |
| self.__tomcat9_path_bak, self.__site_path + domain, self.__site_path + domain) |
| ) |
| |
| if os.path.exists(self.__site_path + domain + '/conf/server.xml'): |
| ret = '''<Server port="{}" shutdown="SHUTDOWN"> |
| <Listener className="org.apache.catalina.startup.VersionLoggerListener" /> |
| <Listener SSLEngine="on" className="org.apache.catalina.core.AprLifecycleListener" /> |
| <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" /> |
| <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" /> |
| <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" /> |
| <GlobalNamingResources> |
| <Resource auth="Container" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" name="UserDatabase" pathname="conf/tomcat-users.xml" type="org.apache.catalina.UserDatabase" /> |
| </GlobalNamingResources> |
| <Service name="Catalina"> |
| <Connector connectionTimeout="20000" port="8083" protocol="HTTP/1.1" redirectPort="8490" /> |
| <Engine defaultHost="localhost" name="Catalina"> |
| <Realm className="org.apache.catalina.realm.LockOutRealm"> |
| <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase" /> |
| </Realm> |
| <Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true"> |
| <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" pattern="%h %l %u %t "%r" %s %b" prefix="localhost_access_log" suffix=".txt" /> |
| </Host> |
| </Engine> |
| </Service> |
| </Server>'''.format(self.generate_random_port(), get.project_name.strip()) |
| log_path = "/www/wwwlogs/java/{}".format(get.project_name) |
| if not os.path.exists(log_path) or os.path.isfile(log_path): |
| os.makedirs(log_path, mode = 0o777) |
| public.WriteFile(self.__site_path + domain + '/conf/server.xml', ret) |
| else: |
| os.system('rm -rf %s' % self.__site_path + domain) |
| return public.returnMsg(False, "配置文件不存在请重新安装tomcat后尝试新建网站") |
| if not self.Initialization2(tomcat_version, domain): |
| return public.returnMsg(False, "配置文件错误或者服务未安装") |
| |
| ret = self.set_site_port(str(project_config['port']), tomcat_version, domain) |
| if not ret['status']: return ret |
| ret = self.add_vhost(path = project_info['path'], domain = domain) |
| if ret: |
| |
| pid_path = '/www/server/web_site/%s/logs/catalina-daemon.pid' % domain |
| if os.path.exists(pid_path): |
| os.remove(pid_path) |
| public.ExecShell('sh %s' % self.__site_path + domain + '/bin/daemon.sh start') |
| |
| public.WriteLog(self._log_name, '修复Java项目{}成功'.format(domain)) |
| return public.returnMsg(True, "修复成功") |
| if project_config['java_type'] == 'neizhi': |
| if not os.path.exists( |
| self.__bttomcat_path + "/tomcat{}/conf/server.xml".format(project_config['tomcat_version']) |
| ): return public.returnMsg(False, '修复失败当前Tomcat版本未安装') |
| if not self.Initialization(project_config['tomcat_version']): return public.returnMsg( |
| False, "tomcat%s配置文件错误或者服务未安装" % project_config['tomcat_version'] |
| ) |
| if self.add_vhost(path = project_info['path'], domain = project_info['name']): |
| res = self.stop_project(get) |
| res = self.start_project(get) |
| return public.returnMsg(True, '修复成功') |
| else: |
| if self.get_vhost(project_info['name']): |
| return public.returnMsg(True, '已经修复成功请不要重复提交') |
| return public.returnMsg(True, '修复失败') |
| else: |
| return public.returnMsg(False, '该项目不是Tomcat独立项目或者Tomcat内置项目') |
| |
| def get_project_info(self, get): |
| ''' |
| @name 获取指定项目信息 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| if not hasattr(get, 'project_name'): |
| return public.returnMsg(False, '请传递项目名称!') |
| project_info = public.M('sites').where('project_type=? AND name=?', ('Java', get.project_name)).find() |
| if not project_info: return public.returnMsg(False, '指定项目不存在!') |
| project_info = self.get_project_stat(project_info) |
| return project_info |
| |
| def get_ssl_end_date(self, project_name): |
| ''' |
| @name 获取SSL信息 |
| @author hwliang<2021-08-09> |
| @param project_name <string> 项目名称 |
| @return dict |
| ''' |
| import data |
| return data.data().get_site_ssl_info('java_{}'.format(project_name)) |
| |
| def get_project_stat(self, project_info): |
| ''' |
| @name 获取项目状态信息 |
| @author hwliang<2021-08-09> |
| @param project_info<dict> 项目信息 |
| @return list |
| ''' |
| project_info['project_config'] = json.loads(project_info['project_config']) |
| if "jdk_path" not in project_info['project_config']: |
| project_info['project_config']["jdk_path"] = "/usr/local/btjdk/jdk8" |
| project_info["use_project_watch"] = use_project_watch(project_info['name']) |
| if project_info['project_config']['java_type'] == 'springboot': |
| project_info['run'] = self.get_project_run_state(project_name = project_info['name']) |
| project_info['load_info'] = self.get_project_load_info(project_name = project_info['name']) |
| project_info['ssl'] = self.get_ssl_end_date(project_name = project_info['name']) |
| project_info['listen'] = [] |
| project_info['listen_ok'] = True |
| |
| project_info['debug'] = False |
| if '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=' in project_info['project_config'][ |
| 'project_cmd']: |
| project_info['debug'] = True |
| if project_info['load_info']: |
| for pid in project_info['load_info'].keys(): |
| if not 'connections' in project_info['load_info'][pid]: |
| project_info['load_info'][pid]['connections'] = [] |
| for conn in project_info['load_info'][pid]['connections']: |
| if not conn['status'] == 'LISTEN': continue |
| if not conn['local_port'] in project_info['listen']: |
| project_info['listen'].append(conn['local_port']) |
| if project_info['listen']: |
| project_info['listen_ok'] = project_info['project_config']['port'] in project_info['listen'] |
| return project_info |
| if project_info['project_config']['java_type'] == 'duli': |
| project_info['run'] = self.get_duli_run_state(project_name = project_info['name']) |
| project_info['load_info'] = self.get_duli_load_info(project_name = project_info['name']) |
| project_info['ssl'] = self.get_ssl_end_date(project_name = project_info['name']) |
| project_info['tomcat_info'] = self.pendent_tomcat_info(domain = project_info['name']) |
| project_info['listen'] = [] |
| project_info['listen_ok'] = True |
| if project_info['load_info']: |
| for pid in project_info['load_info'].keys(): |
| for conn in project_info['load_info'][pid]['connections']: |
| if not conn['status'] == 'LISTEN': continue |
| if not conn['local_port'] in project_info['listen']: |
| project_info['listen'].append(conn['local_port']) |
| if project_info['listen']: |
| project_info['listen_ok'] = project_info['project_config']['port'] in project_info['listen'] |
| return project_info |
| if project_info['project_config']['java_type'] == 'neizhi': |
| project_info['run'] = self.get_duli_run_state( |
| project_name = project_info['name'], |
| bt_tomcat_web = '/usr/local/bttomcat/tomcat{}'.format(project_info['project_config']['tomcat_version']), |
| neizhi = True |
| ) |
| project_info['load_info'] = self.get_duli_load_info( |
| project_name = project_info['name'], |
| bt_tomcat_web = '/usr/local/bttomcat/tomcat{}'.format(project_info['project_config']['tomcat_version']), |
| neizhi = True |
| ) |
| project_info['ssl'] = self.get_ssl_end_date(project_name = project_info['name']) |
| project_info['tomcat_info'] = self.get_tomcat_info( |
| version = project_info['project_config']['tomcat_version'] |
| ) |
| project_info['listen'] = [] |
| project_info['listen_ok'] = True |
| if project_info['load_info']: |
| for pid in project_info['load_info'].keys(): |
| for conn in project_info['load_info'][pid]['connections']: |
| if not conn['status'] == 'LISTEN': continue |
| if not conn['local_port'] in project_info['listen']: |
| project_info['listen'].append(conn['local_port']) |
| if project_info['listen']: |
| project_info['listen_ok'] = project_info['project_config']['port'] in project_info['listen'] |
| return project_info |
| |
| |
| def xsssec(self, text): |
| return text.replace('<', '<').replace('>', '>') |
| |
| def last_lines(self, filename, lines=1): |
| return public.GetNumLines(filename, lines) |
|
|
| def get_project_log_old(self, get): |
| ''' |
| @name 取项目日志 |
| @author lkq<2021-08-27> |
| @param domain 域名 |
| @param project_name 项目名称 |
| @return string |
| ''' |
| project_info = self.get_project_find(get.project_name.strip()) |
| if not project_info: return public.returnMsg(False, '项目不存在') |
| if project_info['project_config']['java_type'] == 'springboot': |
| |
| log_file = project_info['project_config']['logs'] |
| if not os.path.exists(log_file): return public.returnMsg(False, '日志文件不存在') |
| log_file_size = os.path.getsize(log_file) |
| return { |
| "status": True, |
| "path": log_file.rsplit("/", 1)[0], |
| "size": public.to_size(log_file_size), |
| "data": self.xsssec(public.GetNumLines(log_file, 3000)) if log_file_size < 3145928 else self.xsssec( |
| self.last_lines(log_file, 3000) |
| ) |
| } |
| if project_info['project_config']['java_type'] == 'duli': |
| log_file = '/www/server/bt_tomcat_web/{}/logs/catalina-daemon.out'.format(get.project_name.strip()) |
| log_file_size = os.path.getsize(log_file) |
| return { |
| "status": True, |
| "path": log_file.rsplit("/", 1)[0], |
| "size": public.to_size(log_file_size), |
| "data": self.xsssec(public.GetNumLines(log_file, 3000)) if log_file_size < 3145928 else self.xsssec( |
| self.last_lines(log_file, 3000) |
| ) |
| } |
| if project_info['project_config']['java_type'] == 'neizhi': |
| version = project_info['project_config']['tomcat_version'] |
| log_file = '/usr/local/bttomcat/tomcat%s/logs/catalina-daemon.out' % version |
| log_file_size = os.path.getsize(log_file) |
| return { |
| "status": True, |
| "path": log_file.rsplit("/", 1)[0], |
| "size": public.to_size(log_file_size), |
| "data": self.xsssec(public.GetNumLines(log_file, 3000)) if log_file_size < 3145928 else self.xsssec( |
| self.last_lines(log_file, 3000) |
| ) |
| } |
| |
| def get_project_log(self, get): |
| ''' |
| @name 取项目日志 |
| @author lkq<2021-08-27> |
| @param domain 域名 |
| @param project_name 项目名称 |
| @return string |
| ''' |
| |
| try: |
| from mod.project.java.utils import site_tomcat, bt_tomcat |
| except: |
| site_tomcat = bt_tomcat = None |
| |
| project_info = self.get_project_find(get.project_name.strip()) |
| if not project_info: return public.returnMsg(False, '项目不存在') |
| if project_info['project_config']['java_type'] == 'springboot': |
| log_file = project_info['project_config']['logs'] |
| |
| if not os.path.exists(log_file): |
| |
| log_file_size = 0 |
| else: |
| log_file_size = os.path.getsize(log_file) |
| _path = log_file.rsplit("/", 1)[0] |
| if log_file_size > 3145928: |
| return { |
| "status": True, |
| "path": _path, |
| "file": log_file, |
| "data": self.xsssec(self.last_lines(log_file, 3000)), |
| "size": public.to_size(log_file_size) |
| } |
| return { |
| "status": True, |
| "path": _path, |
| "file": log_file, |
| "data": self.xsssec(public.GetNumLines(log_file, 3000)), |
| "size": public.to_size(log_file_size) |
| } |
| if project_info['project_config']['java_type'] == 'duli': |
| if not "logs" in project_info['project_config']: return self.get_project_log_old(get) |
| log_file = log_path = None |
| if site_tomcat: |
| tomcat_name = project_info['project_config'].get("tomcat_name", "") |
| if tomcat_name: |
| tomcat = site_tomcat(tomcat_name) |
| else: |
| tomcat = site_tomcat(get.project_name.strip()) |
| if tomcat: |
| log_file = tomcat.log_file |
| log_path = os.path.dirname(log_file) + "/" |
| if log_file is None: |
| log_path = project_info['project_config']['logs'] |
| if log_path[-1] != "/": |
| log_path = log_path + "/" |
| log_file = '{}catalina-daemon-{}.out'.format(log_path, project_info["name"].replace(".", "_")) |
| if not os.path.isfile(log_file): |
| log_file_size = 0 |
| else: |
| log_file_size = os.path.getsize(log_file) |
| return { |
| "status": True, |
| "path": log_path[:-1], |
| "file": log_file, |
| "size": public.to_size(log_file_size), |
| "data": self.xsssec(public.GetNumLines(log_file, 3000)) if log_file_size < 3145928 else self.xsssec( |
| self.last_lines(log_file, 3000) |
| ) |
| } |
| if project_info['project_config']['java_type'] == 'neizhi': |
| version = project_info['project_config']['tomcat_version'] |
| res = public.ExecShell('sed -n "142p" /usr/local/bttomcat/tomcat{}/bin/daemon.sh'.format(version))[0] |
| if res.find('test ".$CATALINA_OUT" = . && CATALINA_OUT="$CATALINA_BASE/logs/catalina-daemon.out"') == 0: |
| return self.get_project_log_old(get) |
| log_file = None |
| if bt_tomcat: |
| tomcat = bt_tomcat(version) |
| if tomcat: |
| log_file = tomcat.log_file |
| if log_file is None: |
| try: |
| log_file = public.readFile( |
| "/usr/local/bttomcat/tomcat%s/conf/logpath.conf" % version |
| ) + f'/catalina-daemon-{version}.out' |
| except: |
| log_file = '/www/wwwlogs/java/neizhi%s/catalina-daemon.out' % version |
| |
| if not os.path.exists(log_file): |
| log_file_size = 0 |
| else: |
| log_file_size = os.path.getsize(log_file) |
| return { |
| "status": True, |
| "path": log_file.rsplit("/", 1)[0], |
| "file": log_file, |
| "size": public.to_size(log_file_size), |
| "data": self.xsssec(public.GetNumLines(log_file, 3000)) if log_file_size < 3145928 else self.xsssec( |
| self.last_lines(log_file, 3000) |
| ) |
| } |
| |
| def remove_project(self, get): |
| ''' |
| @name 删除指定项目 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name: string<项目名称> |
| } |
| @return dict |
| ''' |
| if not 'project_name' in get: return public.returnMsg(False, '请传递项目名称') |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return public.returnMsg(False, '指定项目不存在: {}'.format(get.project_name)) |
| if not project_find: return public.returnMsg(False, '项目不存在!') |
| if not project_find['project_config']: return public.returnMsg(False, '项目不存在!') |
| if not project_find['project_config']['java_type']: return public.returnMsg(False, '项目不存在!') |
| if project_find['project_config']['java_type'] == 'duli': |
| |
| get.domain = project_find['name'] |
| get.type = 'stop' |
| self.pendent_tomcat_start(get) |
| |
| self.clear_config(get.project_name) |
| public.M('domain').where('pid=?', (project_find['id'],)).delete() |
| public.M('sites').where('name=?', (get.project_name,)).delete() |
| public.ExecShell("rm -rf %s/%s" % (self.__site_path, project_find['name'])) |
| public.WriteLog(self._log_name, '删除Java项目{}'.format(get.project_name)) |
| for i in project_find['project_config']['domains']: |
| self.del_hosts(i) |
| self.del_crontab(get.project_name) |
| |
| return public.returnMsg(True, '删除项目成功') |
| elif project_find['project_config']['java_type'] == 'neizhi': |
| |
| self.tomcat_vhost_delete(project_find['project_config']['tomcat_version'], project_find['project_config']['domains'], get) |
| self.clear_config(get.project_name) |
| public.M('domain').where('pid=?', (project_find['id'],)).delete() |
| public.M('sites').where('name=?', (get.project_name,)).delete() |
| public.WriteLog(self._log_name, '删除Java项目{}'.format(get.project_name)) |
| |
| get.version = project_find['project_config']['tomcat_version'] |
| get.type = 'reload' |
| |
| |
| |
| |
| for i in project_find['project_config']['domains']: |
| self.del_hosts(i) |
| self.del_crontab(get.project_name) |
| |
| return public.returnMsg(True, '删除项目成功') |
| elif project_find['project_config']['java_type'] == 'springboot': |
| |
| self.stop_project(get) |
| |
| self.clear_config(get.project_name) |
| public.M('domain').where('pid=?', (project_find['id'],)).delete() |
| public.M('sites').where('name=?', (get.project_name,)).delete() |
| pid_file = project_find['project_config']['pids'] |
| if os.path.exists(pid_file): os.remove(pid_file) |
| script_file = project_find['project_config']['scripts'] |
| if os.path.exists(script_file): os.remove(script_file) |
| log_file = project_find['project_config']['logs'] |
| if os.path.exists(log_file): os.remove(log_file) |
| public.WriteLog(self._log_name, '删除Java项目{}'.format(get.project_name)) |
| for i in project_find['project_config']['domains']: |
| self.del_hosts(i) |
| self.del_crontab(get.project_name) |
| |
| return public.returnMsg(True, '删除项目成功') |
| else: |
| return public.returnMsg(False, '项目类型错误') |
| |
| def modify_project(self, get): |
| ''' |
| @name 修改指定项目 |
| @author hwliang<2021-08-09> |
| @param get<dict_obj>{ |
| project_name : string<项目名称> |
| } |
| @return dict |
| ''' |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return public.return_error('指定项目不存在2: {}'.format(get.project_name)) |
| |
| |
| if project_find['project_config']['java_type'] == 'springboot': |
| return self.modify_project_springboot(get, project_find = project_find) |
| if project_find['project_config']['java_type'] == 'duli': |
| return self.modify_project_duli(get, project_find = project_find) |
| if project_find['project_config']['java_type'] == 'neizhi': |
| return self.modify_project_neizhi(get, project_find = project_find) |
| return public.returnMsg(False, '项目类型错误') |
| |
| def modify_project_springboot(self, get, project_find): |
| ''' |
| @修改springboot 项目配置 |
| @param get.port 修改的端口号 |
| @param get.run_user 运行目录 |
| @param get.auth 开机自启动 |
| @param get.project_jdk 项目JDK |
| @param get.project_jar 项目jar |
| @param get.project_ps 项目描述 |
| @param get.project_move_name 项目名称 |
| ''' |
| if hasattr(get, 'project_move_name'): |
| if get.project_move_name.strip() != get.project_name.strip(): |
| project_name = get.project_move_name.strip() |
| else: |
| project_name = get.project_name.strip() |
| else: |
| project_name = get.project_name.strip() |
| project_find['project_config']['project_name'] = project_name |
| if hasattr(get, 'port'): |
| if hasattr(get, 'port'): |
| try: |
| int(get.port) |
| except: |
| return public.returnMsg(False, "端口参数错误") |
| if int(project_find['project_config']['port']) != int(get.port): |
| if self.check_port_is_used(get.get('port/port'), True): |
| return public.returnMsg( |
| False, '指定端口已被其它应用占用，请修改您的项目配置使用其它端口, 端口: {}'.format( |
| get.port |
| ) |
| ) |
| project_find['project_config']['port'] = int(get.port) |
| if hasattr(get, 'auth'): project_find['project_config']['auth'] = get.auth |
| if hasattr(get, 'run_user'): project_find['project_config']['run_user'] = get.run_user |
| if hasattr(get, 'project_jdk'): project_find['project_config']['project_jdk'] = get.project_jdk.strip() |
| if hasattr(get, 'project_jar'): project_find['project_config']['project_jar'] = get.project_jar.strip() |
| if hasattr(get, 'project_cmd'): |
| project_find['project_config']['project_cmd'] = get.project_cmd.strip() |
| else: |
| return public.returnMsg(False, '缺少project_cmd参数') |
| |
| if project_find['project_config']['project_cmd'].find(get.project_jar.strip()) == -1: |
| return public.returnMsg(False, '项目jar包名称不在项目启动命令中，请检查') |
| if hasattr(get, 'project_jar'): |
| project_path = os.path.dirname(get.project_jar.strip()) |
| project_find['project_config']['jar_path'] = project_path |
| if hasattr(get, 'jmx_status') and hasattr(get, "jmx_port"): |
| jmx_url = "service:jmx:rmi:///jndi/rmi://127.0.0.1:{}/jmxrmi".format(get.jmx_port) |
| project_find['project_config']['jmx_status'] = get.jmx_status |
| project_find['project_config']['jmx_info'] = { |
| "jmx_url": jmx_url, |
| "username": "", |
| "password": "", |
| } |
| pdata = { |
| 'name': project_name, |
| 'path': get.project_jar.strip(), |
| 'ps': get.project_ps.strip(), |
| 'project_config': json.dumps(project_find['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| self.set_config(get.project_name) |
| |
| |
| res = self.stop_project(get) |
| res = self.start_project(get) |
| if "use_project_watch" in get and get.use_project_watch in ("1", "true", "yes", 1): |
| add_project_watch( |
| p_name = get.project_name.strip(), |
| p_type = "java", |
| site_id = project_find["id"], |
| watch_path = get.project_jar.strip() |
| ) |
| else: |
| del_project_watch(get.project_name.strip()) |
| public.WriteLog(self._log_name, '修改Java项目{}'.format(get.project_name)) |
| return public.returnMsg(True, '修改项目成功') |
| |
| def modify_project_duli(self, get, project_find): |
| ''' |
| @修改独立项目配置 |
| @param get.project_name 项目名称 |
| @param get.project_path 项目路径 |
| @param get.port 修改的端口号 |
| @param get.project_ps 项目描述 |
| @param get.tomcat_start tomcat启动脚本路径 |
| @param get.jdk_path 更换JDK的路径 |
| ''' |
| |
| falg = False |
| if hasattr(get, 'port'): |
| if int(project_find['project_config']['port']) != int(get.port): |
| if self.check_port_is_used(get.get('port/port'), True): |
| return public.returnMsg( |
| False, '指定端口已被其它应用占用，请修改您的项目配置使用其它端口, 端口: {}'.format( |
| get.port |
| ) |
| ) |
| project_find['project_config']['port'] = int(get.port) |
| |
| ret = self.set_tomcat_duli_port(get, get_project_find = project_find) |
| falg = True |
| if not ret['status']: return ret |
| |
| |
| if hasattr(get, 'project_path'): |
| if (get.project_path.strip() == project_find['path']): |
| pass |
| else: |
| ret = self.set_tomcat_duli_path(get, get_project_find = project_find) |
| falg = True |
| if not ret['status']: return ret |
| |
| |
| if hasattr(get, 'jdk_path'): |
| ret = self.change_duli_tomcat_jdk(get.project_name, get.jdk_path) |
| if not ret['status']: |
| return ret |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| if hasattr(get, 'auth'): |
| if str(get.auth) != str(project_find['project_config']['auth']): |
| project_find['project_config']['auth'] = get.auth |
| falg = True |
| pdata = { |
| 'project_config': json.dumps(project_find['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| |
| |
| if hasattr(get, 'project_ps'): |
| if get.project_ps.strip() != project_find['ps']: |
| falg = True |
| pdata = {'ps': get.project_ps.strip()} |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| |
| if falg: |
| self.set_config(get.project_name) |
| |
| self.stop_project(get) |
| self.start_project(get) |
| return public.returnMsg(True, '修改完成') |
| |
| def modify_project_neizhi(self, get, project_find): |
| ''' |
| @name 修改内置项目配置 |
| @param get.project_name 项目名称 |
| @param get.port 修改的端口号 |
| @param get.project_ps 项目描述 |
| @param get.tomcat_start tomcat启动脚本路径 |
| @param get.jdk_path 更换JDK的路径 |
| ''' |
| flag = False |
| if hasattr(get, 'port'): |
| if int(project_find['project_config']['port']) != int(get.port): |
| if self.check_port_is_used(get.get('port/port'), True): |
| return public.returnMsg( |
| False, '指定端口已被其它应用占用，请修改您的项目配置使用其它端口, 端口: {}'.format( |
| get.port |
| ) |
| ) |
| project_find['project_config']['port'] = int(get.port) |
| |
| flag = True |
| ret = self.set_tomcat_duli_port(get, get_project_find = project_find) |
| if not ret['status']: return ret |
| |
| if hasattr(get, 'jdk_path'): |
| ret = self.pendent_tomcat_info(domain = get.project_name) |
| if ret['jdk_path']: |
| if ret['jdk_path'] != get.jdk_path.strip(): |
| |
| flag = True |
| if not os.path.exists(ret['jdk_path']): |
| return public.returnMsg(False, '当前JDK不可用') |
| |
| ret2 = self.replace_jdk_version(get) |
| if not ret2['status']: |
| |
| get.jdk_path = ret['jdk_path'] |
| self.replace_jdk_version(get) |
| return ret2 |
| |
| |
| if hasattr(get, 'project_path'): |
| if (get.project_path.strip() == project_find['path']): |
| pass |
| else: |
| ret = self.set_tomcat_duli_path(get, get_project_find = project_find) |
| flag = True |
| if not ret['status']: return ret |
| |
| |
| if hasattr(get, 'project_ps'): |
| if get.project_ps.strip() != project_find['ps']: |
| flag = True |
| pdata = {'ps': get.project_ps.strip()} |
| public.M('sites').where('name=?', (get.project_name,)).update(pdata) |
| if flag: |
| self.set_config(get.project_name) |
| self.restart_project(get) |
| return public.returnMsg(True, "修改成功") |
| |
| def auto_run(self): |
| ''' |
| @name 自动启动所有项目 |
| @author hwliang<2021-08-09> |
| @return bool |
| ''' |
| project_list = public.M('sites').where('project_type=?', ('Java',)).field('name,path,project_config').select() |
| get = public.dict_obj() |
| success_count = 0 |
| error_count = 0 |
| for project_find in project_list: |
| project_config = json.loads(project_find['project_config']) |
| if project_config['auth'] in [0, False, '0', None]: continue |
| project_name = project_find['name'] |
| |
| if project_config['java_type'] == 'springboot': |
| project_state = self.get_project_run_state(project_name = project_name) |
| elif project_config['java_type'] == 'duli': |
| project_state = self.get_duli_run_state(project_name = project_name) |
| else: |
| get.project_name = project_name |
| project_state = self.get_duli_run_state( |
| project_name = project_name, |
| bt_tomcat_web = '/usr/local/bttomcat/tomcat{}'.format( |
| project_config['tomcat_version'] |
| ), neizhi = True |
| ) |
| if not project_state: |
| get.project_name = project_name |
| result = self.start_project(get) |
| if not result['status']: |
| error_count += 1 |
| error_msg = '自动启动Java项目[' + project_name + ']失败!' |
| public.WriteLog(self._log_name, error_msg) |
| else: |
| success_count += 1 |
| success_msg = '自动启动Java项目[' + project_name + ']成功!' |
| public.WriteLog(self._log_name, success_msg) |
| if (success_count + error_count) < 1: return False |
| dene_msg = '共需要启动{}个Java项目，成功{}个，失败{}个'.format( |
| success_count + error_count, success_count, error_count |
| ) |
| public.WriteLog(self._log_name, dene_msg) |
| return True |
| |
| def get_jmap_path(self, project_find): |
| ''' |
| @name 获取jmap jhat jstack绝对路径 |
| @author lkq<2021-09-24> |
| @return list |
| ''' |
| |
| ret = {} |
| cmd = project_find['project_config']['project_cmd'] |
| if not cmd: |
| return False |
| |
| cmd = cmd.split() |
| path = None |
| for i in cmd: |
| if 'bin/java' in i: |
| path = i |
| break |
| if not path: |
| jdk_list = self.get_local_jdk_version(None) |
| if jdk_list: |
| path = '/'.join(jdk_list[0][1].split('/')[:-1]) |
| jmap_path = path + '/jmap' |
| if os.path.exists(jmap_path): |
| ret['jmap'] = jmap_path |
| if os.path.exists(path + '/jhat'): |
| ret['jhat'] = path + '/jhat' |
| if os.path.exists(path + '/jstack'): |
| ret['jstack'] = path + '/jstack' |
| return ret |
| else: |
| path = '/'.join(path.split('/')[:-1]) |
| jmap_path = path + '/jmap' |
| if os.path.exists(jmap_path): |
| ret['jmap'] = jmap_path |
| if os.path.exists(path + '/jhat'): |
| ret['jhat'] = path + '/jhat' |
| if os.path.exists(path + '/jstack'): |
| ret['jstack'] = path + '/jstack' |
| return ret |
| |
| def get_project_dump(self, get): |
| ''' |
| @name 获取heapdump 文件列表 |
| @author lkq<2021-09-24> |
| @return list |
| ''' |
| ret = [] |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return ret |
| if not project_find['project_config']['java_type'] == 'springboot': return ret |
| if not os.path.exists(self._springoot_dump + '/' + get.project_name + '.json'): return ret |
| try: |
| ret = json.loads(public.ReadFile(self._springoot_dump + '/' + get.project_name + '.json')) |
| return ret |
| except: |
| public.WriteFile(public.ReadFile(self._springoot_dump + '/' + get.project_name + '.json'), []) |
| return ret |
| |
| def del_project_dump(self, get): |
| ''' |
| @name 获取heapdump 文件列表 |
| @author lkq<2021-09-24> |
| @param get.project_name 项目名称 |
| @param get.dump_name 文件名称 |
| ''' |
| ret = [] |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return public.returnMsg(False, '项目不存在') |
| if not project_find['project_config']['java_type'] == 'springboot': return public.returnMsg( |
| False, '只支持SpringBoot项目' |
| ) |
| if not os.path.exists(self._springoot_dump + '/' + get.project_name + '.json'): return public.returnMsg( |
| False, '路径不存在于当前项目中' |
| ) |
| if not os.path.exists(get.dump_name.strip()): return public.returnMsg(False, '文件不存在') |
| try: |
| ret = json.loads(public.ReadFile(self._springoot_dump + '/' + get.project_name + '.json')) |
| if get.dump_name.strip() in ret: |
| ret.remove(get.dump_name.strip()) |
| public.ExecShell("rm -rf %s" % get.dump_name.strip()) |
| return public.returnMsg(True, '删除成功') |
| except: |
| public.WriteFile(public.ReadFile(self._springoot_dump + '/' + get.project_name + '.json'), []) |
| return public.returnMsg(True, '删除成功') |
| |
| def heapdump_project(self, get): |
| ''' |
| @name 生成headdump 文件 |
| @author lkq<2021-09-24> |
| @param type Finfo 代表强制获取每个类占用 info获取每个类占用 dump生成dump文件 Fdump 强制生成dump文件 heap 显示Java堆详细信息 Fheap 强制显示Java堆详细信息 |
| @return list |
| ''' |
| if not hasattr(get, 'type'): |
| get.type = 'info' |
| type = get.type |
| else: |
| type = get.type |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return public.returnMsg(False, '指定项目不存在2: {}'.format(get.project_name)) |
| if not project_find['project_config']['java_type'] == 'springboot': return public.returnMsg( |
| False, '只支持Springboot项目' |
| ) |
| |
| path = self.get_jmap_path(project_find) |
| |
| if not self.get_project_run_state(project_name = get.project_name): |
| return public.returnMsg(False, '指定项目未启动: {}'.format(get.project_name)) |
| |
| pidlist = self.get_project_load_info(project_name = get.project_name) |
| if not pidlist: |
| return public.returnMsg(False, '指定项目未启动: {}'.format(get.project_name)) |
| pid = 0 |
| for i in pidlist: |
| pid = i |
| break |
| if pid == 0: |
| return public.returnMsg(False, '指定项目未启动: {}'.format(get.project_name)) |
| if 'jmap' in path: |
| jmap_path = path['jmap'] |
| if type == 'Finfo': |
| |
| cmd = '{} -F -histo {} | head -n 100'.format(jmap_path, pid) |
| elif type == 'info': |
| |
| cmd = '{} -histo:live {} | head -n 100'.format(jmap_path, pid) |
| elif type == 'dump': |
| path = self._springoot_dump + '/' + str(int(time.time())) + '.dump' |
| |
| cmd = '{} -dump:live,format=b,file={} {}'.format(jmap_path, path, pid) |
| ret = public.ExecShell(cmd, user = project_find['project_config']['run_user']) |
| if os.path.exists(path): |
| if os.path.exists(self._springoot_dump + '/' + get.project_name + '.json'): |
| try: |
| ret = json.loads(public.ReadFile(self._springoot_dump + '/' + get.project_name + '.json')) |
| if path not in ret: |
| ret.append(path) |
| public.WriteFile( |
| self._springoot_dump + '/' + get.project_name + '.json', json.dumps(ret) |
| ) |
| except: |
| public.WriteFile( |
| self._springoot_dump + '/' + get.project_name + '.json', json.dumps([path]) |
| ) |
| else: |
| public.WriteFile(self._springoot_dump + '/' + get.project_name + '.json', json.dumps([path])) |
| return public.returnMsg(True, '生成dump文件成功内容如下:%s' % ret[0]) |
| else: |
| return public.returnMsg(False, '生成dump文件失败内容如下:%s' % ret[0]) |
| elif type == 'Fdump': |
| |
| cmd = '{} -F -dump:live,format=b,file={} {}'.format( |
| jmap_path, self._springoot_dump + '/' + time.strftime( |
| '%Y-%m-%d %X', time.localtime() |
| ) + '.dump', pid |
| ) |
| ret = public.ExecShell(cmd, user = project_find['project_config']['run_user']) |
| return public.returnMsg(True, ret) |
| elif type == 'heap': |
| |
| cmd = '{} -heap {} '.format(jmap_path, pid) |
| elif type == 'Fheap': |
| |
| cmd = '{} -F -heap {}'.format(jmap_path, pid) |
| else: |
| return public.returnMsg(False, '指定的类型不存在: {}'.format(type)) |
| ret = public.ExecShell(cmd, user = project_find['project_config']['run_user']) |
| return public.returnMsg(True, ret) |
| return public.returnMsg(False, '当前JDK不存在jmap') |
| |
| def jhat_project(self, get): |
| ''' |
| @name jhat 分析dump文件 |
| @param dump dump文件 |
| @return string |
| @ps :此功能消耗很大的内存和CPU。請注意使用 |
| ''' |
| pass |
| dump_path = get.dump |
| if not os.path.exists(dump_path): |
| return public.returnMsg(False, 'dump文件不存在: {}'.format(dump_path)) |
| cmd = 'jhat {}'.format(dump_path) |
| return cmd |
| |
| def jstack_project(self, get): |
| ''' |
| @name jstack 生成虚拟线程快照 |
| @param pid 进程id |
| @return string |
| ''' |
| project_find = self.get_project_find(get.project_name) |
| if not project_find: |
| return public.returnMsg(False, '指定项目不存在2: {}'.format(get.project_name)) |
| |
| if not project_find['project_config']['java_type'] == 'springboot': return public.returnMsg( |
| False, '只支持Springboot项目' |
| ) |
| path = self.get_jmap_path(project_find) |
| |
| if not self.get_project_run_state(project_name = get.project_name): |
| return public.returnMsg(False, '指定项目未启动: {}'.format(get.project_name)) |
| |
| pidlist = self.get_project_load_info(project_name = get.project_name) |
| if not pidlist: |
| return public.returnMsg(False, '指定项目未启动: {}'.format(get.project_name)) |
| pid = 0 |
| for i in pidlist: |
| pid = i |
| break |
| if pid == 0: |
| return public.returnMsg(False, '指定项目未启动: {}'.format(get.project_name)) |
| if 'jstack' in path: |
| jstack_path = path['jstack'] |
| cmd = '{} -l {}'.format(jstack_path, pid) |
| |
| ret = public.ExecShell(cmd, user = project_find['project_config']['run_user']) |
| return public.returnMsg(True, ret) |
| return public.returnMsg(False, '当前JDK不存在jstack') |
| |
| |
| |
| |
| |
| def multi_remove_project(self, get): |
| ''' |
| @name 批量删除项目 |
| @author baozi<2023-3-2> |
| @param get<dict_obj>{ |
| project_names: list[string] <项目名称>所组成的列表 |
| } |
| @return dict |
| ''' |
| project_names = get.project_names |
| if isinstance(project_names, list): |
| pjnames = [i.strip() for i in project_names] |
| else: |
| pjnames = [] |
| |
| projects = public.M('sites').where( |
| f'project_type=? AND name in ({",".join(["?"] * len(pjnames))})', |
| ('Java', *pjnames) |
| ).select() |
| if not projects: |
| return public.returnMsg(False, "未选中要删除的站点") |
| |
| _duli, _neizh, _springboot, _error_type = [], [], [], [] |
| for project in projects: |
| project['project_config'] = json.loads(project['project_config']) |
| if project['project_config']['java_type'] == 'duli': |
| _duli.append(project) |
| elif project['project_config']['java_type'] == 'neizhi': |
| _neizh.append(project) |
| elif project['project_config']['java_type'] == 'springboot': |
| _springboot.append(project) |
| else: |
| _error_type.append("项目:[{}], 项目类型错误\n".format(project["name"])) |
| if _error_type: |
| return public.return_error(data = _error_type) |
| |
| |
| if _duli: |
| self._multi_remove_duli(_duli) |
| if _neizh: |
| self._multi_remove_neizhi(_neizh) |
| if _springboot: |
| self._multi_remove_springboot(_springboot) |
| |
| |
| self._multi_clear_config(projects) |
| |
| project_ids = tuple([i["id"] for i in projects]) |
| public.M('domain').where('pid IN ({})'.format(",".join(["?"] * len(projects))), project_ids).delete() |
| public.M('sites').where( |
| f'project_type=? AND name in ({",".join(["?"] * len(pjnames))})', |
| ('Java', *pjnames) |
| ).delete() |
| public.WriteLog(self._log_name, f'批量删除Java项目:[{"; ".join([i["name"] for i in projects])}]') |
| |
| for project in projects: |
| self.del_crontab(project["name"]) |
| for i in project['project_config']['domains']: |
| self.del_hosts(i) |
| |
| return {"status": True, "msg": "删除成功", "project_names": pjnames} |
| |
| def _multi_clear_config(self, projects): |
| for project in projects: |
| self.clear_nginx_config(project) |
| self.clear_apache_config(project) |
| public.serviceReload() |
| |
| def _multi_remove_duli(self, projects): |
| get = public.dict_obj() |
| for project in projects: |
| |
| get.domain = project['name'] |
| get.type = 'stop' |
| self.pendent_tomcat_start(get) |
| |
| shutil.rmtree(self.__site_path, project['name']) |
| |
| def _multi_remove_tomcat_vhost(self, projects): |
| if not self.__ENGINE: return |
| domains = [project["name"] for project in projects if project["name"] != 'localhost'] |
| try: |
| Hosts = self.__ENGINE.getchildren() |
| except: |
| Hosts = list(self.__ENGINE) |
| for host in Hosts: |
| if host.tag != 'Host': continue |
| if host.attrib['name'] in domains: |
| self.__ENGINE.remove(host) |
| self.save_tomcat() |
| |
| def _multi_remove_neizhi(self, projects): |
| version_group = {} |
| res_msg = [] |
| |
| for project in projects: |
| if project['project_config']['tomcat_version'] in version_group: |
| version_group[project['project_config']['tomcat_version']].append(project) |
| else: |
| version_group[project['project_config']['tomcat_version']] = [project, ] |
| |
| for version, group_projects in version_group.items(): |
| if not self.Initialization(version): |
| res_msg.append( |
| "项目[{}]".format(",".join([i["name"] for i in group_projects])) + ":配置文件错误请检查配置文件" |
| ) |
| continue |
| self._multi_remove_tomcat_vhost(group_projects) |
| get = public.dict_obj() |
| get.version = version |
| get.type = 'reload' |
| self.start_tomcat(get) |
| |
| def _multi_remove_springboot(self, projects): |
| get = public.dict_obj() |
| for project in projects: |
| |
| get.project_name = project["name"] |
| self.stop_project(get) |
| |
| pid_file = project['project_config']['pids'] |
| if os.path.exists(pid_file): os.remove(pid_file) |
| script_file = project['project_config']['scripts'] |
| if os.path.exists(script_file): os.remove(script_file) |
| log_file = project['project_config']['logs'] |
| if os.path.exists(log_file): os.remove(log_file) |
| |
| def multi_set_project(self, get): |
| ''' |
| @name 批量设置项目 |
| @author baozi<2023-3-2> |
| @param get<dict_obj>{ |
| project_names: list[string] <项目名称>所组成的列表 |
| } |
| @return dict |
| ''' |
| project_names = get.project_names |
| set_type = get.operation |
| if set_type not in ["start", "stop"]: |
| return public.returnMsg(False, "操作信息错误") |
| if isinstance(project_names, list): |
| pjnames = [i.strip() for i in project_names] |
| else: |
| pjnames = [] |
| |
| projects = public.M('sites').where( |
| f'project_type=? AND name in ({",".join(["?"] * len(pjnames))})', |
| ('Java', *pjnames) |
| ).select() |
| if not projects: |
| return public.returnMsg(False, "未选中要启动的站点") |
| |
| neizhi_projects = {'7': False, '8': False, '9': False} |
| _check = self.get_tomcat_version(None) |
| if not _check["tomcat7"]["status"]: neizhi_projects.pop("7") |
| if not _check["tomcat8"]["status"]: neizhi_projects.pop("8") |
| if not _check["tomcat9"]["status"]: neizhi_projects.pop("9") |
| springboot_projects = [] |
| duli_projects = [] |
| error_list = [] |
| for project in projects: |
| project['project_config'] = json.loads(project['project_config']) |
| if project['project_config']['java_type'] == 'neizhi': |
| if project['project_config']['tomcat_version'] in neizhi_projects: |
| neizhi_projects[project['project_config']['tomcat_version']] = True |
| else: |
| error_list.append( |
| { |
| "project_name": project["name"], "msg": "启动失败,没有安装Tomcat{}".format( |
| project['project_config']['tomcat_version'] |
| ) |
| } |
| ) |
| pjnames.remove(project["name"]) |
| |
| if project['project_config']['java_type'] == 'duli': |
| duli_projects.append(project) |
| |
| if project['project_config']['java_type'] == 'springboot': |
| springboot_projects.append(project) |
| |
| for tomcat_version, flag in neizhi_projects.items(): |
| if flag: |
| _get = public.dict_obj() |
| _get.type = set_type |
| _get.version = tomcat_version |
| self.start_tomcat(_get) |
| |
| for i in springboot_projects: |
| if set_type == "start": |
| flag, msg = self.__start_springboot_project(i) |
| if not flag: |
| error_list.append({"project_name": i["name"], "msg": msg}) |
| pjnames.remove(i["name"]) |
| else: |
| self.__stop_springboot_project(i) |
| |
| for i in duli_projects: |
| _get = public.dict_obj() |
| _get.domain = i['name'] |
| _get.type = set_type |
| self.pendent_tomcat_start(_get) |
| |
| if error_list: |
| return {"status": True, "msg": "部分项目启动失败", "error_list": error_list, "project_names": pjnames} |
| return {"status": True, "msg": "启动成功" if set_type == "start" else "停止成功", "project_names": pjnames} |
| |
| |
| def __stop_springboot_project(self, project_info): |
| pid_file = project_info['project_config']['pids'] |
| if not os.path.exists(pid_file): return public.returnMsg(False, '项目未启动') |
| try: |
| pid = int(public.readFile(pid_file)) |
| except: |
| return False, '项目未启动' |
| pids = self.get_project_pids(pid = pid) |
| if not pids: return False, '项目未启动' |
| self.kill_pids(pids = pids) |
| if os.path.exists(pid_file): os.remove(pid_file) |
| self.stop_by_user(project_info["id"]) |
| return True, '停止成功' |
| |
| |
| def __start_springboot_project(self, project_find): |
| project_cmd = project_find["project_config"]['project_cmd'] |
| |
| log_file = project_find["project_config"]['logs'] |
| pid_file = project_find["project_config"]['pids'] |
| nohup_log = ' &>> {log_file}'.format(log_file = log_file) |
| if not int(project_find["project_config"].get('nohup_log', 1)): |
| nohup_log = '' |
| if 'jar_path' in project_find['project_config']: |
| jar_path = project_find['project_config']['jar_path'] |
| else: |
| jar_path = '{}'.format(self._springboot) |
| |
| start_cmd = '''#!/bin/bash |
| PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin |
| export PATH |
| cd {jar_path} |
| nohup {project_cmd}{nohup_log} & |
| echo $! > {pid_file} |
| '''.format( |
| jar_path = jar_path, |
| project_cmd = project_cmd, |
| pid_file = pid_file, |
| log_file = log_file, |
| nohup_log = nohup_log, |
| ) |
| script_file = project_find["project_config"]['scripts'] |
| |
| public.writeFile(script_file, start_cmd) |
| if os.path.exists(pid_file): os.remove(pid_file) |
| public.ExecShell("chmod -R 777 /var/tmp/springboot/") |
| |
| public.set_mode(script_file, 755) |
| public.ExecShell( |
| "chown {}:{} {}".format( |
| project_find['project_config']['run_user'], project_find['project_config']['run_user'], |
| project_find['path'] |
| ) |
| ) |
| |
| |
| |
| p = public.ExecShell( |
| "bash {}".format(script_file), user = project_find['project_config']['run_user'], env = os.environ.copy() |
| ) |
| time.sleep(1) |
| if not os.path.exists(pid_file): |
| return False, '启动失败,请尝试切换启动用户' |
| |
| |
| try: |
| pid = int(public.readFile(pid_file)) |
| except: |
| return False, '启动失败' |
| time.sleep(0.4) |
| pids = self.get_project_pids(pid = pid) |
| |
| |
| |
| self.start_by_user(project_find["id"]) |
| return True, None |
| |
| def multi_check_bind_extranet(self, get): |
| """检查是否可以绑定外网，并执行绑定操作 |
| @author baozi <202-03-2> |
| @param: |
| get ( dict ): project_names 要操作的网站列表 |
| @return |
| """ |
| if not public.is_apache_nginx(): return public.returnMsg(False, '请先安装Apache或者Nginx!') |
| project_names = get.project_names |
| if isinstance(project_names, list): |
| pjnames = [i.strip() for i in project_names] |
| else: |
| pjnames = [] |
| |
| projects = public.M('sites').where( |
| f'project_type=? AND name in ({",".join(["?"] * len(pjnames))})', ('Java', *pjnames) |
| ).select() |
| if not projects: |
| return public.returnMsg(False, "未选中要启动的站点") |
| |
| error_list = [] |
| flag = False |
| for project in projects: |
| project['project_config'] = json.loads(project['project_config']) |
| if not project['project_config']['domains']: |
| error_list.append({'project_name': project["name"], "msg": '请先到【域名管理】选项中至少添加一个域名'}) |
| pjnames.remove(project["name"]) |
| continue |
| if "bind_extranet" in project['project_config'] and project['project_config']['bind_extranet'] == 1: |
| continue |
| else: |
| flag = True |
| project['project_config']['bind_extranet'] = 1 |
| public.M('sites').where("id=?", (project['id'],)).setField( |
| 'project_config', json.dumps(project['project_config']) |
| ) |
| self.set_nginx_config(project) |
| self.set_apache_config(project) |
| public.WriteLog(self._log_name, 'Java项目{}, 开启外网映射'.format(project)) |
| |
| if flag: |
| public.serviceReload() |
| |
| if error_list: |
| return { |
| "status": True, "msg": "部分网站开启外网映射失败", "error_list": error_list, "project_names": pjnames |
| } |
| |
| return {"status": True, "msg": "开启外网映射成功", "project_names": pjnames} |
| |
| def _change_daemom_sh(self, target_sh, logpath, suffix=''): |
| if not os.path.exists(target_sh): return False |
| file = public.readFile(target_sh) |
| rep = r'''\n ?test ?"\.\$CATALINA_OUT" ?= ?\. && {0,3}CATALINA_OUT="[^\n]*"[^\n]*\n''' |
| repl = f'\ntest ".$CATALINA_OUT" = . && CATALINA_OUT="{logpath}/catalina-daemon{"-" + suffix if suffix else ""}.out"\n' |
| file = re.sub(rep, repl, file) |
| public.writeFile(target_sh, file) |
| return True |
| |
| def change_log_path(self, get): |
| """"修改日志文件地址 |
| @author baozi <202-03-13> |
| @param: |
| get ( dict ): 请求: 包含项目名称和新的路径 |
| @return |
| """ |
| project_info = self.get_project_find(get.project_name.strip()) |
| if not project_info: return public.returnMsg(False, '项目不存在') |
| new_log_path = get.path.strip() if "path" in get else None |
| if not new_log_path or new_log_path[0] != "/": |
| return public.returnMsg(False, "路径设置错误") |
| if new_log_path[-1] == "/": new_log_path = new_log_path[:-1] |
| if not os.path.exists(new_log_path): |
| os.makedirs(new_log_path, mode = 0o777) |
| if project_info['project_config']['java_type'] == 'springboot': |
| project_info['project_config']['logs'] = new_log_path + '/' + project_info["name"] + '.log' |
| pdata = { |
| 'name': project_info["name"], |
| 'project_config': json.dumps(project_info['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name.strip(),)).update(pdata) |
| |
| |
| res = self.stop_project(get) |
| res = self.start_project(get) |
| public.WriteLog(self._log_name, '修改Java项目{}'.format(get.project_name)) |
| return public.returnMsg(True, "项目日志路径修改成功") |
| if project_info['project_config']['java_type'] == 'duli': |
| project_info['project_config']['logs'] = new_log_path + '/' |
| if not self._change_daemom_sh( |
| self.__site_path + project_info["name"] + "/bin/daemon.sh", new_log_path, |
| project_info["name"].replace(".", "_") |
| ): |
| return public.returnMsg(False, "项目日志路径修改失败") |
| pdata = { |
| 'name': project_info["name"], |
| 'project_config': json.dumps(project_info['project_config']) |
| } |
| public.M('sites').where('name=?', (get.project_name.strip(),)).update(pdata) |
| |
| |
| res = self.stop_project(get) |
| res = self.start_project(get) |
| public.WriteLog(self._log_name, '修改Java项目{}'.format(get.project_name)) |
| return public.returnMsg(True, "项目日志路径修改成功") |
| |
| if project_info['project_config']['java_type'] == 'neizhi': |
| version = project_info['project_config']['tomcat_version'] |
| if not self._change_daemom_sh( |
| "/usr/local/bttomcat/tomcat%s/bin/daemon.sh" % version, new_log_path, str(version) |
| ): |
| return public.returnMsg(False, "项目日志路径修改失败") |
| public.writeFile("/usr/local/bttomcat/tomcat%s/conf/logpath.conf" % version, new_log_path) |
| res = self.stop_project(get) |
| res = self.start_project(get) |
| public.WriteLog(self._log_name, '修改Java-Tomcat{}内置项目路径修改成功'.format(version)) |
| return public.returnMsg(True, "项目日志路径修改成功") |
| |
| def for_split(self, logsplit, project): |
| """日志切割方法调用 |
| @author baozi <202-03-20> |
| @param: |
| logsplit ( LogSplit ): 日志切割方法，传入 pjanme:项目名称 sfile:日志文件路径 log_prefix:产生的日志文件前缀 |
| project ( dict ): 项目内容 |
| @return |
| """ |
| try: |
| from mod.project.java.utils import site_tomcat, bt_tomcat |
| except: |
| site_tomcat = bt_tomcat = None |
| log_file = None |
| if project['project_config']['java_type'] == 'springboot': |
| log_file = project['project_config']['logs'] |
| logsplit(project["name"], log_file, project["name"]) |
| return |
| elif project['project_config']['java_type'] == 'duli': |
| if site_tomcat: |
| tomcat_name = project["project_config"].get("tomcat_name", "") |
| tomcat = site_tomcat(tomcat_name) if tomcat_name else site_tomcat(project["project_config"]["project_name"]) |
| if tomcat: |
| log_file = tomcat.log_file |
| if log_file is None: |
| _log_file = project['project_config']['logs'] |
| log_file = '{}catalina-daemon-{}.out'.format(_log_file, project["name"].replace(".", "_")) |
| if project['project_config']['java_type'] == 'neizhi': |
| version = str(project['project_config']['tomcat_version']).split(".")[0] |
| if bt_tomcat: |
| tomcat = bt_tomcat(version) |
| if tomcat: |
| log_file = tomcat.log_file |
| if log_file is None: |
| try: |
| log_file = public.readFile( |
| "/usr/local/bttomcat/tomcat%s/conf/logpath.conf" % version |
| ) + f'/catalina-daemon-{version}.out' |
| except: |
| log_file = '/www/wwwlogs/java/neizhi%s/catalina-daemon.out' % version |
| |
| logsplit(project["name"], log_file, project["name"]) |
| |
| |
| |
| |
| def del_crontab(self, name): |
| """ |
| @name 删除项目日志切割任务 |
| @auther hezhihong<2022-10-31> |
| @return |
| """ |
| cron_name = f'[勿删]Java项目[{name}]运行日志切割' |
| cron_path = public.GetConfigValue('setup_path') + '/cron/' |
| cron_list = public.M('crontab').where("name=?", (cron_name,)).select() |
| if cron_list: |
| for i in cron_list: |
| if not i: continue |
| cron_echo = public.M('crontab').where("id=?", (i['id'],)).getField('echo') |
| args = {"id": i['id']} |
| import crontab |
| crontab.crontab().DelCrontab(args) |
| del_cron_file = cron_path + cron_echo |
| public.ExecShell("crontab -u root -l| grep -v '{}'|crontab -u root -".format(del_cron_file)) |
| |
| def add_crontab(self, name, log_conf, python_path): |
| """ |
| @name 构造站点运行日志切割任务 |
| """ |
| cron_name = f'[勿删]Java项目[{name}]运行日志切割' |
| if not public.M('crontab').where('name=?', (cron_name,)).count(): |
| cmd = '{pyenv} {script_path} {name}'.format( |
| pyenv = python_path, |
| script_path = self.__log_split_script_py, |
| name = name |
| ) |
| args = { |
| "name": cron_name, |
| "type": 'day' if log_conf["log_size"] == 0 else "minute-n", |
| "where1": "" if log_conf["log_size"] == 0 else log_conf["minute"], |
| "hour": log_conf["hour"], |
| "minute": log_conf["minute"], |
| "sName": name, |
| "sType": 'toShell', |
| "notice": '0', |
| "notice_channel": '', |
| "save": str(log_conf["num"]), |
| "save_local": '1', |
| "backupTo": '', |
| "sBody": cmd, |
| "urladdress": '' |
| } |
| import crontab |
| res = crontab.crontab().AddCrontab(args) |
| if res and "id" in res.keys(): |
| return True, "新建任务成功" |
| return False, res["msg"] |
| return True |
| |
| def change_cronta(self, name, log_conf): |
| """ |
| @name 更改站点运行日志切割任务 |
| """ |
| python_path = "/www/server/panel/pyenv/bin/python3" |
| if not python_path: return False |
| cronInfo = public.M('crontab').where('name=?', (f'[勿删]Java项目[{name}]运行日志切割',)).find() |
| if not cronInfo: |
| return self.add_crontab(name, log_conf, python_path) |
| import crontab |
| recrontabMode = crontab.crontab() |
| id = cronInfo['id'] |
| del (cronInfo['id']) |
| del (cronInfo['addtime']) |
| cronInfo['sBody'] = '{pyenv} {script_path} {name}'.format( |
| pyenv = python_path, |
| script_path = self.__log_split_script_py, |
| name = name |
| ) |
| cronInfo['where_hour'] = log_conf['hour'] |
| cronInfo['where_minute'] = log_conf['minute'] |
| cronInfo['save'] = log_conf['num'] |
| cronInfo['type'] = 'day' if log_conf["log_size"] == 0 else "minute-n" |
| cronInfo['where1'] = '' if log_conf["log_size"] == 0 else log_conf['minute'] |
| |
| columns = 'where_hour,where_minute,sBody,save,type,where1' |
| values = ( |
| cronInfo['where_hour'], cronInfo['where_minute'], cronInfo['sBody'], cronInfo['save'], cronInfo['type'], |
| cronInfo['where1']) |
| recrontabMode.remove_for_crond(cronInfo['echo']) |
| if cronInfo['status'] == 0: return False, '当前任务处于停止状态,请开启任务后再修改!' |
| sync_res = recrontabMode.sync_to_crond(cronInfo) |
| if not sync_res['status']: |
| return False, sync_res['msg'] |
| public.M('crontab').where('id=?', (id,)).save(columns, values) |
| public.WriteLog('计划任务', '修改计划任务[' + cronInfo['name'] + ']成功') |
| return True, '修改成功' |
| |
| def mamger_log_split(self, get): |
| """管理日志切割任务 |
| @author baozi <202-02-27> |
| @param: |
| get ( dict ): 包含name, mode, hour, minute |
| @return |
| """ |
| name = get.name.strip() |
| project = self.get_project_find(name) |
| if not project: |
| return public.returnMsg(False, "没有该项目，请尝试刷新页面") |
| try: |
| _compress = False |
| _log_size = float(get.log_size) if float(get.log_size) >= 0 else 0 |
| _hour = get.hour.strip() if 0 <= int(get.hour) < 24 else "2" |
| _minute = get.minute.strip() if 0 <= int(get.minute) < 60 else '0' |
| _num = int(get.num) if 0 < int(get.num) <= 1800 else 180 |
| if "compress" in get: |
| _compress = int(get.compress) == 1 |
| except (ValueError, AttributeError, KeyError): |
| _log_size = 0 |
| _hour = "2" |
| _minute = "0" |
| _num = 180 |
| _compress = False |
| |
| if _log_size != 0: |
| _log_size = _log_size * 1024 * 1024 |
| _hour = 0 |
| _minute = 5 |
| |
| log_conf = { |
| "log_size": _log_size, |
| "hour": _hour, |
| "minute": _minute, |
| "num": _num, |
| "compress": _compress |
| } |
| flag, msg = self.change_cronta(name, log_conf) |
| if flag: |
| conf_path = '{}/data/run_log_split.conf'.format(public.get_panel_path()) |
| if os.path.exists(conf_path): |
| try: |
| data = json.loads(public.readFile(conf_path)) |
| except: |
| data = {} |
| else: |
| data = {} |
| data[name] = { |
| "stype": "size" if bool(_log_size) else "day", |
| "log_size": _log_size, |
| "limit": _num, |
| "compress": _compress |
| } |
| public.writeFile(conf_path, json.dumps(data)) |
| project["project_config"]["log_conf"] = log_conf |
| pdata = { |
| "project_config": json.dumps(project["project_config"]) |
| } |
| public.M('sites').where('name=?', (name,)).update(pdata) |
| return public.returnMsg(flag, msg) |
| |
| def set_log_split(self, get): |
| """设置日志计划任务状态 |
| @author baozi <202-02-27> |
| @param: |
| get ( dict ): 包含项目名称name |
| @return msg : 操作结果 |
| """ |
| name = get.name.strip() |
| project_conf = self.get_project_find(name) |
| if not project_conf: |
| return public.returnMsg(False, "没有该项目，请尝试刷新页面") |
| cronInfo = public.M('crontab').where('name=?', (f'[勿删]Java项目[{name}]运行日志切割',)).find() |
| if not cronInfo: |
| return public.returnMsg(False, "该项目没有设置运行日志的切割任务") |
| |
| status_msg = ['停用', '启用'] |
| status = 1 |
| import crontab |
| recrontabMode = crontab.crontab() |
| |
| if cronInfo['status'] == status: |
| status = 0 |
| recrontabMode.remove_for_crond(cronInfo['echo']) |
| else: |
| cronInfo['status'] = 1 |
| sync_res = recrontabMode.sync_to_crond(cronInfo) |
| if not sync_res['status']: |
| return public.returnMsg(False, sync_res['msg']) |
| |
| public.M('crontab').where('id=?', (cronInfo["id"],)).setField('status', status) |
| public.WriteLog('计划任务', '修改计划任务[' + cronInfo['name'] + ']状态为[' + status_msg[status] + ']') |
| return public.returnMsg(True, '设置成功') |
| |
| def get_log_split(self, get): |
| """获取站点的日志切割任务 |
| @author baozi <202-02-27> |
| @param: |
| get ( dict ): name |
| @return msg : 操作结果 |
| """ |
| |
| name = get.name.strip() |
| project_conf = self.get_project_find(name) |
| if not project_conf: |
| return public.returnMsg(False, "没有该项目，请尝试刷新页面") |
| if self._check_old(project_conf): |
| return { |
| "status": False, |
| "msg": "更新版本后需要重启项目，才能开启运行日志切割任务，建议您找一个合适的时间重启项目", |
| "is_old": True |
| } |
| cronInfo = public.M('crontab').where('name=?', (f'[勿删]Java项目[{name}]运行日志切割',)).find() |
| if not cronInfo: |
| return public.returnMsg(False, "该项目没有设置运行日志的切割任务") |
| |
| if "log_conf" not in project_conf["project_config"]: |
| return public.returnMsg(False, "日志切割配置丢失，请尝试重新设置") |
| res = project_conf["project_config"]["log_conf"] |
| res["status"] = cronInfo["status"] |
| return {"status": True, "data": res} |
| |
| def _update_project(self, project_name, project_info): |
| |
| |
| |
| |
| |
| if project_info['project_config']['java_type'] == 'springboot': |
| target_file = "{}/{}.log".format(self._springboot_logs_path, str(project_name)) |
| log_file = project_info['project_config']['logs'] |
| if not log_file.startswith(self._springboot_logs): |
| return |
| if os.path.exists(log_file): |
| self._move_logs(log_file, target_file) |
| if not os.path.exists(target_file): |
| return |
| else: |
| os.remove(log_file) |
| |
| project_info['project_config']["logs"] = target_file |
| pdata = { |
| 'name': project_name, |
| 'project_config': json.dumps(project_info['project_config']) |
| } |
| public.M('sites').where('name=?', (project_name,)).update(pdata) |
| |
| if project_info['project_config']['java_type'] == 'duli': |
| if "logs" in project_info['project_config']: |
| return |
| _path = '/www/wwwlogs/java/{}/'.format(project_name) |
| if not os.path.exists(_path): |
| os.makedirs(_path) |
| target_file = '{}catalina-daemon-{}.out'.format(_path, project_info["name"].replace(".", "_")) |
| s_file = '/www/server/bt_tomcat_web/{}/logs/catalina-daemon.out'.format(project_name) |
| if os.path.exists(s_file): |
| self._move_logs(s_file, target_file) |
| if not os.path.exists(target_file): |
| return |
| else: |
| os.remove(s_file) |
| if not self._change_daemom_sh( |
| self.__site_path + project_info["name"] + "/bin/daemon.sh", _path[:-1], |
| project_info["name"].replace(".", "_") |
| ): |
| return |
| project_info['project_config']["logs"] = _path |
| pdata = { |
| 'name': project_name, |
| 'project_config': json.dumps(project_info['project_config']) |
| } |
| public.M('sites').where('name=?', (project_name,)).update(pdata) |
| |
| if project_info['project_config']['java_type'] == 'neizhi': |
| version = project_info['project_config']['tomcat_version'] |
| target_file = '/www/wwwlogs/java/neizhi{}/catalina-daemon-{}.out'.format(version, version) |
| _path = '/www/wwwlogs/java/neizhi{}'.format(version) |
| if not os.path.exists(_path): |
| os.makedirs(_path) |
| s_file = '/usr/local/bttomcat/tomcat%s/logs/catalina-daemon.out' % version |
| res = public.ExecShell('sed -n "142p" /usr/local/bttomcat/tomcat{}/bin/daemon.sh'.format(version))[0] |
| if not res.startswith( |
| 'test ".$CATALINA_OUT" = . && CATALINA_OUT="$CATALINA_BASE/logs/catalina-daemon.out"' |
| ): |
| return |
| if os.path.exists(s_file): |
| self._move_logs(s_file, target_file) |
| if not os.path.exists(target_file): |
| return |
| else: |
| os.remove(s_file) |
| if not self._change_daemom_sh("/usr/local/bttomcat/tomcat%s/bin/daemon.sh" % version, _path, str(version)): |
| return |
| |
| public.writeFile("/usr/local/bttomcat/tomcat%s/conf/logpath.conf" % version, _path) |
| |
| def _move_logs(self, s_file, target_file): |
| if os.path.getsize(s_file) > 3145928: |
| res = self.last_lines(s_file, 3000) |
| public.WriteFile(target_file, res) |
| else: |
| shutil.copyfile(s_file, target_file) |
| |
| def _check_old(self, project_info): |
| if project_info['project_config']['java_type'] == 'springboot': |
| log_file = project_info['project_config']['logs'] |
| if log_file.startswith(self._springboot_logs): |
| return True |
| |
| if project_info['project_config']['java_type'] == 'duli': |
| if not "logs" in project_info['project_config']: |
| return True |
| |
| if project_info['project_config']['java_type'] == 'neizhi': |
| version = project_info['project_config']['tomcat_version'] |
| _path = '/www/wwwlogs/java/neizhi{}'.format(version) |
| if not os.path.exists(_path): |
| os.makedirs(_path) |
| res = public.ExecShell('sed -n "142p" /usr/local/bttomcat/tomcat{}/bin/daemon.sh'.format(version))[0] |
| if res.startswith('test ".$CATALINA_OUT" = . && CATALINA_OUT="$CATALINA_BASE/logs/catalina-daemon.out"'): |
| return True |
| |
| def _ckeck_add_domain(self, site_name, domains): |
| from panelSite import panelSite |
| ssl_data = panelSite().GetSSL(type("get", tuple(), {"siteName": site_name})()) |
| if not ssl_data["status"] or not ssl_data.get("cert_data", {}).get("dns", None): |
| return {"domains": domains} |
| domain_rep = [] |
| for i in ssl_data["cert_data"]["dns"]: |
| if i.startswith("*"): |
| _rep = "^[^\.]+\." + i[2:].replace(".", "\.") |
| else: |
| _rep = "^" + i.replace(".", "\.") |
| domain_rep.append(_rep) |
| no_ssl = [] |
| for domain in domains: |
| if not domain["status"]: continue |
| for _rep in domain_rep: |
| if re.search(_rep, domain["name"]): |
| break |
| else: |
| no_ssl.append(domain["name"]) |
| if no_ssl: |
| return { |
| "domains": domains, |
| "not_ssl": no_ssl, |
| "tip": "本站点已启用SSL证书,但本次添加的域名：{}，无法匹配当前证书，如有需求，请重新申请证书。".format( |
| str(no_ssl) |
| ) |
| } |
| return {"domains": domains} |
| |
| |
| def get_jmx_config(self, get): |
| if not hasattr(get, "site_id"): |
| return public.returnMsg(False, "缺少参数! site_id") |
| if not str(get.site_id).isdigit(): |
| return public.returnMsg(False, "参数错误! site_id") |
| project_config = public.M('sites').where('project_type=? AND id=?', ('Java', get.site_id)).getField( |
| "project_config" |
| ) |
| if not project_config: |
| return public.returnMsg(False, "网站信息不存在!") |
| |
| |
| try: |
| from jmxquery import JMXConnection, JMXQuery |
| except: |
| public.ExecShell("btpip install jmxquery==0.6.0") |
| |
| try: |
| project_config = json.loads(project_config) |
| except: |
| project_config = {} |
| |
| jmx_info = project_config.get("jmx_info", {}) |
| if jmx_info.get("jmx_url") is None: |
| jmx_info["jmx_url"] = "" |
| if jmx_info.get("username") is None: |
| jmx_info["username"] = "" |
| if jmx_info.get("password") is None: |
| jmx_info["password"] = "" |
| return {"status": True, "msg": "ok", "data": jmx_info} |
| |
| |
| def set_jmx_config(self, get): |
| if not hasattr(get, "site_id"): |
| return public.returnMsg(False, "缺少参数! site_id") |
| if not str(get.site_id).isdigit(): |
| return public.returnMsg(False, "参数错误! site_id") |
| jmx_url = getattr(get, "jmx_url") |
| username = getattr(get, "username", "") |
| password = getattr(get, "password", "") |
| |
| project_config = public.M('sites').where('project_type=? AND id=?', ('Java', get.site_id)).getField( |
| "project_config" |
| ) |
| if not project_config: |
| return public.returnMsg(False, "网站信息不存在!") |
| |
| |
| try: |
| from jmxquery import JMXConnection, JMXQuery |
| except: |
| public.ExecShell("btpip install jmxquery==0.6.0") |
| from jmxquery import JMXConnection |
| try: |
| |
| JMXConnection(connection_uri = jmx_url, jmx_username = username, jmx_password = password) |
| except Exception: |
| return public.returnMsg(False, "连接失败！") |
| |
| try: |
| project_config = json.loads(project_config) |
| except: |
| project_config = {} |
| |
| jmx_info = {} |
| |
| if jmx_url: |
| jmx_info["jmx_url"] = jmx_url |
| if username: |
| jmx_info["username"] = username |
| if password: |
| jmx_info["password"] = password |
| |
| project_config["jmx_info"] = jmx_info |
| public.M('sites').where('project_type=? AND id=?', ('Java', get.site_id,)).update( |
| {"project_config": json.dumps(project_config)} |
| ) |
| return public.returnMsg(True, "设置成功!") |
| |
| |
| def get_status_info(self, get): |
| if not hasattr(get, "site_id"): |
| return public.returnMsg(False, "缺少参数! site_id") |
| |
| project_config = public.M('sites').where('project_type=? AND id=?', ('Java', get.site_id)).getField( |
| "project_config" |
| ) |
| if not project_config: |
| return public.returnMsg(False, "网站信息不存在!") |
| |
| project_config = json.loads(project_config) |
| |
| if not project_config.get("jmx_status", False): |
| return public.returnMsg(False, "您未启用 jmx 监控") |
| |
| jmx_info = project_config.get("jmx_info") |
| if jmx_info is None: |
| return public.returnMsg(False, "请先设置 jmx 监控") |
| |
| java_path = project_config.get("project_jdk", '') |
| jmx_url = jmx_info.get("jmx_url") |
| username = jmx_info.get("username", "") |
| password = jmx_info.get("password", "") |
| if not jmx_url: |
| return public.returnMsg(False, "未设置 jmx 监控") |
| |
| |
| try: |
| from jmxquery import JMXConnection, JMXQuery |
| except: |
| public.ExecShell("btpip install jmxquery==0.6.0") |
| from jmxquery import JMXConnection, JMXQuery |
| import types |
| try: |
| |
| def my_load_from_json(the, jsonOutput: str): |
| if "\n" in jsonOutput: |
| jsonOutput = jsonOutput.replace("\n", "") |
| if "\t" in jsonOutput: |
| jsonOutput = jsonOutput.replace("\t", "") |
| jsonMetrics = json.loads(jsonOutput) |
| metrics = [] |
| for jsonMetric in jsonMetrics: |
| mBeanName = jsonMetric['mBeanName'] |
| attribute = jsonMetric['attribute'] |
| attributeType = jsonMetric['attributeType'] |
| metric_name = None |
| if 'metricName' in jsonMetric: |
| metric_name = jsonMetric['metricName'] |
| metric_labels = None |
| if 'metricLabels' in jsonMetric: |
| metric_labels = jsonMetric['metricLabels'] |
| attributeKey = None |
| if 'attributeKey' in jsonMetric: |
| attributeKey = jsonMetric['attributeKey'] |
| value = None |
| if 'value' in jsonMetric: |
| value = jsonMetric['value'] |
| |
| metrics.append( |
| JMXQuery(mBeanName, attribute, attributeKey, value, attributeType, metric_name, metric_labels) |
| ) |
| return metrics |
| |
| |
| |
| |
| |
| |
| jmxConnection = JMXConnection( |
| connection_uri = jmx_url, jmx_username = username, jmx_password = password, |
| java_path = java_path |
| ) |
| setattr(jmxConnection, "_JMXConnection__load_from_json", types.MethodType(my_load_from_json, jmxConnection)) |
| jmxQuery = [JMXQuery("*:*")] |
| |
| metrics = jmxConnection.query(jmxQuery) |
| except Exception: |
| return public.returnMsg(False, "连接失败！ {}".format(jmx_url)) |
| |
| |
| jmx_status_info = {} |
| |
| type_list = ["MemoryPool", "GarbageCollector"] |
| percent_list = ["SystemCpuLoad", "ProcessCpuLoad"] |
| |
| microsecond_list = ["StartTime", "Uptime", "endTime", "startTime", "CollectionTime", "CurrentThreadCpuTime", |
| "CurrentThreadUserTime", "endTime", "startTime", "CollectionTime", |
| "TotalCompilationTime", ] |
| nanoseconds_list = ["ProcessCpuTime", ] |
| size_list = ["FreePhysicalMemorySize", "TotalPhysicalMemorySize", "committed", "init", "max", "used"] |
| value_dict = { |
| "True": "是", |
| "False": "否", |
| "None": "无", |
| } |
| |
| |
| for metric in metrics: |
| java_type_obj = re.search("type=([\w\s]+)", metric.mBeanName) |
| if not java_type_obj: |
| continue |
| java_type = java_type_obj.group(1) |
| |
| name_obj = re.search("name=([\w\s]+)", metric.mBeanName) |
| name = None |
| if name_obj: |
| name = name_obj.group(1) |
| |
| if jmx_status_info.get(java_type) is None: |
| if java_type in type_list: |
| jmx_status_info[java_type] = [] |
| else: |
| jmx_status_info[java_type] = {} |
| type_info = jmx_status_info[java_type] |
| |
| if name is not None: |
| name = name.replace(" ", "_") |
| if isinstance(type_info, list): |
| for info in type_info: |
| if info["name"] == name: |
| type_info = info |
| break |
| else: |
| info = {"name": name} |
| type_info.append(info) |
| type_info = info |
| else: |
| if type_info.get(name) is None: |
| type_info[name] = {} |
| type_info = type_info[name] |
| |
| value = value_dict.get(str(metric.value)) |
| if value is None: |
| value = metric.value |
| |
| if metric.attributeKey: |
| if metric.attribute is not None and type_info.get(metric.attribute) is None: |
| type_info[metric.attribute] = {} |
| |
| if value == -1: |
| value = "无限制" |
| elif metric.attributeKey in size_list: |
| value = public.to_size(value) |
| elif metric.attributeKey in microsecond_list: |
| value = datetime.datetime.fromtimestamp(int(value) / 1000).strftime('%Y-%m-%d %H:%M:%S') |
| elif metric.attributeKey in nanoseconds_list: |
| value = "{} 秒".format(int(value) / 1e9) |
| |
| type_info[metric.attribute][metric.attributeKey] = value |
| else: |
| if metric.attribute in size_list: |
| value = public.to_size(value) |
| elif metric.attribute in percent_list: |
| value = "{}%".format(round(int(value) * 100, 2)) |
| elif metric.attribute in microsecond_list: |
| value = datetime.datetime.fromtimestamp(int(value) / 1000).strftime('%Y-%m-%d %H:%M:%S') |
| elif metric.attribute in nanoseconds_list: |
| value = "{} 秒".format(int(value) / 1e9) |
| type_info[metric.attribute] = value |
| return {"status": True, "msg": "ok", "data": jmx_status_info} |
| |
| def get_project_status(self, project_id): |
| |
| project_info = public.M('sites').where('project_type=? AND id=?', ('Java', project_id)).find() |
| if not project_info: |
| return None, "" |
| |
| project_info["project_config"] = json.loads(project_info["project_config"]) |
| if project_info['project_config']['java_type'] == 'springboot': |
| if self.is_stop_by_user(project_id): |
| return True, project_info["name"] |
| return self.get_project_run_state(project_name = project_info['name']), project_info["name"] |
| |
| if project_info['project_config']['java_type'] == 'duli': |
| if self.is_stop_by_user(self.__site_path + "/" + project_info["name"]): |
| return True, project_info["name"] |
| return self.get_duli_run_state(project_name = project_info['name']), project_info["name"] |
| |
| if project_info['project_config']['java_type'] == 'neizhi': |
| version = project_info['project_config']['tomcat_version'] |
| if self.is_stop_by_user("/etc/init.d/bttomcat{}".format(version)): |
| return True, project_info["name"] |
| tomcat_path = '/usr/local/bttomcat/tomcat{}'.format(version) |
| return self.get_duli_run_state( |
| project_name = project_info["name"], bt_tomcat_web = tomcat_path, |
| neizhi = True |
| ), project_info["name"] |
| |
| def set_jdk_environment(self, get): |
| |
| jdk_name = get.name |
| jdk_path = "/www/server/java/{}/bin/java".format(jdk_name) |
| |
| |
| if not os.path.exists(jdk_path): |
| return "提供的JDK路径不存在。" |
| |
| |
| new_java_home = os.path.dirname(os.path.dirname(jdk_path)) |
| |
| |
| profile_path = '/etc/profile' |
| java_home_line = "export JAVA_HOME={}".format(new_java_home) |
| path_line = "export PATH=$JAVA_HOME/bin:$PATH" |
| |
| |
| if os.path.exists(profile_path): |
| |
| |
| with open(profile_path, 'r') as file: |
| lines = file.readlines() |
| |
| try: |
| |
| with open(profile_path, 'w') as file: |
| java_home_set = False |
| for line in lines: |
| if 'export JAVA_HOME=' in line: |
| file.write(java_home_line + '\n') |
| java_home_set = True |
| elif 'export PATH=$JAVA_HOME/bin:$PATH' in line: |
| |
| continue |
| else: |
| file.write(line) |
| if not java_home_set: |
| |
| file.write(java_home_line + '\n') |
| |
| file.write(path_line + '\n') |
| public.ExecShell("source /etc/profile") |
| |
| return public.returnMsg(True, "设置成功！") |
| except: |
| return public.returnMsg(False, "设置失败，请查看您是否开启了系统加固！") |
| |
| else: |
| return public.returnMsg(False, "设置失败！") |
|
|
| def get_system_user_list(self, get): |
| """ |
| 默认只返回uid>= 1000 的用户 和 root |
| get中包含 sys_user 返回 uid>= 100 的用户 和 root |
| get中包含 all_user 返回所有的用户 |
| """ |
| is_spring_boot = get.get("springboot/d", 0) |
| if is_spring_boot: |
| self.set_spring_user() |
| sys_user = False |
| all_user = False |
| if get is not None: |
| if hasattr(get, "sys_user"): |
| sys_user = True |
| if hasattr(get, "all_user"): |
| all_user = True |
| |
| user_set = set() |
| try: |
| for tmp_uer in pwd.getpwall(): |
| |
| |
| if tmp_uer.pw_uid == 0: |
| user_set.add(tmp_uer.pw_name) |
| elif tmp_uer.pw_uid >= 1000: |
| user_set.add(tmp_uer.pw_name) |
| elif sys_user and tmp_uer.pw_uid >= 100: |
| user_set.add(tmp_uer.pw_name) |
| elif all_user: |
| user_set.add(tmp_uer.pw_name) |
| except Exception: |
| pass |
| return list(user_set) |
|
|
|
|
| def generate_port(self, get): |
| return public.returnMsg(True, self.generate_random_port()) |
