def run_client_command(self, cmd_sec_name, tmp_logfile, bench_name):
fp = open(tmp_logfile, "a+")
start_log = "%%%%%% %s test start %%%%%% \n" % cmd_sec_name
fp.write(start_log)
fp.write("<<<BEGIN TEST>>>\n")
tags = "[test: " + cmd_sec_name + "]\n"
fp.write(tags)
logs = "log: " + cmd_sec_name + "\n"
fp.write(logs)
fp.close()
start = time.time()
flag = 0
logging.debug("the client running command is %s" % cmd_sec_name)
try:
logging.debug(
"begining to execute the command of %s on remote host" %
cmd_sec_name)
fp = open(tmp_logfile, "a+")
logging.debug("client command in localhost is: %s" % cmd_sec_name)
# FIXME: update code for this condition
[out, returncode] = self.run_commands(bench_name, cmd_sec_name)
fp.close()
server_utils.file_copy(tmp_logfile,
'/tmp/%s_output.log' % bench_name, 'a+')
except error.ServRunError, e:
fp = open(tmp_logfile, "a+")
fp.write("[status]: FAIL\n")
sys.stdout.write(e)
flag = -1
fp.close()
def run_commands(self, bench_name, cmd_sec_name):
returncode = -1
output = ''
pwd = os.getcwd()
try:
# the commands is multiple lines, and was included by Quotation
try:
logging.debug("the actual commands running in local is: %s" %
cmd_sec_name)
test_case_dir = os.path.join(caliper_path.BENCHS_DIR,
bench_name, 'tests')
cmd_sec_name_tmp_file = os.path.join(Folder.workspace,
Folder.name,
cmd_sec_name + '_tmp.log')
subprocess.call("echo '$$ %s RUN START' >> %s" %
(cmd_sec_name, cmd_sec_name_tmp_file),
shell=True)
os.chdir(test_case_dir)
result = subprocess.call(
'ansible-playbook -i %s %s.yml --extra-vars "hosts=%s" -u %s>> %s 2>&1'
% (Folder.project_config, cmd_sec_name, self.host,
getpass.getuser(), cmd_sec_name_tmp_file),
stdout=subprocess.PIPE,
shell=True)
subprocess.call("echo '$$ %s RUN STOP' >> %s" %
(cmd_sec_name, cmd_sec_name_tmp_file),
shell=True)
subprocess.call(
"echo '==================================' >> %s" %
(cmd_sec_name_tmp_file),
shell=True)
server_utils.file_copy(Folder.caliper_run_log_file,
cmd_sec_name_tmp_file, 'a+')
if os.path.exists(cmd_sec_name_tmp_file):
os.remove(cmd_sec_name_tmp_file)
except error.CmdError, e:
raise error.ServRunError(e.args[0], e.args[1])
except Exception, e:
logging.debug(e)
def parse_all_cases(kind_bench, bench_name, parser_file, dic, run_case_list):
"""
function: parse one benchmark which was selected in the configuration files
"""
try:
# get the abspath, which is filename of run config for the benchmark
# get the config sections for the benchmrk
bench_conf_file = os.path.join(kind_bench, 'main.yml')
# get the config sections for the benchmrk
pf = open(bench_conf_file, 'r')
values = yaml.load(pf.read())
sections_run = values[bench_name].keys()
except AttributeError as e:
raise AttributeError
except Exception:
raise
logging.debug("the sections to run are: %s" % sections_run)
if not os.path.exists(Folder.exec_dir):
os.mkdir(Folder.exec_dir)
log_bench = os.path.join(Folder.exec_dir, bench_name)
logfile = log_bench + "_output.log"
tmp_log_file = log_bench + "_output_tmp.log"
parser_result_file = log_bench + "_parser.log"
tmp_parser_file = log_bench + "_parser_tmp.log"
if os.path.exists(parser_result_file):
os.remove(parser_result_file)
# for each command in run config file, read the config for the benchmark
i = 0
for section in sections_run:
if section in run_case_list:
dic[bench_name][section] = {}
flag = 0
try:
parser = values[bench_name][section]['parser']
except Exception:
logging.debug("no value for the %s" % section)
continue
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
# parser the result in the tmp_log_file, the result is the output of
# running the command
try:
logging.debug("Parsering the result of command: %s" % section)
outfp = open(logfile, 'r')
infp = open(tmp_log_file, 'w')
# infp.write(re.findall("test start\s+%+(.*?)%+\s+test_end", outfp.read(), re.DOTALL)[sections_run.index(section) - i])
infp.write(re.findall(section + "\s+test start\s+%+(.*?)%+\s+test_end", outfp.read(), re.DOTALL)[-1])
infp.close()
outfp.close()
parser_result = parser_case(bench_name, parser_file,
parser, tmp_log_file,
tmp_parser_file, 'parser')
dic[bench_name][section]["type"] = type(parser_result)
dic[bench_name][section]["value"] = parser_result
except Exception, e:
logging.info("Error while parsing the result of \" %s \""
% section)
logging.info(e)
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
else:
server_utils.file_copy(parser_result_file, tmp_parser_file, "a+")
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
if (parser_result <= 0):
continue
else:
i += 1
continue
def parse_all_cases(target_exec_dir, target, kind_bench, bench_name, run_file,
parser_file, dic):
"""
function: run one benchmark which was selected in the configuration files
"""
try:
# get the abspath, which is filename of run config for the benchmark
bench_conf_file = os.path.join(caliper_path.config_files.tests_cfg_dir,
kind_bench, run_file)
# get the config sections for the benchmrk
configRun, sections_run = server_utils.read_config_file(
bench_conf_file)
except AttributeError as e:
raise AttributeError
except Exception:
raise
logging.debug("the sections to run are: %s" % sections_run)
if not os.path.exists(Folder.exec_dir):
os.mkdir(Folder.exec_dir)
log_bench = os.path.join(Folder.exec_dir, bench_name)
logfile = log_bench + "_output.log"
tmp_log_file = log_bench + "_output_tmp.log"
parser_result_file = log_bench + "_parser.log"
tmp_parser_file = log_bench + "_parser_tmp.log"
if os.path.exists(parser_result_file):
os.remove(parser_result_file)
#output_logs_names = glob.glob(Folder.exec_dir+"/*output.log")
bench_test = "ltp"
# for each command in run config file, read the config for the benchmark
for i in range(0, len(sections_run)):
dic[bench_name][sections_run[i]] = {}
flag = 0
try:
category = configRun.get(sections_run[i], 'category')
scores_way = configRun.get(sections_run[i], 'scores_way')
parser = configRun.get(sections_run[i], 'parser')
command = configRun.get(sections_run[i], 'command')
except Exception:
logging.debug("no value for the %s" % sections_run[i])
continue
if bench_name == bench_test:
subsection = sections_run[i].split(" ")[1]
subsection_file = log_bench + "_" + subsection + "_output.log"
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
# parser the result in the tmp_log_file, the result is the output of
# running the command
try:
logging.debug("Parsering the result of command: %s" % command)
if bench_name == bench_test:
outfp = open(tmp_parser_file, "w")
outfp.write("%s" % (subsection))
outfp.close()
parser_result = parser_case(kind_bench, bench_name,
parser_file, parser,
subsection_file, tmp_parser_file)
else:
outfp = open(logfile, 'r')
infp = open(tmp_log_file, 'w')
infp.write(
re.findall("test start\s+%+(.*?)%+\s+test_end",
outfp.read(), re.DOTALL)[i])
infp.close()
outfp.close()
parser_result = parser_case(kind_bench, bench_name,
parser_file, parser, tmp_log_file,
tmp_parser_file)
dic[bench_name][sections_run[i]]["type"] = type(parser_result)
dic[bench_name][sections_run[i]]["value"] = parser_result
except Exception, e:
logging.info("Error while parsing the result of \" %s \"" %
sections_run[i])
logging.info(e)
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
else:
server_utils.file_copy(parser_result_file, tmp_parser_file, "a+")
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
if (parser_result <= 0):
continue
def run_all_cases(target_exec_dir, target, kind_bench, bench_name, run_file):
"""
function: run one benchmark which was selected in the configuration files
"""
try:
# get the abspath, which is filename of run config for the benchmark
bench_conf_file = os.path.join(caliper_path.config_files.tests_cfg_dir,
kind_bench, run_file)
# get the config sections for the benchmrk
configRun, sections_run = server_utils.read_config_file(
bench_conf_file)
except AttributeError as e:
raise AttributeError
except Exception:
raise
logging.debug("the sections to run are: %s" % sections_run)
if not os.path.exists(Folder.exec_dir):
os.mkdir(Folder.exec_dir)
log_bench = os.path.join(Folder.exec_dir, bench_name)
logfile = log_bench + "_output.log"
tmp_log_file = log_bench + "_output_tmp.log"
if os.path.exists(logfile):
os.remove(logfile)
starttime = datetime.datetime.now()
if os.path.exists(Folder.caliper_log_file):
sections = bench_name + " EXECUTION"
fp = open(Folder.caliper_log_file, "r")
f = fp.readlines()
fp.close()
op = open(Folder.caliper_log_file, "w")
for line in f:
if not (sections in line):
op.write(line)
op.close()
result = subprocess.call(
"echo '$$ %s EXECUTION START: %s' >> %s" %
(bench_name, str(starttime)[:19], Folder.caliper_log_file),
shell=True)
bench_test = "ltp"
if bench_name == bench_test:
tar_ip = settings.get_value('CLIENT', 'ip', type=str)
target.run(
"if [[ ! -e /mnt/caliper_nfs ]]; then mkdir -p /mnt/caliper_nfs; fi"
)
# fix me , now that we create the folder, why not we mount it directly here
try:
tar_mask = ".".join(tar_ip.split(".")[0:3])
p1 = subprocess.Popen(["ifconfig"], stdout=subprocess.PIPE)
p2 = subprocess.Popen(["grep", tar_mask],
stdin=p1.stdout,
stdout=subprocess.PIPE)
p1.stdout.close()
output, err = p2.communicate()
output = output.strip()
host_ip = output.split("inet addr:")[1].split(" ")[0]
except Exception:
logging.debug("Unable to get the host_ip")
try:
mount_cmd = target.run(
"mount -t nfs %s:/opt/caliper_nfs /mnt/caliper_nfs" %
(host_ip))
except Exception:
try:
umount_cmd = target.run("umount /mnt/caliper_nfs/")
mount_cmd = target.run(
"mount -t nfs %s:/opt/caliper_nfs /mnt/caliper_nfs" %
(host_ip))
except Exception:
logging.debug("Unable to mount")
return result
readme_file = log_bench + "_README"
resultltp = subprocess.call("touch %s" % (readme_file), shell=True)
resultltp = subprocess.call(
"echo 'The categorization of ltp in caliper is\nCATEGORY\t\t\t\t\t\tSCENARIOS OF LTP\n\n[command]\t\t\t\t\t\tcommands\n[cpu]\t\t\t\t\t\tsched,cpuhotplug\n[memory]\t\t\t\t\t\tmm.numa,hugetlb\n[dio]\t\t\t\t\t\tdio,io,dma_thread_diotest,timers\n[filesystem]\t\t\t\t\t\tfilecaps,fs,fs_bind,fs_ext4,fs_perms_simple,fs_readonly\n[kernel/\t\t\t\t\t\tsyscalls,controllers,pty,containers,admin_tools,modules,can\n[proc]\t\t\t\t\t\tipc,hyperthreading,nptl,cap_bounds,connectors,pipes\n\n\nltp_output.log contains the screenshot of complete ltp execution and ltp_parser.log contains the information regarding the number of tests executed and among them which all have passed failed or skipped.\n\nFor more information regarding a particular category please see ltp_<category>_output.log which contains the output screen and parser log for that particular category' >> %s"
% (readme_file),
shell=True)
# for each command in run config file, read the config for the benchmark
for i in range(0, len(sections_run)):
flag = 0
try:
category = configRun.get(sections_run[i], 'category')
command = configRun.get(sections_run[i], 'command')
except Exception:
logging.debug("no value for the %s" % sections_run[i])
continue
if bench_name == bench_test:
subsection = sections_run[i].split(" ")[1]
subsection_file = log_bench + "_" + subsection + "_output.log"
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
server_run_command = get_server_command(kind_bench, sections_run[i])
logging.debug("Get the server command is: %s" % server_run_command)
# run the command of the benchmarks
try:
flag = run_kinds_commands(sections_run[i], server_run_command,
tmp_log_file, kind_bench, target,
command)
except Exception, e:
logging.info(e)
crash_handle.main()
if bench_name == bench_test:
move_logs = subprocess.call(
"cp /opt/caliper_nfs/ltp_log/* %s " % (Folder.exec_dir),
shell=True)
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
continue
else:
return result
else:
if bench_name == bench_test:
move_logs = subprocess.call(
"cp /opt/caliper_nfs/ltp_log/* %s " % (Folder.exec_dir),
shell=True)
if os.path.exists(subsection_file):
server_utils.file_copy(tmp_log_file, subsection_file, 'a+')
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if flag != 1:
logging.info("There is wrong when running the command \"%s\"" %
command)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
crash_handle.main()
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
if bench_name != bench_test:
continue
else:
return result
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
def run_all_cases(self, kind_bench, bench_name, run_case_list):
"""
function: run one benchmark which was selected in the configuration files
"""
try:
# get the abspath, which is filename of run config for the benchmark
bench_conf_file = os.path.join(kind_bench, 'main.yml')
# get the config sections for the benchmrk
pf = open(bench_conf_file, 'r')
values = yaml.load(pf.read())
sections_run = values[bench_name].keys()
except AttributeError as e:
raise AttributeError
except Exception:
raise
logging.debug("the sections to run are: %s" % sections_run)
if not os.path.exists(Folder.exec_dir):
os.mkdir(Folder.exec_dir)
log_bench = os.path.join(Folder.exec_dir, bench_name)
logfile = log_bench + "_output.log"
tmp_log_file = log_bench + "_output_tmp.log"
if os.path.exists(logfile):
os.remove(logfile)
starttime = datetime.datetime.now()
if os.path.exists(Folder.caliper_log_file):
sections = bench_name + " EXECUTION"
fp = open(Folder.caliper_log_file, "r")
f = fp.readlines()
fp.close()
op = open(Folder.caliper_log_file, "w")
for line in f:
if not (sections in line):
op.write(line)
op.close()
result = subprocess.call(
"echo '$$ %s EXECUTION START: %s' >> %s" %
(bench_name, str(starttime)[:19], Folder.caliper_log_file),
shell=True)
# for each command in run config file, read the config for the benchmark
for section in sections_run:
if section in run_case_list:
if self.num == 0:
config_files = os.path.join(
caliper_path.config_files.config_dir,
'cases_config.json')
fp = open(config_files, 'r')
case_list = yaml.load(fp.read())
for dimension in case_list:
for i in range(len(case_list[dimension])):
for tool in case_list[dimension][i]:
for case in case_list[dimension][i][tool]:
if case == section:
self.num = case_list[dimension][i][
tool][case][-1]
flag = 0
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
# run the command of the benchmarks
try:
for j in range(int(self.num)):
flag = self.run_client_command(section, tmp_log_file,
bench_name)
except Exception, e:
logging.info(e)
crash_handle.main()
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
continue
else:
return result
else:
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if flag != 1:
logging.info(
"There is wrong when running the command \"%s\"" %
section)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
crash_handle.main()
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
return result
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
else:
continue
endtime = datetime.datetime.now()
subprocess.call(
"echo '$$ %s EXECUTION STOP: %s' >> %s" %
(section, str(endtime)[:19], Folder.caliper_log_file),
shell=True)
subprocess.call(
"echo '$$ %s EXECUTION DURATION %s Seconds'>>%s" %
(section,
(endtime - starttime).seconds, Folder.caliper_log_file),
shell=True)
def run_all_cases(target_exec_dir, target, kind_bench, bench_name, run_file,
parser_file):
"""
function: run one benchmark which was selected in the configuration files
"""
try:
# get the abspath, which is filename of run config for the benchmark
bench_conf_file = os.path.join(caliper_path.config_files.tests_cfg_dir,
kind_bench, run_file)
# get the config sections for the benchmrk
configRun, sections_run = server_utils.read_config_file(
bench_conf_file)
except AttributeError as e:
raise AttributeError
except Exception:
raise
logging.debug("the sections to run are: %s" % sections_run)
if not os.path.exists(Folder.exec_dir):
os.mkdir(Folder.exec_dir)
log_bench = os.path.join(Folder.exec_dir, bench_name)
logfile = log_bench + "_output.log"
tmp_log_file = log_bench + "_output_tmp.log"
parser_result_file = log_bench + "_parser.log"
tmp_parser_file = log_bench + "_parser_tmp.log"
if os.path.exists(parser_result_file):
os.remove(parser_result_file)
if os.path.exists(logfile):
os.remove(logfile)
starttime = datetime.datetime.now()
result = subprocess.call(
"echo '$$ %s EXECUTION START: %s' >> %s" %
(bench_name, str(starttime)[:19], Folder.caliper_log_file),
shell=True)
bench_test = "ltp"
if bench_name == bench_test:
tar_ip = settings.get_value('CLIENT', 'ip', type=str)
target.run("if [[ ! -e /mnt/ltp ]]; then mkdir -p /mnt/ltp; fi")
# fix me , now that we create the folder, why not we mount it directly here
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
# fix me , getting host ip to be optimised
s.connect(("8.8.8.8", 80))
except Exception:
logging.debug(
"Socket connection failed during ltp pre-requisite check")
host_ip = s.getsockname()[0]
try:
xyz = target.run("mount -t nfs %s:/opt/caliper_nfs /mnt/ltp" %
(host_ip))
except Exception:
try:
xyz = target.run("umount /mnt/ltp/")
xyz = target.run("mount -t nfs %s:/opt/caliper_nfs /mnt/ltp" %
(host_ip))
except Exception:
logging.debug("Unable to mount")
return result
readme_file = log_bench + "_README"
resultltp = subprocess.call("touch %s" % (readme_file), shell=True)
resultltp = subprocess.call(
"echo 'The categorization of ltp in caliper is\nCATEGORY\t\t\t\t\t\tSCENARIOS OF LTP\n\n[command]\t\t\t\t\t\tcommands\n[cpu]\t\t\t\t\t\tsched,cpuhotplug\n[memory]\t\t\t\t\t\tmm.numa,hugetlb\n[dio]\t\t\t\t\t\tdio,io,dma_thread_diotest,timers\n[filesystem]\t\t\t\t\t\tfilecaps,fs,fs_bind,fs_ext4,fs_perms_simple,fs_readonly\n[kernel/\t\t\t\t\t\tsyscalls,controllers,pty,containers,admin_tools,modules,can\n[proc]\t\t\t\t\t\tipc,hyperthreading,nptl,cap_bounds,connectors,pipes\n\n\nltp_output.log contains the screenshot of complete ltp execution and ltp_parser.log contains the information regarding the number of tests executed and among them which all have passed failed or skipped.\n\nFor more information regarding a particular category please see ltp_<category>_output.log which contains the output screen and parser log for that particular category' >> %s"
% (readme_file),
shell=True)
# for each command in run config file, read the config for the benchmark
for i in range(0, len(sections_run)):
flag = 0
try:
category = configRun.get(sections_run[i], 'category')
scores_way = configRun.get(sections_run[i], 'scores_way')
parser = configRun.get(sections_run[i], 'parser')
command = configRun.get(sections_run[i], 'command')
except Exception:
logging.debug("no value for the %s" % sections_run[i])
continue
if bench_name == bench_test:
subsection = sections_run[i].split(" ")[1]
subsection_file = log_bench + "_" + subsection + "_output.log"
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
server_run_command = get_server_command(kind_bench, sections_run[i])
logging.debug("Get the server command is: %s" % server_run_command)
# run the command of the benchmarks
try:
flag = run_kinds_commands(sections_run[i], server_run_command,
tmp_log_file, kind_bench, target,
command)
except Exception, e:
logging.info(e)
crash_handle.main()
if bench_name == bench_test:
xyz = subprocess.call("mv /opt/caliper_nfs/ltp_log/* %s " %
(Folder.exec_dir),
shell=True)
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
continue
else:
return result
else:
if bench_name == bench_test:
xyz = subprocess.call("mv /opt/caliper_nfs/ltp_log/* %s " %
(Folder.exec_dir),
shell=True)
if os.path.exists(subsection_file):
server_utils.file_copy(tmp_log_file, subsection_file, 'a+')
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if flag != 1:
logging.info("There is wrong when running the command \"%s\"" %
command)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
crash_handle.main()
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
if bench_name != bench_test:
continue
else:
return result
# parser the result in the tmp_log_file, the result is the output of
# running the command
try:
logging.debug("Parsering the result of command: %s" % command)
if bench_name == bench_test:
outfp = open(tmp_parser_file, "w")
outfp.write("%s" % (subsection))
outfp.close()
parser_result = parser_case(kind_bench, bench_name,
parser_file, parser,
subsection_file, tmp_parser_file)
else:
parser_result = parser_case(kind_bench, bench_name,
parser_file, parser, tmp_log_file,
tmp_parser_file)
except Exception, e:
logging.info(
"There's wrong when parsering the result of \" %s \"" %
sections_run[i])
logging.info(e)
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
subsection_file, tmp_parser_file)
else:
parser_result = parser_case(kind_bench, bench_name,
parser_file, parser, tmp_log_file,
tmp_parser_file)
except Exception, e:
logging.info(
"There's wrong when parsering the result of \" %s \"" %
sections_run[i])
logging.info(e)
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
else:
server_utils.file_copy(parser_result_file, tmp_parser_file, "a+")
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
if (parser_result <= 0):
continue
# according the method in the config file, compute the score
try:
logging.debug("Computing the score of the result of command: %s" %
command)
flag_compute = compute_case_score(parser_result, category,
scores_way, target)
except Exception, e:
logging.info(e)
def parse_all_cases(target_exec_dir, target, kind_bench, bench_name,
run_file,parser_file,dic):
"""
function: run one benchmark which was selected in the configuration files
"""
try:
# get the abspath, which is filename of run config for the benchmark
bench_conf_file = os.path.join(
caliper_path.config_files.tests_cfg_dir,
kind_bench, run_file)
# get the config sections for the benchmrk
configRun, sections_run = server_utils.read_config_file(
bench_conf_file)
except AttributeError as e:
raise AttributeError
except Exception:
raise
bench_test = "ltp"
logging.debug("the sections to run are: %s" % sections_run)
if not os.path.exists(Folder.exec_dir):
os.mkdir(Folder.exec_dir)
log_bench = os.path.join(Folder.exec_dir, bench_name)
logfile = log_bench + "_output.log"
if bench_name != bench_test:
if not os.path.exists(logfile):
return -1
tmp_log_file = log_bench + "_output_tmp.log"
parser_result_file = log_bench + "_parser.log"
tmp_parser_file = log_bench + "_parser_tmp.log"
if os.path.exists(parser_result_file):
os.remove(parser_result_file)
#output_logs_names = glob.glob(Folder.exec_dir+"/*output.log")
# for each command in run config file, read the config for the benchmark
for i in range(0, len(sections_run)):
dic[bench_name][sections_run[i]] = {}
flag = 0
try:
category = configRun.get(sections_run[i], 'category')
scores_way = configRun.get(sections_run[i], 'scores_way')
parser = configRun.get(sections_run[i], 'parser')
command = configRun.get(sections_run[i], 'command')
except Exception:
logging.debug("no value for the %s" % sections_run[i])
continue
if bench_name == bench_test:
subsection = sections_run[i].split(" ")[1]
subsection_file = log_bench + "_" + subsection + "_output.log"
if not os.path.exists(subsection_file):
continue
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
# parser the result in the tmp_log_file, the result is the output of
# running the command
try:
logging.debug("Parsering the result of command: %s" % command)
if bench_name == bench_test:
outfp = open(tmp_parser_file, "w")
outfp.write("%s" %(subsection))
outfp.close()
parser_result = parser_case(kind_bench, bench_name, parser_file,
parser, subsection_file,
tmp_parser_file)
else:
outfp = open(logfile, 'r')
infp = open(tmp_log_file, 'w')
infp.write(re.findall("test start\s+%+(.*?)%+\s+test_end", outfp.read(), re.DOTALL)[i])
infp.close()
outfp.close()
parser_result = parser_case(kind_bench, bench_name, parser_file,
parser,tmp_log_file,
tmp_parser_file)
dic[bench_name][sections_run[i]]["type"] = type(parser_result)
dic[bench_name][sections_run[i]]["value"] = parser_result
except Exception, e:
logging.info("Error while parsing the result of \" %s \""
% sections_run[i])
logging.info(e)
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
else:
server_utils.file_copy(parser_result_file, tmp_parser_file, "a+")
if os.path.exists(tmp_parser_file):
os.remove(tmp_parser_file)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
if (parser_result <= 0):
continue
def run_all_cases(target_exec_dir, target, kind_bench, bench_name,
run_file):
"""
function: run one benchmark which was selected in the configuration files
"""
try:
# get the abspath, which is filename of run config for the benchmark
bench_conf_file = os.path.join(
caliper_path.config_files.tests_cfg_dir,
kind_bench, run_file)
# get the config sections for the benchmrk
configRun, sections_run = server_utils.read_config_file(
bench_conf_file)
except AttributeError as e:
raise AttributeError
except Exception:
raise
logging.debug("the sections to run are: %s" % sections_run)
if not os.path.exists(Folder.exec_dir):
os.mkdir(Folder.exec_dir)
log_bench = os.path.join(Folder.exec_dir, bench_name)
logfile = log_bench + "_output.log"
tmp_log_file = log_bench + "_output_tmp.log"
if os.path.exists(logfile):
os.remove(logfile)
starttime = datetime.datetime.now()
if os.path.exists(Folder.caliper_log_file):
sections = bench_name + " EXECUTION"
fp = open(Folder.caliper_log_file,"r")
f = fp.readlines()
fp.close()
op = open(Folder.caliper_log_file,"w")
for line in f:
if not(sections in line):
op.write(line)
op.close()
result = subprocess.call("echo '$$ %s EXECUTION START: %s' >> %s"
% (bench_name,
str(starttime)[:19],
Folder.caliper_log_file),
shell=True)
bench_test = "ltp"
if bench_name == bench_test:
tar_ip = settings.get_value('CLIENT', 'ip', type=str)
target.run("if [[ ! -e /mnt/caliper_nfs ]]; then mkdir -p /mnt/caliper_nfs; fi")
# fix me , now that we create the folder, why not we mount it directly here
try:
tar_mask = ".".join(tar_ip.split(".")[0:3])
p1 = subprocess.Popen(["ifconfig"], stdout=subprocess.PIPE)
p2 = subprocess.Popen(["grep", tar_mask], stdin=p1.stdout, stdout=subprocess.PIPE)
p1.stdout.close()
output,err = p2.communicate()
output = output.strip()
host_ip = output.split("inet addr:")[1].split(" ")[0]
except Exception:
logging.debug("Unable to get the host_ip" )
try:
mount_cmd = target.run("mount -t nfs %s:/opt/caliper_nfs /mnt/caliper_nfs" % (host_ip) )
except Exception:
try:
umount_cmd = target.run("umount /mnt/caliper_nfs/")
mount_cmd = target.run("mount -t nfs %s:/opt/caliper_nfs /mnt/caliper_nfs" % (host_ip) )
except Exception:
logging.debug("Unable to mount")
return result
readme_file=log_bench+"_README"
resultltp = subprocess.call("touch %s"
%(readme_file),shell=True)
resultltp = subprocess.call("echo 'The categorization of ltp in caliper is\nCATEGORY\t\t\t\t\t\tSCENARIOS OF LTP\n\n[command]\t\t\t\t\t\tcommands\n[cpu]\t\t\t\t\t\tsched,cpuhotplug\n[memory]\t\t\t\t\t\tmm.numa,hugetlb\n[dio]\t\t\t\t\t\tdio,io,dma_thread_diotest,timers\n[filesystem]\t\t\t\t\t\tfilecaps,fs,fs_bind,fs_ext4,fs_perms_simple,fs_readonly\n[kernel/\t\t\t\t\t\tsyscalls,controllers,pty,containers,admin_tools,modules,can\n[proc]\t\t\t\t\t\tipc,hyperthreading,nptl,cap_bounds,connectors,pipes\n\n\nltp_output.log contains the screenshot of complete ltp execution and ltp_parser.log contains the information regarding the number of tests executed and among them which all have passed failed or skipped.\n\nFor more information regarding a particular category please see ltp_<category>_output.log which contains the output screen and parser log for that particular category' >> %s"
%(readme_file),shell=True)
# for each command in run config file, read the config for the benchmark
for i in range(0, len(sections_run)):
flag = 0
try:
category = configRun.get(sections_run[i], 'category')
command = configRun.get(sections_run[i], 'command')
except Exception:
logging.debug("no value for the %s" % sections_run[i])
continue
if bench_name == bench_test:
subsection = sections_run[i].split(" ")[1]
subsection_file = log_bench + "_" + subsection + "_output.log"
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
server_run_command = get_server_command(kind_bench, sections_run[i])
logging.debug("Get the server command is: %s" % server_run_command)
# run the command of the benchmarks
try:
flag = run_kinds_commands(sections_run[i], server_run_command,
tmp_log_file, kind_bench,
target, command)
except Exception, e:
logging.info(e)
crash_handle.main()
if bench_name == bench_test:
move_logs = subprocess.call("cp /opt/caliper_nfs/ltp_log/* %s "
% (Folder.exec_dir), shell=True)
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
continue
else:
return result
else:
if bench_name == bench_test:
move_logs = subprocess.call("cp /opt/caliper_nfs/ltp_log/* %s "
% (Folder.exec_dir), shell=True)
if os.path.exists(subsection_file):
server_utils.file_copy(tmp_log_file,subsection_file, 'a+')
server_utils.file_copy(logfile, tmp_log_file, 'a+')
if flag != 1:
logging.info("There is wrong when running the command \"%s\""
% command)
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
crash_handle.main()
run_flag = server_utils.get_fault_tolerance_config(
'fault_tolerance', 'run_error_continue')
if run_flag == 1:
if bench_name != bench_test:
continue
else:
return result
if os.path.exists(tmp_log_file):
os.remove(tmp_log_file)
