def _judge_single(self, test_case):
# test case input and output path
in_file_path = os.path.join(self._test_cases_dir, test_case['in'])
out_file_path = os.path.join(self._test_cases_dir, test_case['out'])
# run test case output path & run test case error path
run_out_file_path = os.path.join(self._runner_path, test_case['out'])
run_out_err_path = os.path.join(
self._runner_path, test_case['in'] + '.err')
command = self._run_config["command"].format(exe_path=self._exe_path, exe_dir=self._runner_path,
max_memory=int(self._memory_limit * 1024)).split(" ")
runner_env = ["PATH=" + os.environ.get("PATH", "")] + self._run_config.get("env", [])
seccomp_rule = self._run_config.get("seccomp_rule")
run_result = runner.run(max_cpu_time=self._time_limit * 3,
max_real_time=self._time_limit * 3,
max_memory=self._memory_limit * 1024 * 1024,
max_stack=128 * 1024 * 1024,
max_output_size=1024 * 1024 * 16,
max_process_number=UNLIMITED,
exe_path=command[0],
args=command[1::],
env=runner_env,
input_path=in_file_path,
output_path=run_out_file_path,
error_path=run_out_err_path,
log_path=self._run_log,
seccomp_rule_name=seccomp_rule,
uid=RUN_USER_UID,
gid=RUN_GROUP_GID,
memory_limit_check_only=self._run_config.get("memory_limit_check_only", 0))
run_result['memory'] = run_result['memory'] // 1024 // 1024
logger.debug(run_result)
if run_result["result"] != Result.RESULT_SUCCESS:
return run_result
if self._spj:
spj_run_result = self._judge_single_spj(
in_file_path, out_file_path, run_out_file_path, test_case)
if spj_run_result['exit_code'] == 0:
run_result['result'] = spj_run_result['result']
elif spj_run_result['exit_code'] == 1:
run_result['result'] = Result.RESULT_WRONG_ANSWER
else:
run_result['result'] = Result.RESULT_SYSTEM_ERROR
else:
if not os.path.exists(run_out_file_path):
run_result["result"] = Result.RESULT_WRONG_ANSWER
else:
run_result["result"] = Runner.diff(
standard_path=out_file_path, output_path=run_out_file_path)
return run_result
def make_engine(connection_str=None, host_name=None, db_name=None):
logger.debug(settings['db_connection']['db'])
DEFAULT_DB_NAME = settings['db_connection']['db']
DEFAULT_DB_SERVER = settings['db_connection']['host']
connection=None
if db_name is None:
database_name = DEFAULT_DB_NAME
else:
database_name = db_name
if connection_str is None:
conn_str = "DRIVER={SQL Server}; SERVER=" + DEFAULT_DB_SERVER + "; DATABASE=" + str(database_name)
else:
conn_str = connection_str + str(database_name)
params = urllib.parse.quote_plus("DRIVER={SQL Server};SERVER=VIDEADDQASPRC03;DATABASE=VideaSuperSnapshot")
engine = sqlalchemy.create_engine("mssql+pyodbc:///?odbc_connect=%s" % params)
return engine
def compile(self):
if self._spj:
self._compile_spj()
compile_config = self._language_config['compile']
command = compile_config["compile_command"]
command = command.format(
src_path=self._src_path, exe_dir=self._runner_path, exe_path=self._exe_path)
_command = command.split(" ")
os.chdir(self._runner_path)
runner_env = ["PATH=" + os.environ.get("PATH", "")] + self._compile_config.get("env", [])
if os.getenv("JAVA_OPTS"):
runner_env.append(f'JAVA_OPTS={os.getenv("JAVA_OPTS")}')
result = runner.run(max_cpu_time=compile_config["max_cpu_time"],
max_real_time=compile_config["max_real_time"],
max_memory=compile_config["max_memory"],
max_stack=128 * 1024 * 1024,
max_output_size=20 * 1024 * 1024,
max_process_number=UNLIMITED,
exe_path=_command[0],
input_path=self._src_path,
output_path=self._compiler_out,
error_path=self._compiler_out,
args=_command[1::],
env=runner_env,
log_path=self._compiler_log,
seccomp_rule_name=None,
uid=RUN_USER_UID,
gid=RUN_GROUP_GID)
logger.debug('compile result:' + str(result))
os.chdir(self._original_dir)
if result["result"] != Result.RESULT_SUCCESS:
if os.path.exists(self._compiler_out):
with open(self._compiler_out, encoding="utf-8") as f:
error = f.read().strip()
logger.debug(error)
if error:
raise CompileError(error)
raise CompileError(
"Compiler runtime error, info: \n%s\n" % json.dumps(result))
else:
return result
def _judge_single_spj(self, input_path, output_path, user_output_path, test_case):
# 将test case拷贝到运行目录下面，并且分配权限
spj_in_file_path = os.path.join(self._runner_path, test_case['in'])
spj_out_file_path = os.path.join(self._runner_path, test_case['out'])
shutil.copyfile(input_path, spj_in_file_path)
shutil.copyfile(output_path, spj_out_file_path)
os.chown(spj_in_file_path, RUN_USER_UID, RUN_GROUP_GID)
os.chown(spj_out_file_path, RUN_USER_UID, RUN_GROUP_GID)
command = self._spj_config['run']['command'].format(exe_path=self._spj_exe_path,
in_file_path=spj_in_file_path,
out_file_path=spj_out_file_path,
user_out_file_path=user_output_path).split(" ")
runner_env = ["PATH=" + os.environ.get("PATH", "")]
if os.getenv("JAVA_OPTS"):
runner_env.append(f'JAVA_OPTS={os.getenv("JAVA_OPTS")}')
seccomp_rule = self._spj_config['run']["seccomp_rule"]
in_file_path = os.path.join(self._test_cases_dir, test_case['in'])
# run test case output path & run test case error path
run_out_file_path = os.path.join(self._runner_path, test_case['out'] + '.spj.out')
run_out_err_path = os.path.join(self._runner_path, test_case['out'] + '.spj.err')
run_result = runner.run(max_cpu_time=self._time_limit * 3,
max_real_time=self._time_limit * 3,
max_memory=self._memory_limit * 1024 * 1024,
max_stack=128 * 1024 * 1024,
max_output_size=1024 * 1024 * 16,
max_process_number=UNLIMITED,
exe_path=command[0],
args=command[1::],
env=runner_env,
input_path=in_file_path,
output_path=run_out_file_path,
error_path=run_out_err_path,
log_path=self._run_log,
seccomp_rule_name=seccomp_rule,
uid=RUN_USER_UID,
gid=RUN_GROUP_GID,
memory_limit_check_only=self._run_config.get("memory_limit_check_only", 0))
logger.debug(run_result)
return run_result
def _compile_spj(self):
compile_config = self._spj_config['compile']
command = compile_config['compile_command']
command = command.format(
src_path=self._spj_src_path, exe_path=self._spj_exe_path)
_command = command.split(' ')
os.chdir(self._runner_path)
runner_env = compile_config.get("env", [])
runner_env.append("PATH=" + os.getenv("PATH"))
if os.getenv("JAVA_OPTS"):
runner_env.append("JAVA_OPTS=" + os.getenv("JAVA_OPTS"))
spj_compile_result = runner.run(max_cpu_time=compile_config['max_cpu_time'],
max_real_time=compile_config['max_real_time'],
max_memory=compile_config['max_memory'],
max_stack=128 * 1024 * 1024,
max_output_size=20 * 1024 * 1024,
max_process_number=UNLIMITED,
exe_path=_command[0],
input_path=self._spj_src_path,
output_path=self._compiler_spj_out,
error_path=self._compiler_spj_out,
args=_command[1::],
env=runner_env,
log_path=self._compiler_log,
seccomp_rule_name=None,
uid=RUN_USER_UID,
gid=RUN_GROUP_GID)
logger.debug(spj_compile_result)
if spj_compile_result["result"] != Result.RESULT_SUCCESS:
if os.path.exists(self._compiler_out):
with open(self._compiler_out, encoding="utf-8") as f:
error = f.read().strip()
if error:
raise CompileError('Compile spj error.\n' + error)
raise CompileError("Compile spj runtime error, info:\n%s" %
json.dumps(spj_compile_result))
def run_submission_task(submission_id, problem_id, manifest, code, language,
time_limit, memory_limit):
logger.debug(submission_id, problem_id, manifest, code, language,
time_limit, memory_limit)
result_submission_task.apply_async(args=[
submission_id, Verdict.RUNNING, None, None, {
'node': default_nodename(None)
}
],
queue='result')
if language not in ACCEPT_SUBMISSION_LANGUAGES:
logger.warning('request language not valid')
result_submission_task.apply_async(args=[
submission_id, Verdict.SYSTEM_ERROR, None, None, {
'error': f'language {language} not support',
'node': default_nodename(None)
}
],
queue='result')
# initialize runner
try:
validate_manifest(manifest)
except TestCaseError as test_case_error:
logger.debug(test_case_error)
if OJ_ENABLE_SYNC:
# sync test cases
result_submission_task.apply_async(args=[
submission_id, Verdict.SYNC_TEST_CASES, None, None, {
'node': default_nodename(None)
}
],
queue='result')
logger.debug("sync test cases")
try:
sync_test_cases(manifest['hash'], problem_id)
validate_manifest(manifest)
except ManifestError as e:
traceback.print_exc()
result_submission_task.apply_async(args=[
submission_id, Verdict.SYSTEM_ERROR, None, None, {
'error': str(e),
'node': default_nodename(None)
}
],
queue='result')
return
else:
# sync test cases disabled, return system error
result_submission_task.apply_async(args=[
submission_id, Verdict.SYSTEM_ERROR, None, None, {
'error': str(test_case_error),
'node': default_nodename(None)
}
],
queue='result')
except ManifestError as e:
logger.debug(e)
result_submission_task.apply_async(args=[
submission_id, Verdict.SYSTEM_ERROR, None, None, {
'error': str(e),
'node': default_nodename(None)
}
],
queue='result')
return
try:
runner = JudgeRunner(PROBLEM_TEST_CASES_DIR, manifest, time_limit,
memory_limit, code,
load_submission_config(language),
load_spj_config('c'))
except Exception as e:
result_submission_task.apply_async(args=[
submission_id, Verdict.SYSTEM_ERROR, None, None, {
'error': str(e),
'node': default_nodename(None)
}
],
queue='result')
return
# compile code
try:
res_compile = runner.compile()
logger.debug('compile result:' + str(res_compile))
except Exception as e:
logger.debug('compile error:' + str(e))
result_submission_task.apply_async(args=[
submission_id, Verdict.COMPILE_ERROR, None, None, {
'error': str(e),
'node': default_nodename(None)
}
],
queue='result')
return
# run code
try:
result = runner.run()
verdict = Verdict.ACCEPTED
# attention: time spend and memory spend indicated maximum case time spend and maximum case memory spend
time_cost = 0
memory_cost = 0
for item in result:
# calculate max time spend and memory spend
time_cost = max(time_cost, item['cpu_time'])
memory_cost = max(memory_cost, item['memory'])
if item['result'] != 0:
verdict = Verdict.VERDICT_MAPPING[item['result']]
break
result_submission_task.apply_async(args=[
submission_id, verdict, time_cost, memory_cost, {
'result': result,
'node': default_nodename(None)
}
],
queue='result')
except Exception as e:
traceback.print_exc()
result_submission_task.apply_async(args=[
submission_id, Verdict.SYSTEM_ERROR, None, None, {
'error': str(e),
'node': default_nodename(None)
}
],
queue='result')
return
try:
# clean running directory
runner.clean()
except OSError:
pass
async def load_dump(self, ctx, filename=None):
embed = discord.Embed()
embed.set_author(name=self.__bot.user.name,
url=settings.URL,
icon_url=self.__bot.user.avatar_url)
updated = []
if filename is None:
filename = "/members.dump.json"
try:
with open(filename, "r") as dump_file:
data = json.load(dump_file)
except OSError:
embed.colour = Colors.unauthorized
embed.title = "File not found!"
embed.description = "Be sure that you inserted the right " \
"filename and you have copied the file " \
"into the container!"
embed.timestamp = datetime.datetime.utcnow()
await ctx.send(embed=embed)
return
for member in data:
async with session_lock:
with Session() as session:
player_discord_id = member["player"]["discord_id"]
server_discord_id = member["server"]["discord_id"]
exp = int(member["exp"])
player = self.__bot.get_user(player_discord_id)
server = self.__bot.get_guild(server_discord_id)
db_player = crud_player.get_by_discord(
session, player_discord_id)
if db_player is None:
if player is None and "name" in member["player"]:
name = member["player"]["name"]
elif player is None and "name" not in member["player"]:
name = "UNKNOWN"
else:
name = player.name
db_player = crud_player.create(
session,
obj_in=CreatePlayer(
**{
"discord_id":
player_discord_id,
"name":
name,
"hidden":
"hidden" in member["player"]
and member["player"]["hidden"] == 1
}))
else:
hidden = "hidden" in member["player"] and \
member["player"]["hidden"] == 1
if hidden != db_player.hidden:
db_player = crud_player.update(
session,
db_obj=db_player,
obj_in={"hidden": hidden})
db_server = crud_server.get_by_discord(
session, server_discord_id)
if db_server is None:
if server is None and "name" in member["server"]:
name = member["server"]["name"]
elif server is None and "name" not in member["server"]:
name = "UNKNOWN"
else:
name = server.name
db_server = crud_server.create(
session,
obj_in=CreateServer(
**{
"discord_id": server_discord_id,
"name": name,
"server_exp": 0,
"channel": member["server"].get("channel")
}))
else:
if db_server.channel != member["server"]. \
get("channel"):
db_server = crud_server.update(
session,
db_obj=db_server,
obj_in={
"channel": member["server"].get("channel")
})
db_member = crud_member.get_by_ids(session, db_player.uuid,
db_server.uuid)
if "level_id" in member:
logger.debug(member["level_id"])
if "level_id" in member and member["level_id"] != "NULL":
current_level = int(member["level_id"])
else:
current_level = 0
current_level, exp = process_exp(current_level, exp)
if current_level > 0:
db_level = get_create(
session,
crud_level,
obj_in=CreateLevel(
**{
"value": current_level,
"exp": level_exp(current_level),
"title": None
}))
level_uuid = db_level.uuid
else:
level_uuid = None
if db_member is None:
db_member = crud_member.create(
session,
obj_in=CreateMember(
**{
"exp": exp,
"player_uuid": db_player.uuid,
"server_uuid": db_server.uuid,
"level_uuid": level_uuid
}))
else:
db_member = crud_member.update(session,
db_obj=db_member,
obj_in={
"level_uuid":
level_uuid,
"exp": exp
})
updated.append(db_member)
embed.colour = Colors.other
embed.title = "Members loaded from dump file."
embed.description = f"Members updated: {len(updated)}"
embed.timestamp = datetime.datetime.utcnow()
await ctx.send(embed=embed)
def run(max_cpu_time,
max_real_time,
max_memory,
max_stack,
max_output_size,
max_process_number,
exe_path,
input_path,
output_path,
error_path,
args,
env,
log_path,
seccomp_rule_name,
uid,
gid,
memory_limit_check_only=0):
str_list_vars = ["args", "env"]
int_vars = [
"max_cpu_time", "max_real_time", "max_memory", "max_stack",
"max_output_size", "max_process_number", "uid", "gid",
"memory_limit_check_only"
]
str_vars = [
"exe_path", "input_path", "output_path", "error_path", "log_path"
]
proc_args = ["ddlc"]
for var in str_list_vars:
value = vars()[var]
if not isinstance(value, list):
raise ValueError("{} must be a list".format(var))
for item in value:
if not isinstance(item, str):
raise ValueError("{} item must be a string".format(var))
proc_args.append("--{}={}".format(var, item))
for var in int_vars:
value = vars()[var]
if not isinstance(value, int):
raise ValueError("{} must be a int".format(var))
if value != UNLIMITED:
proc_args.append("--{}={}".format(var, value))
for var in str_vars:
value = vars()[var]
if not isinstance(value, str):
raise ValueError("{} must be a string".format(var))
proc_args.append("--{}={}".format(var, value))
if not isinstance(seccomp_rule_name,
str) and seccomp_rule_name is not None:
raise ValueError("seccomp_rule_name must be a string or None")
if seccomp_rule_name:
proc_args.append("--seccomp_rule={}".format(seccomp_rule_name))
logger.debug(' ||| '.join(proc_args))
proc = subprocess.Popen(proc_args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = proc.communicate()
logger.debug(out)
if err:
logger.error(err)
return json.loads(out.decode("utf-8"))