def Check_System_Error(self):
failure = JudgeServer_Manager.Get_Failure_Task()
if failure == None:
return
for x in failure:
Judge_Manager.update_status(x, 10)
return
def Start_Judge(self, Problem_ID, User, Code, Lang, Share):
self.Check_System_Error()
Judge_Manager.add_judge(Code, User, Problem_ID, Lang, unix_nano(),
Share)
self.Check_Queue()
return
def heartBeat():
Secret = request.form.get("Server_Secret")
if Secret == None:
return '-1'
if not JudgeServer_Manager.Check_Secret(Secret):
return '-1'
Last_Seen_Time = int(JudgeServer_Manager.Get_Last_Heartbeat(Secret))
if Last_Seen_Time < unix_nano() - JudgeConfig.Max_Duration:
url = JudgeServer_Manager.Get_URL(Secret)
for i in range(0, 3):
try:
data = {}
data['Server_Secret'] = JudgeConfig.Web_Server_Secret
re = requests.post(url + '/isBusy', data = data).content.decode() # Fixme: check self-signed SSL
if re == '0':
Faliure = JudgeServer_Manager.Get_Current_Task(Secret)
if Faliure != -1:
Judge_Manager.update_status(Faliure, 10)
JudgeServer_Manager.Flush_Busy(Secret, False)
else:
JudgeServer_Manager.Flush_Busy(Secret, True)
break
except:
pass
JudgeServer_Manager.Flush_Heartbeat(Secret, unix_nano())
JudgeServer_Scheduler.Check_Queue()
return '0'
def Check_Queue(self):
self.Check_System_Error()
Server = JudgeServer_Manager.Get_Standby_Server(
unix_nano() - JudgeConfig.Max_Duration)
# print(Server)
if Server == None or len(Server) == 0: # no avaliable server
return
Record = Judge_Manager.get_pending_judge(
) # ID, Problem_ID, Code, Language
if Record == None or len(Record) == 0:
return
data = {}
data['Server_Secret'] = JudgeConfig.Web_Server_Secret
data['Problem_ID'] = str(Record[1])
data['Judge_ID'] = str(Record[0])
data['Lang'] = 'cpp' if int(Record[3]) == 0 else 'git'
data['Code'] = Record[2]
for i in range(0, 3):
re = requests.post(
Server[0] + '/judge',
data=data).content.decode() # Fixme: check self-signed SSL
if re == '0':
Judge_Manager.update_status(int(Record[0]), 1)
JudgeServer_Manager.Flush_Busy(Server[1], True, int(Record[0]))
break
return
def code():
if not Login_Manager.check_user_status(): # not login
return redirect('login?next=' + request.full_path)
if not str(request.args.get('submit_id')).isdigit(): # bad argument
abort(404)
run_id = int(request.args.get('submit_id'))
if run_id < 0 or run_id > Judge_Manager.max_id():
abort(404)
detail = Judge_Manager.query_judge(run_id)
if detail['User'] != Login_Manager.get_username(
) and Login_Manager.get_privilege() < Privilege.SUPER and (
not detail['Share']
or Problem_Manager.in_contest(detail['Problem_ID'])):
return abort(403)
else:
detail['Friendly_Name'] = User_Manager.get_friendly_name(
detail['User'])
detail['Problem_Title'] = Problem_Manager.get_title(
detail['Problem_ID'])
detail['Lang'] = readable_lang(detail['Lang'])
detail['Time'] = readable_time(int(detail['Time']))
data = None
if detail['Detail'] != 'None':
temp = json.loads(detail['Detail'])
detail['Score'] = int(temp[1])
data = temp[4:]
else:
detail['Score'] = 0
return render_template(
'judge_detail.html',
Detail=detail,
Data=data,
friendlyName=Login_Manager.get_friendly_name(),
is_Admin=Login_Manager.get_privilege() >= Privilege.ADMIN)
def Error_Check_Correct(self, Mintime: int):
db = db_connect()
cursor = db.cursor()
cursor.execute(
"SELECT Address, Secret_Key, Current_Task FROM Judge_Server WHERE Last_Seen_Time >= %s AND Busy = %s",
(str(Mintime), '1'))
ret = cursor.fetchall()
db.close()
if ret == None or len(ret) == 0: # nothing to do
return
for x in ret:
url = x[0]
Secret = x[1]
Current_Task = x[2]
for i in range(0, 3):
try:
data = {}
data['Server_Secret'] = JudgeConfig.Web_Server_Secret
re = requests.post(url + '/isBusy',
data=data).content.decode(
) # Fixme: check self-signed SSL
if re == '0':
JudgeServer_Manager.Flush_Busy(Secret, False)
Judge_Manager.update_after_judge(
Current_Task, 9) # set system error for fake busy
break
except:
pass
def Receive_Judge_Result(self, Secret: str, Judge_ID: int, Result: str):
self.Check_System_Error()
JudgeServer_Manager.Flush_Busy(Secret, False)
x = json.loads(Result)
# print(x[0])
Judge_Manager.update_after_judge(Judge_ID, int(x[0]), x[1], Result,
x[3], x[2])
JudgeServer_Manager.Flush_Busy(Secret, False)
self.Check_Queue()
return
def problem_rank():
if not Login_Manager.check_user_status():
return redirect('login?next=' + request.full_path)
problem_id = request.args.get('problem_id')
if problem_id is None:
abort(404)
sort_parameter = request.args.get('sort')
record = Judge_Manager.search_ac(problem_id)
if sort_parameter == 'memory':
record = sorted(record, key=lambda x: x[3])
elif sort_parameter == 'submit_time':
record = sorted(record, key=lambda x: x[5])
else:
sort_parameter = 'time'
record = sorted(record, key=lambda x: x[2])
return render_template(
'problem_rank.html',
Problem_ID=problem_id,
Title=Problem_Manager.get_title(problem_id),
Data=record,
Sorting=sort_parameter,
friendlyName=Login_Manager.get_friendly_name(),
readable_lang=readable_lang,
readable_time=readable_time,
is_Admin=Login_Manager.get_privilege() >= Privilege.ADMIN)
def get_code():
if not Login_Manager.check_user_status():
return '-1'
arg = request.form.get('submit_id')
if arg is None:
return '-1'
if not str(request.form.get('submit_id')).isdigit(): # bad argument
return '-1'
run_id = int(request.form.get('submit_id'))
if run_id < 0 or run_id > Judge_Manager.max_id():
return '-1'
detail = Judge_Manager.query_judge(run_id)
if detail['User'] != Login_Manager.get_username(
) and Login_Manager.get_privilege() < Privilege.SUPER and (
not detail['Share']
or Problem_Manager.in_contest(detail['Problem_ID'])):
return '-1'
return detail['Code']
def Set_Offline(self, Secret: str):
db = db_connect()
cursor = db.cursor()
try:
cursor.execute(
"UPDATE Judge_Server SET Last_Seen_Time = %s WHERE Secret_Key = %s",
('0', Secret))
db.commit()
except:
db.rollback()
sys.stderr.write("SQL Error in JudgeServerManager: Set_Offline\n")
cursor.execute(
"SELECT Current_Task FROM Judge_Server WHERE Secret_Key = %s",
(Secret))
Current_Task = cursor.fetchone()
if (str(Current_Task) != '-1'):
Judge_Manager.update_after_judge(Current_Task, 9)
db.close()
return
def homework():
if not Login_Manager.check_user_status():
return redirect('login?next=' + request.full_path)
contest_id = request.args.get('homework_id')
username = Login_Manager.get_username()
if contest_id is None: # display contest list
contest_list = Contest_Manager.list_contest(1)
data = []
cur_time = unix_nano()
for ele in contest_list:
cur = {
'ID': int(ele[0]),
'Title': str(ele[1]),
'Start_Time': readable_time(int(ele[2])),
'End_Time': readable_time(int(ele[3])),
'Joined':
Contest_Manager.check_player_in_contest(ele[0], username),
'Blocked': unix_nano() > int(ele[3])
}
if cur_time < int(ele[2]):
cur['Status'] = 'Pending'
elif cur_time > int(ele[3]):
cur['Status'] = 'Finished'
else:
cur['Status'] = 'Going On'
data.append(cur)
return render_template(
'homework_list.html',
Data=data,
friendlyName=Login_Manager.get_friendly_name(),
is_Admin=Login_Manager.get_privilege() >= Privilege.ADMIN)
else:
contest_id = int(contest_id)
start_time, end_time = Contest_Manager.get_time(contest_id)
problems = Contest_Manager.list_problem_for_contest(
contest_id) if start_time <= unix_nano() else []
players = Contest_Manager.list_player_for_contest(contest_id)
data = []
is_admin = Login_Manager.get_privilege() >= Privilege.ADMIN
for Player in players:
tmp = [0, User_Manager.get_friendly_name(Player)]
for Problem in problems:
submits = Judge_Manager.get_contest_judge(
int(Problem[0]), Player[0], start_time, end_time)
is_ac = False
try_time = 0
if submits is not None:
for Submit in submits:
try_time += 1
if int(Submit[1]) == 2:
is_ac = True
break
if is_ac:
tmp[0] += 1
tmp.append([is_ac, try_time]) # AC try time or failed times
if is_admin:
tmp.append(
Reference_Manager.Query_Realname(
User_Manager.get_student_id(Player)))
else:
tmp.append("")
data.append(tmp)
cur_time = unix_nano()
if cur_time < start_time:
contest_status = 'Pending'
elif cur_time > end_time:
contest_status = 'Finished'
else:
contest_status = 'Going On'
title = Contest_Manager.get_title(contest_id)[0][0]
return render_template(
'homework.html',
id=contest_id,
Title=title,
Status=contest_status,
StartTime=readable_time(start_time),
EndTime=readable_time(end_time),
Problems=problems,
Players=players,
Data=data,
len=len(players),
len2=len(problems),
is_Admin=is_admin,
Percentage=min(
max(
int(100 * float(unix_nano() - start_time) /
float(end_time - start_time)), 0), 100),
friendlyName=Login_Manager.get_friendly_name())
def status():
if not Login_Manager.check_user_status():
return redirect('login?next=' + request.full_path)
page = request.args.get('page')
arg_submitter = request.args.get('submitter')
if arg_submitter == '':
arg_submitter = None
arg_problem_id = request.args.get('problem_id')
if arg_problem_id == '':
arg_problem_id = None
arg_status = request.args.get('status')
if arg_status == '-1':
arg_status = None
arg_lang = request.args.get('lang')
if arg_lang == '-1':
arg_lang = None
username = Login_Manager.get_username()
privilege = Login_Manager.get_privilege()
is_admin = Login_Manager.get_privilege() >= Privilege.ADMIN
if arg_submitter is None and arg_problem_id is None and arg_status is None and arg_lang is None:
page = int(page) if page is not None else 1
max_page = int(
(Judge_Manager.max_id() + JudgeConfig.Judge_Each_Page - 1) /
JudgeConfig.Judge_Each_Page)
page = max(min(max_page, page), 1)
end_id = Judge_Manager.max_id() - (page -
1) * JudgeConfig.Judge_Each_Page
start_id = end_id - JudgeConfig.Judge_Each_Page + 1
record = Judge_Manager.judge_in_range(start_id, end_id)
else:
record = Judge_Manager.search_judge(arg_submitter, arg_problem_id,
arg_status, arg_lang)
max_page = int((len(record) + JudgeConfig.Judge_Each_Page - 1) /
JudgeConfig.Judge_Each_Page)
page = int(page) if page is not None else 1
page = max(min(max_page, page), 1)
end_id = len(record) - (page - 1) * JudgeConfig.Judge_Each_Page
start_id = max(end_id - JudgeConfig.Judge_Each_Page + 1, 1)
record = reversed(record[start_id - 1:end_id])
data = []
for ele in record:
cur = {
'ID':
ele['ID'],
'Friendly_Name':
User_Manager.get_friendly_name(ele['Username']),
'Problem_ID':
ele['Problem_ID'],
'Problem_Title':
Problem_Manager.get_title(ele['Problem_ID']),
'Status':
ele['Status'],
'Time_Used':
ele['Time_Used'],
'Mem_Used':
ele['Mem_Used'],
'Lang':
readable_lang(ele['Lang']),
'Visible':
username == ele['Username'] or privilege == 2
or (bool(ele['Share'])
and not Problem_Manager.in_contest(ele['Problem_ID'])),
'Time':
readable_time(ele['Time'])
}
if is_admin:
cur['Real_Name'] = Reference_Manager.Query_Realname(
User_Manager.get_student_id(ele['Username']))
data.append(cur)
return render_template('status.html',
Data=data,
Pages=gen_page(page, max_page),
Args=dict(
filter(lambda e: e[0] != 'page',
request.args.items())),
is_Admin=is_admin,
friendlyName=Login_Manager.get_friendly_name())