684 lines
29 KiB
Python
684 lines
29 KiB
Python
# -*- coding: utf-8 -*-
|
||
__author__ = 'huaxuemin'
|
||
|
||
from logbook import Logger
|
||
import shutil
|
||
import errno
|
||
import os
|
||
import sqlite3
|
||
from pathlib import Path
|
||
import random
|
||
import socket
|
||
import configparser
|
||
import codecs
|
||
import time
|
||
import json
|
||
import re
|
||
import requests
|
||
|
||
logging = Logger(__name__)
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
ROBOT_LOG_LEVEL = 'INFO'
|
||
from requests.packages.urllib3.exceptions import InsecureRequestWarning
|
||
|
||
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
|
||
|
||
|
||
class OSType:
|
||
WIN, LINUX, UNKNOWN = range(3)
|
||
|
||
def __init__(self):
|
||
pass
|
||
|
||
@staticmethod
|
||
def get_type():
|
||
import platform
|
||
system_name = platform.system()
|
||
if system_name.lower() == 'windows':
|
||
return OSType.WIN
|
||
elif system_name.lower() == 'linux':
|
||
return OSType.LINUX
|
||
else:
|
||
return OSType.UNKNOWN
|
||
|
||
|
||
def run_process(cmd_str, out_p=False):
|
||
"""
|
||
run command
|
||
cmd_str unicode string.
|
||
"""
|
||
if OSType.WIN == OSType.get_type():
|
||
# cmd_str = cmd_str.encode('gbk')
|
||
cmd_str = cmd_str
|
||
elif OSType.LINUX == OSType.get_type():
|
||
cmd_str = cmd_str.encode('utf-8')
|
||
else:
|
||
raise RuntimeError("your os is not support.")
|
||
|
||
logging.info('cmd: %s' % cmd_str)
|
||
print(cmd_str)
|
||
import subprocess
|
||
from subprocess import PIPE
|
||
close_fds = False if OSType.WIN == OSType.get_type() else True
|
||
if out_p:
|
||
p = subprocess.Popen(cmd_str, shell=True, close_fds=close_fds, stdout=PIPE)
|
||
p.wait()
|
||
return p.returncode, p.stdout.read()
|
||
else:
|
||
p = subprocess.Popen(cmd_str, shell=True, close_fds=close_fds, stdout=subprocess.DEVNULL)
|
||
p.wait()
|
||
return p.returncode, None
|
||
|
||
|
||
class CaseRunner:
|
||
|
||
def __init__(self, workspace, case_path, test_case, include, exclude, rerun="true", special_env="", team="",
|
||
physics_env="QA", business="hh"):
|
||
self.workspace = workspace
|
||
self.case_path = case_path
|
||
self.test_case = test_case
|
||
self.include = include
|
||
self.exclude = exclude
|
||
self.rerun = rerun
|
||
self.special_env = special_env
|
||
self.team = team
|
||
self.physics_env = physics_env
|
||
self.business = business
|
||
self.con = sqlite3.connect(HERE + "/case_runner.db")
|
||
self.cur = self.con.cursor()
|
||
self.def_port = set("9" + "".join(map(str, random.choices(range(10), k=3))) for i in range(500))
|
||
self.env_port = None
|
||
self.pid = None
|
||
self.wait_time = 120
|
||
self.all_dir_name = set()
|
||
self.galaxy_server_name_to_swagger = {"peppa-teach-opt-cms-api": "teach-opt-cms-api",
|
||
"peppa-teach-biz-server": "peppa-teach-biz",
|
||
"peppa-market-server": "peppa-market",
|
||
"peppa-teach-parker-server": "peppa-teach-parker",
|
||
"peppa-course-server": "peppa-course"}
|
||
self.swagger_name_to_galaxy = {"teach-opt-cms-api": "peppa-teach-opt-cms-api",
|
||
"peppa-teach-biz": "peppa-teach-biz-server",
|
||
"peppa-market": "peppa-market-server",
|
||
"peppa-teach-parker": "peppa-teach-parker-server",
|
||
"peppa-course": "peppa-course-server"}
|
||
# 获取opengalaxy ssotoken相关变量
|
||
self.ops_uri = "http://opengalaxy.bg.huohua.cn"
|
||
self.showUsername = "luohong"
|
||
self.username = "luohong"
|
||
self.password = "Lh123456789@"
|
||
self.sso_login_url = "https://sso.huohua.cn/authentication/form"
|
||
self.redirect_url = "https://sso.huohua.cn/oauth/authorize?client_id=open-galaxy&response_type=code&redirect_uri=http://opengalaxy.bg.huohua.cn/api/v1/users/user/ssologin/"
|
||
|
||
def getSsoToken(self):
|
||
session = requests.session()
|
||
post_data = dict()
|
||
post_data['showUsername'] = self.showUsername
|
||
post_data['username'] = self.username
|
||
post_data['password'] = self.password
|
||
session.post(url=self.sso_login_url, data=post_data, allow_redirects=True, verify=False)
|
||
resp = session.get(
|
||
url=self.redirect_url,
|
||
allow_redirects=False,
|
||
verify=False)
|
||
resp1 = session.get(
|
||
url=resp.headers['Location'],
|
||
allow_redirects=False,
|
||
verify=False)
|
||
ssoToken = resp1.headers["Set-Cookie"].split(";")[4].split("=")[2]
|
||
return ssoToken
|
||
|
||
def update_platform(self):
|
||
if len(self.special_env) > 0:
|
||
config_file = str(Path(self.workspace) / "base_framework/base_config/env_choose.ini")
|
||
fd = open(config_file, encoding='utf-8')
|
||
data = fd.read()
|
||
if data[:3] == codecs.BOM_UTF8:
|
||
data = data[3:]
|
||
files = codecs.open(config_file, "w")
|
||
files.write(data)
|
||
files.close()
|
||
fd.close()
|
||
|
||
cf = configparser.ConfigParser(allow_no_value=True)
|
||
cf.read(config_file, encoding='utf-8')
|
||
cf.set("run_jira_id", "huohua-podenv", self.special_env)
|
||
with open(config_file, 'w') as fw: # 循环写入
|
||
cf.write(fw)
|
||
|
||
def assign_port(self):
|
||
workspace_base_name = Path(self.workspace).name
|
||
query_port = "SELECT PORT FROM ENV_PORT WHERE NAME='{}'".format(workspace_base_name)
|
||
res_port = self.cur.execute(query_port).fetchall()
|
||
query_all_port = "SELECT PORT FROM ENV_PORT"
|
||
res_all_port = self.cur.execute(query_all_port).fetchall()
|
||
not_use_port = (self.def_port - set(str(item[0]) for item in res_all_port)).pop()
|
||
print("not use port is {}".format(not_use_port))
|
||
self.env_port = not_use_port
|
||
if len(res_port) == 0:
|
||
insert_name_port_sql = "INSERT INTO ENV_PORT(NAME,PORT)VALUES(?,?)"
|
||
self.cur.execute(insert_name_port_sql, (workspace_base_name, not_use_port)).fetchall()
|
||
self.con.commit()
|
||
else:
|
||
update_name_port_sql = "UPDATE ENV_PORT SET PORT='{}' WHERE NAME='{}'".format(self.env_port,
|
||
workspace_base_name)
|
||
self.cur.execute(update_name_port_sql).fetchall()
|
||
self.con.commit()
|
||
|
||
self.cur.close()
|
||
self.con.close()
|
||
print("use port is {}".format(self.env_port))
|
||
|
||
# def assign_port(self):
|
||
# workspace_base_name = Path(self.workspace).name
|
||
# query_port = "SELECT PORT FROM ENV_PORT WHERE NAME='{}'".format(workspace_base_name)
|
||
# res = self.cur.execute(query_port).fetchall()
|
||
# if len(res) == 0:
|
||
# query_all_port = "SELECT PORT FROM ENV_PORT"
|
||
# res_all_port = self.cur.execute(query_all_port).fetchall()
|
||
# not_use_port = (self.def_port - set(str(item[0]) for item in res_all_port)).pop()
|
||
# print("not use port is {}".format(not_use_port))
|
||
# insert_name_port_sql = "INSERT INTO ENV_PORT(NAME,PORT)VALUES(?,?)"
|
||
# self.cur.execute(insert_name_port_sql, (workspace_base_name, not_use_port)).fetchall()
|
||
# self.con.commit()
|
||
# self.env_port = not_use_port
|
||
# else:
|
||
# self.env_port = str(res[0][0])
|
||
# self.cur.close()
|
||
# self.con.close()
|
||
# print("use port is {}".format(self.env_port))
|
||
|
||
def _get_not_used_port(self):
|
||
find_pid_linux_cmd = "lsof -i:{}".format(self.env_port)
|
||
res_code, res_context = run_process(find_pid_linux_cmd, out_p=True)
|
||
if len(res_context) > 0:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def check_port(self):
|
||
if OSType.WIN == OSType.get_type():
|
||
find_pid_win_cmd = 'netstat -ano | findstr {} | findstr LISTENING'.format(self.env_port)
|
||
res_code, res_context = run_process(find_pid_win_cmd, out_p=True)
|
||
if res_code == 0:
|
||
print(res_context)
|
||
if len(res_context) > 0:
|
||
try:
|
||
self.pid = str(res_context).split()[-1].replace("\\r\\n'", "")
|
||
self._kill_pid()
|
||
except IndexError:
|
||
pass
|
||
|
||
elif OSType.LINUX == OSType.get_type():
|
||
find_pid_linux_cmd = "lsof -i:{}".format(self.env_port)
|
||
res_code, res_context = run_process(find_pid_linux_cmd, out_p=True)
|
||
if res_code == 0:
|
||
print(res_context)
|
||
# 获取pid
|
||
if len(res_context) > 0:
|
||
try:
|
||
self.pid = str(res_context).split("\\n")[1].split()[1]
|
||
self._kill_3_pid()
|
||
except IndexError:
|
||
pass
|
||
else:
|
||
raise RuntimeError("your os is not support.")
|
||
|
||
def _kill_3_pid(self):
|
||
self._kill_pid()
|
||
count = 3
|
||
while count > 0:
|
||
find_pid_linux_cmd = "lsof -i:{}".format(self.env_port)
|
||
res_code, res_context = run_process(find_pid_linux_cmd, out_p=True)
|
||
|
||
if len(res_context) > 0:
|
||
time.sleep(2)
|
||
self.pid = str(res_context).split("\\n")[1].split()[1]
|
||
self._kill_pid()
|
||
count -= 1
|
||
continue
|
||
else:
|
||
break
|
||
|
||
def _kill_pid(self):
|
||
if OSType.WIN == OSType.get_type():
|
||
kill_pid_cmd = "taskkill /f /pid {}".format(self.pid)
|
||
elif OSType.LINUX == OSType.get_type():
|
||
kill_pid_cmd = "kill -9 {}".format(self.pid)
|
||
else:
|
||
raise RuntimeError("your os is not support.")
|
||
|
||
res_code, res_context = run_process(kill_pid_cmd)
|
||
if res_code:
|
||
raise RuntimeError("kill pid: {} failed. error: {}".format(self.pid, res_context))
|
||
|
||
def update_port(self):
|
||
main_py = Path(self.workspace) / "base_framework/main.py"
|
||
tmp_py = Path(self.workspace) / "base_framework/tmp.py"
|
||
shutil.copy(main_py, tmp_py)
|
||
src_context = "port=9999"
|
||
dst_context = "port={}".format(self.env_port)
|
||
self._replace_file_context(tmp_py, main_py, src_context, dst_context)
|
||
env_robot = Path(self.workspace) / "{}/test_case/Resource/AdapterKws/env.robot".format(self.team)
|
||
tmp_robot = Path(self.workspace) / "{}/test_case/Resource/AdapterKws/tmp.robot".format(self.team)
|
||
shutil.copy(env_robot, tmp_robot)
|
||
src_context = "127.0.0.1:9999"
|
||
dst_context = "127.0.0.1:{}".format(self.env_port)
|
||
self._replace_file_context(tmp_robot, env_robot, src_context, dst_context)
|
||
|
||
def update_suite(self):
|
||
case_dir = Path(self.workspace) / "{}/test_case".format(self.team)
|
||
self._set_path(case_dir)
|
||
|
||
case_src_path = Path(self.case_path)
|
||
if case_src_path.is_file():
|
||
base_name = case_src_path.name.split(case_src_path.suffix)[0]
|
||
if base_name.upper() in self.all_dir_name:
|
||
self.case_path = str(case_src_path.with_name(base_name + "9" + case_src_path.suffix))
|
||
|
||
self._replace_path(case_dir)
|
||
|
||
def _set_path(self, src_path):
|
||
for p in src_path.iterdir():
|
||
if p.is_dir():
|
||
self.all_dir_name.add(p.name.upper())
|
||
self._set_path(p)
|
||
|
||
def _replace_path(self, src_path):
|
||
for p in src_path.iterdir():
|
||
if p.is_dir():
|
||
self._replace_path(p)
|
||
elif p.is_file():
|
||
base_name = p.name.split(p.suffix)[0]
|
||
if base_name.upper() in self.all_dir_name:
|
||
p.rename(p.with_name(base_name + "9" + p.suffix))
|
||
|
||
def start_kwl(self):
|
||
startup_path = Path(self.workspace) / "base_framework"
|
||
startup = "startup.py"
|
||
exec_cmd_params = ""
|
||
if len(self.special_env) > 0:
|
||
exec_cmd_params = exec_cmd_params + "-j {} ".format(self.special_env)
|
||
if len(self.team) > 0:
|
||
exec_cmd_params = exec_cmd_params + "-t {} ".format(self.team)
|
||
if len(self.business) > 0:
|
||
exec_cmd_params = exec_cmd_params + "-b {} ".format(self.business)
|
||
if OSType.WIN == OSType.get_type():
|
||
exec_cmd_path = "cd {} && python {} ".format(startup_path, startup)
|
||
exec_cmd = exec_cmd_path + exec_cmd_params
|
||
elif OSType.LINUX == OSType.get_type():
|
||
exec_cmd_path = "cd {} && python3 {} ".format(startup_path, startup)
|
||
exec_cmd = exec_cmd_path + exec_cmd_params
|
||
else:
|
||
raise RuntimeError("your os is not support.")
|
||
exec_cmd = exec_cmd[:-1]
|
||
# import subprocess
|
||
# from subprocess import PIPE
|
||
# close_fds = False if OSType.WIN == OSType.get_type() else True
|
||
# subprocess.Popen(exec_cmd, shell=True, close_fds=close_fds, stdout=subprocess.DEVNULL)
|
||
try:
|
||
pro = self._start_kwl_server(exec_cmd)
|
||
if not pro.is_alive():
|
||
print("--------pro.exec_status: ", pro.is_alive())
|
||
pro.kill()
|
||
time.sleep(5)
|
||
self._kill_3_pid()
|
||
self._start_kwl_server(exec_cmd)
|
||
except Exception as e:
|
||
print("--------error: ", e)
|
||
|
||
@staticmethod
|
||
def _start_kwl_server(exec_cmd):
|
||
from multiprocessing import Process
|
||
p = Process(target=run_process, args=(exec_cmd,))
|
||
p.daemon = True
|
||
p.start()
|
||
time.sleep(30)
|
||
return p
|
||
|
||
@staticmethod
|
||
def _replace_file_context(src_file, dst_file, src_context, dst_context):
|
||
with open(src_file, "r") as f_src:
|
||
with open(dst_file, "w") as f_dst:
|
||
for line in f_src:
|
||
if src_context in line:
|
||
f_dst.writelines(line.replace(src_context, dst_context))
|
||
else:
|
||
f_dst.writelines(line)
|
||
|
||
def _get_report_dir(self):
|
||
"""
|
||
Create %WORKSPACE%/Report 用于存放对应构建的构建日志
|
||
"""
|
||
report_dir = os.path.join(self.workspace, 'Report')
|
||
if not os.path.exists(report_dir):
|
||
logging.info(u'create report directory: %s' % report_dir)
|
||
os.makedirs(report_dir)
|
||
|
||
return report_dir
|
||
|
||
def _get_report_ci_out_dir(self):
|
||
"""
|
||
Create %WORKSPACE%/Report/ci_out，用于存放构建日志
|
||
"""
|
||
ci_out_dir = os.path.join(self.workspace, 'Report', 'ci_out')
|
||
if os.path.exists(ci_out_dir):
|
||
logging.info(u'create ci output directory: %s' % ci_out_dir)
|
||
shutil.rmtree(ci_out_dir)
|
||
|
||
return ci_out_dir
|
||
|
||
@staticmethod
|
||
def copy_any_thing(src, dst):
|
||
try:
|
||
shutil.copytree(src, dst)
|
||
except OSError as exc:
|
||
if exc.errno == errno.ENOTDIR:
|
||
shutil.copy(src, dst)
|
||
else:
|
||
raise
|
||
|
||
def _wait_kwl_run(self):
|
||
i = 0
|
||
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||
while i < self.wait_time:
|
||
try:
|
||
s.connect(("127.0.0.1", int(self.env_port)))
|
||
s.shutdown(2)
|
||
s.close()
|
||
return
|
||
except socket.error:
|
||
i += 1
|
||
s.close()
|
||
|
||
def run_cases(self):
|
||
"""
|
||
run cases by workspace include exclude.
|
||
"""
|
||
self._wait_kwl_run()
|
||
report_dir = os.path.join(self.workspace, 'Report')
|
||
if os.path.exists(report_dir):
|
||
logging.info(u'clean report directory: %s' % report_dir)
|
||
shutil.rmtree(report_dir)
|
||
os.makedirs(report_dir)
|
||
|
||
if self.rerun == 'true' or self.rerun == '':
|
||
self._rerun_failed_cases()
|
||
else:
|
||
self._default_run_cases()
|
||
|
||
out_dir = os.path.join(self._get_report_dir(), 'out')
|
||
if os.path.exists(out_dir):
|
||
# copy report to ci_out.
|
||
self.copy_any_thing(self._get_report_dir(), self._get_report_ci_out_dir())
|
||
else:
|
||
raise RuntimeError(u'%s directory is not exist.' % out_dir)
|
||
|
||
def _default_run_cases(self):
|
||
"""
|
||
exec robot and output log to {report_dir}/out directory.
|
||
return command execute exit code.
|
||
"""
|
||
|
||
test_case_cmdstr = []
|
||
if len(self.test_case) > 0:
|
||
for tc in self.test_case.split(','):
|
||
test_case_cmdstr.append(u'--test %s' % tc)
|
||
|
||
includes_cmdstr = []
|
||
if len(self.include) > 0:
|
||
for include in self.include.split(','):
|
||
includes_cmdstr.append(u'--include %s' % include)
|
||
|
||
excludes_cmdstr = []
|
||
if len(self.exclude) > 0:
|
||
for exclude in self.exclude.split(','):
|
||
excludes_cmdstr.append(u'--exclude %s' % exclude)
|
||
output_directory = os.path.join(self._get_report_dir(), 'out')
|
||
Path(output_directory).mkdir(exist_ok=True)
|
||
|
||
# Set ROBOT_SYSLOG_FILE and ROBOT_SYSLOG_LEVEL environment variable.
|
||
os.environ['ROBOT_SYSLOG_FILE'] = os.path.join(self._get_report_dir(), 'robot_syslog.txt')
|
||
os.environ['ROBOT_SYSLOG_LEVEL'] = ROBOT_LOG_LEVEL
|
||
|
||
logging.info(u'building cases...')
|
||
res_code, _ = run_process(' '.join(
|
||
[u'robot'] + test_case_cmdstr + excludes_cmdstr + includes_cmdstr + [u'-d', output_directory,
|
||
self.case_path]))
|
||
|
||
# clear ROBOT_SYSLOG_FILE(NONE) and ROBOT_SYSLOG_LEVEL environment variable.
|
||
os.environ['ROBOT_SYSLOG_FILE'] = 'NONE'
|
||
|
||
return res_code
|
||
|
||
def _rerun_failed_cases(self):
|
||
"""
|
||
execute robot twice(the second execute is only failed in first.)
|
||
and remerge output to {report_dir}/out directory.
|
||
"""
|
||
|
||
logging.info('rerunfailed cases mode...')
|
||
|
||
return_code = self._default_run_cases()
|
||
logging.info('first run exit code: %s' % return_code)
|
||
if not return_code:
|
||
logging.info('first cases built successfully')
|
||
return
|
||
|
||
logging.info('the first cases to build there is failure cases')
|
||
output_directory = os.path.join(self._get_report_dir(), u'out')
|
||
|
||
if not os.path.exists(output_directory):
|
||
raise RuntimeError(u'the first cases to built throw exception.')
|
||
|
||
output_directory_r1 = os.path.join(self._get_report_dir(), u'first_out')
|
||
output_directory_r2 = os.path.join(self._get_report_dir(), u'second_out')
|
||
logging.info('rename the first cases to build the output directory')
|
||
cur_dir = os.getcwd()
|
||
os.chdir(self._get_report_dir())
|
||
if OSType.WIN == OSType.get_type():
|
||
cmd_str = 'ren out first_out'
|
||
elif OSType.LINUX == OSType.get_type():
|
||
cmd_str = 'cp -R out first_out'
|
||
else:
|
||
raise RuntimeError("your os is not support.")
|
||
os.system(cmd_str)
|
||
os.chdir(cur_dir)
|
||
|
||
output_directory_cmdstr = [u'-d', output_directory_r2]
|
||
rerun_failed_cmdstr = [u'--rerunfailed', os.path.join(output_directory_r1, u'output.xml')]
|
||
|
||
logging.info('rerunfailed test cases...')
|
||
run_process(' '.join([u'robot'] + output_directory_cmdstr + rerun_failed_cmdstr + [self.case_path]))
|
||
|
||
if not os.path.exists(output_directory_r2):
|
||
raise RuntimeError(u'the second cases to built throw throw exception.')
|
||
|
||
# Set ROBOT_SYSLOG_FILE and ROBOT_SYSLOG_LEVEL environment variable.
|
||
os.environ['ROBOT_SYSLOG_FILE'] = os.path.join(self._get_report_dir(), 'robot_syslog2.txt')
|
||
os.environ['ROBOT_SYSLOG_LEVEL'] = ROBOT_LOG_LEVEL
|
||
|
||
logging.info('merge report...')
|
||
run_process(' '.join([u'rebot', u'-d', output_directory, u'-o', u'output.xml', u'--merge',
|
||
os.path.join(output_directory_r1, u'output.xml'),
|
||
os.path.join(output_directory_r2, u'output.xml')]))
|
||
# clear ROBOT_SYSLOG_FILE(NONE) and ROBOT_SYSLOG_LEVEL environment variable.
|
||
os.environ['ROBOT_SYSLOG_FILE'] = 'NONE'
|
||
|
||
def record_build_url(self, build_id, report_url):
|
||
try:
|
||
if build_id:
|
||
import pymysql
|
||
db = pymysql.connect(host="mysql.qa.huohua.cn", user="qa-dev", password="jaeg3SCQt0",
|
||
database="sparkatp", charset='utf8')
|
||
cursor = db.cursor()
|
||
if build_id and report_url:
|
||
update_sql = "UPDATE sparkatp.build_info set report_url='{}',status=2 WHERE id={}".format(
|
||
report_url, build_id)
|
||
cursor.execute(update_sql)
|
||
cursor.fetchall()
|
||
try:
|
||
self.get_jacoco_report(cursor, build_id)
|
||
except Exception as e:
|
||
print(e)
|
||
db.commit()
|
||
cursor.close()
|
||
db.close()
|
||
|
||
except Exception as e:
|
||
print(e)
|
||
|
||
def get_tester_by_project_id(self):
|
||
"""
|
||
获取project_id和tester
|
||
:return:
|
||
"""
|
||
try:
|
||
import pymysql
|
||
db = pymysql.connect(host="10.250.200.53", user="root", password="peppa@test", database="tools",
|
||
charset='utf8')
|
||
cursor = db.cursor()
|
||
|
||
db.commit()
|
||
cursor.close()
|
||
db.close()
|
||
except Exception as e:
|
||
print(e)
|
||
|
||
def get_project_id_by_build_id(self, cursor, build_id):
|
||
try:
|
||
if build_id:
|
||
get_scene_id_sql = "SELECT scene_id FROM build_info where id='{}'".format(
|
||
build_id)
|
||
cursor.execute(get_scene_id_sql)
|
||
scene_id_info = cursor.fetchone()
|
||
if scene_id_info:
|
||
scene_id = scene_id_info[0]
|
||
get_project_id_sql = "SELECT project_id FROM scene_new where id='{}'".format(
|
||
scene_id)
|
||
cursor.execute(get_project_id_sql)
|
||
project_id_info = cursor.fetchone()
|
||
if project_id_info:
|
||
project_id = project_id_info[0]
|
||
return project_id
|
||
return 0
|
||
return 0
|
||
except Exception as e:
|
||
print(e)
|
||
|
||
def get_jacoco_report(self, cursor, build_id):
|
||
get_server_name_sql = "SELECT run_server_list FROM build_info where id='{}' and is_jacoco=1".format(build_id)
|
||
cursor.execute(get_server_name_sql)
|
||
server_name_info = cursor.fetchone()
|
||
if server_name_info:
|
||
server_name_list = eval(server_name_info[0])
|
||
for server_name in server_name_list:
|
||
if server_name == "PEPPA-TEACH-API" or server_name == "peppa-teach-api" or "-EXECUTOR" in server_name.upper():
|
||
continue
|
||
self._do_jacoco_report(server_name, build_id, cursor)
|
||
|
||
def _do_jacoco_report(self, project_name, build_id, cursor):
|
||
if not self.special_env:
|
||
insert_data = "INSERT INTO `sparkatp`.`build_jacoco`(`build_info_id`, `jacoco_report_id`, `team`, `server_name`, `now_version`, `base_version`, `env_name`, `status`, `report_url`, `remark`) VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}');".format(
|
||
build_id, "", self.team, project_name, self.special_env, "master",
|
||
self.special_env, "1", "", "QA环境构建，不需要收集增量覆盖率")
|
||
cursor.execute(insert_data)
|
||
return
|
||
elif self.special_env.upper() == "NONE" or self.special_env.upper() == "QA":
|
||
insert_data = "INSERT INTO `sparkatp`.`build_jacoco`(`build_info_id`, `jacoco_report_id`, `team`, `server_name`, `now_version`, `base_version`, `env_name`, `status`, `report_url`, `remark`) VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}');".format(
|
||
build_id, "", self.team, project_name, self.special_env, "master",
|
||
self.special_env, "1", "", "QA环境构建，不需要收集增量覆盖率")
|
||
cursor.execute(insert_data)
|
||
return
|
||
# 收集覆盖率报告
|
||
import requests
|
||
import json
|
||
if self.team.upper() in ["CC", "LALIVE", "H2R"]:
|
||
self.team = "CC"
|
||
if self.team.upper() in ["SCM", "ES"]:
|
||
self.team = "ES"
|
||
if self.team.upper() in ["TO", "TMO"]:
|
||
self.team = "TTS"
|
||
current_version = self.get_branch_from_open_galaxy(self.special_env, project_name)
|
||
if current_version == "master":
|
||
insert_data = "INSERT INTO `sparkatp`.`build_jacoco`(`build_info_id`, `jacoco_report_id`, `team`, `server_name`, `now_version`, `base_version`, `env_name`, `status`, `report_url`, `remark`) VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}');".format(
|
||
build_id, "", self.team, project_name, current_version, current_version,
|
||
self.special_env, "1", "", "master不需要收集增量覆盖率")
|
||
cursor.execute(insert_data)
|
||
return
|
||
if not current_version:
|
||
print("-----------------: {}, 独立环境： {}， 服务名： {}".format("未在独立环境中服务，不收集覆盖率", self.special_env, project_name))
|
||
return
|
||
if project_name.lower() in self.galaxy_server_name_to_swagger.keys():
|
||
project_name = self.galaxy_server_name_to_swagger[project_name.lower()]
|
||
base_version = "master"
|
||
url = "http://10.250.0.252:8989/cov/syncCollectionCov"
|
||
params = {"baseVersion": base_version, "businessName": self.team, "currentVersion": current_version,
|
||
"departmentName": "质量保障中心",
|
||
"envName": self.special_env, "isBranch": 1, "isDiff": 2, "projectName": project_name}
|
||
res = requests.post(url, json=params)
|
||
if res.status_code == 200:
|
||
if json.loads(res.text)["msg"] != "success":
|
||
logging.error("{}收集覆盖率报告失败，err: {}".format(project_name, res.text))
|
||
insert_data = "INSERT INTO `sparkatp`.`build_jacoco`(`build_info_id`, `jacoco_report_id`, `team`, `server_name`, `now_version`, `base_version`, `env_name`, `status`, `report_url`, `remark`) VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}');".format(
|
||
build_id, "", self.team, project_name, current_version, base_version,
|
||
self.special_env, "3", "", res.text)
|
||
cursor.execute(insert_data)
|
||
else:
|
||
jacoco_report_id = json.loads(res.text)["data"]
|
||
insert_data = "INSERT INTO `sparkatp`.`build_jacoco`(`build_info_id`, `jacoco_report_id`, `team`, `server_name`, `now_version`, `base_version`, `env_name`, `status`, `report_url`, `remark`) VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}');".format(
|
||
build_id, int(jacoco_report_id), self.team, project_name, current_version, base_version,
|
||
self.special_env, "0", "", "")
|
||
cursor.execute(insert_data)
|
||
else:
|
||
logging.error("{}收集覆盖率报告失败，status：{}，err: {}".format(project_name, str(res.status_code), res.text))
|
||
insert_data = "INSERT INTO `sparkatp`.`build_jacoco`(`build_info_id`, `jacoco_report_id`, `team`, `server_name`, `now_version`, `base_version`, `env_name`, `status`, `report_url`, `remark`) VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}');".format(
|
||
build_id, "", self.team, project_name, current_version, base_version,
|
||
self.special_env, "3", "", res.text)
|
||
cursor.execute(insert_data)
|
||
# print(res.text)
|
||
|
||
def get_branch_from_open_galaxy(self, special_env, server_name):
|
||
if server_name.lower() in self.swagger_name_to_galaxy.keys():
|
||
server_name = self.swagger_name_to_galaxy[server_name.lower()]
|
||
try:
|
||
headers = {
|
||
"Api-Token": "2a1cbc25e0d183e1ec9fe5872c1433617c96da9e2905c4371d8f979479910aa1"}
|
||
open_galaxy_url = "http://opengalaxy.bg.huohua.cn/api/v1/hcloud/tree/node/sec/application?sec_name={}".format(
|
||
special_env)
|
||
res = requests.get(open_galaxy_url, headers=headers)
|
||
if res.status_code == 200:
|
||
result = json.loads(res.text)
|
||
for item in result["data"]["results"]:
|
||
if item["name"].lower() == server_name.lower():
|
||
branch = item["branch"]
|
||
return branch
|
||
return ""
|
||
else:
|
||
print("获取运维服务列表失败，status: {}, res: {}".format(res.status_code, res.text))
|
||
return ""
|
||
except Exception as e:
|
||
print(e)
|
||
return ""
|
||
|
||
|
||
if __name__ == '__main__':
|
||
# workspace = "/root/workspaces/huaxuemin-dev"
|
||
workspace = r"E:\huohua\auto\huaxuemin-dev"
|
||
# case_path = "/root/workspaces/huaxuemin-dev/HuoHuaTestCase/EN/1.接口/Peppa-Eng-Live/play_back.robot"
|
||
case_path = r"E:\huohua\auto\huaxuemin-dev\HuoHuaTestCase\EN\1.接口\Peppa-Eng-Live\play_back.robot"
|
||
test_case = ""
|
||
include = ""
|
||
exclude = ""
|
||
test = CaseRunner(workspace, case_path, test_case, include, exclude)
|
||
# test.assign_port()
|
||
# test.check_port()
|
||
# test.update_port()
|
||
# test.start_kwl()
|
||
# test.run_cases()
|
||
# test.check_port()
|
||
# build_info_id = '16329'
|
||
# build_url = 'http://10.250.200.1:8080/jenkins/view/QE_JOB/job/qe_job1/63/'
|
||
# test.record_build_url(build_info_id, build_url)
|
||
res = test.get_branch_from_open_galaxy("HHC-92692", "peppa-asset-server")
|
||
print(res)
|