async def handle(self):
try:
event = self.request.pop('event', None)
if event:
if event == 'problem_data_change':
await self.update_problem_data()
else:
raise SystemError('Unknown event: {}'.format(event))
else:
type = self.request.pop('type')
if type == 0:
await self.submission()
elif type == 1:
await self.pretest()
else:
raise SystemError('Unsupported type: {}'.format(type))
for key in self.request:
logger.warning('Unused key in judge request: %s', key)
except CompileError as e:
self.end(status=STATUS_COMPILE_ERROR,
score=0,
time_ms=0,
memory_kb=0)
except Exception as e:
logger.exception(e)
self.next(compiler_text=repr(e))
self.end(status=STATUS_SYSTEM_ERROR,
score=0,
time_ms=0,
memory_kb=0)
def read_yaml_config(config, lang, judge_category, ops):
open = ops["open"]
extract = ops["extract"]
data = yaml.safe_load(config)
data['lang'] = None
# if not has_lang(lang):
# logger.warning('Unsupported language: %s', lang)
# return data
for _lang in data['languages']:
_language = _lang.get('language')
if not _language:
logger.warning('Language not defined')
continue
if not lang == _language:
continue
if _lang.get('compiler_args'):
_lang['compiler_args'] = shlex.split(_lang['compiler_args'])
if _lang.get('execute_args'):
_lang['execute_args'] = shlex.split(_lang['execute_args'])
data['lang'] = _lang
break
data['cases'] = read_yaml_cases(data.get('cases'), judge_category, open)
# support for injecting other files:
if 'compile_time_files' in data:
# logger.info("Need to inject compile time files at '%s'", data['compile_time_files'])
data['compile_time_files'] = partial(extract, data['compile_time_files'])
if 'runtime_files' in data:
# logger.info("Need to inject runtime files at '%s'", data['runtime_files'])
data['runtime_files'] = partial(extract, data['runtime_files'])
return data
async def judge_consume(self, handler_type):
async with self.ws_connect(self.full_url('judge/consume-conn/websocket')) as ws:
logger.info('Connected')
async for msg in ws:
request = json.loads(msg.data)
await handler_type(self, request, ws).handle()
logger.warning('Connection lost with code %d', ws.close_code)
def try_init_cgroup():
euid = geteuid()
if euid == 0:
logger.warning('Running as root')
cgroups_to_init = list()
if not (path.isdir(CPUACCT_CGROUP_ROOT)
and access(CPUACCT_CGROUP_ROOT, W_OK)):
cgroups_to_init.append(CPUACCT_CGROUP_ROOT)
if not (path.isdir(MEMORY_CGROUP_ROOT)
and access(MEMORY_CGROUP_ROOT, W_OK)):
cgroups_to_init.append(MEMORY_CGROUP_ROOT)
if not (path.isdir(PIDS_CGROUP_ROOT) and access(PIDS_CGROUP_ROOT, W_OK)):
cgroups_to_init.append(PIDS_CGROUP_ROOT)
if cgroups_to_init:
if euid == 0:
logger.info('Initializing cgroup: %s', ', '.join(cgroups_to_init))
for cgroup_to_init in cgroups_to_init:
makedirs(cgroup_to_init, exist_ok=True)
elif __stdin__.isatty():
logger.info('Initializing cgroup: %s', ', '.join(cgroups_to_init))
call([
'sudo', 'sh', '-c',
'mkdir -p "{1}" && chown -R "{0}" "{1}"'.format(
euid, '" "'.join(cgroups_to_init))
])
else:
logger.error('Cgroup not initialized')
async def judge_consume(self, handler_type):
async with self.ws_connect(
self.full_url('judge/consume-conn/websocket')) as ws:
logger.info('Connected')
queue = Queue()
async def worker():
try:
while True:
request = await queue.get()
await handler_type(self, request, ws).handle()
except CancelledError:
raise
except Exception as e:
logger.exception(e)
await ws.close()
worker_task = get_event_loop().create_task(worker())
try:
while True:
queue.put_nowait(await ws.receive_json())
except TypeError:
pass
logger.warning('Connection lost with code %s', ws.close_code)
worker_task.cancel()
try:
await worker_task
except CancelledError:
pass
async def handle(self):
event = self.request.pop('event', None)
if not event:
await self.do_record()
elif event == 'problem_data_change':
await self.update_problem_data()
else:
logger.warning('Unknown event: %s', event)
for key in self.request:
logger.warning('Unused key in judge request: %s', key)
def do_status(self, expected_status, expected_score, code):
package, message, time_usage_ns, memory_usage_bytes = \
run(build('c', code))
self.assertIsNotNone(package, 'Compile failed: ' + message)
if message:
logger.warning('Compiler output is not empty: %s', message)
status, score, time_usage_ns, memory_usage_bytes, stderr = \
run(self.case.judge(package))
self.assertEqual(status, expected_status)
self.assertEqual(score, expected_score)
def _init():
parallelism = config.get('parallelism', 2)
if parallelism < 2:
logger.warning(
'Parallelism less than 2, custom judge will not be supported.')
logger.info('Using parallelism: %d', parallelism)
sandboxes_task = create_sandboxes(parallelism)
global _lock, _queue
_lock = Lock()
_queue = LifoQueue()
put_sandbox(*get_event_loop().run_until_complete(sandboxes_task))
def do_lang(self, lang, code):
package, message, time_usage_ns, memory_usage_bytes = \
run(build(lang, code))
self.assertIsNotNone(package, 'Compile failed: ' + message)
logger.info('Compiled successfully in %d ms time, %d kb memory',
time_usage_ns // 1000000, memory_usage_bytes // 1024)
if message:
logger.warning('Compiler output is not empty: %s', message)
for case in self.cases:
status, score, time_usage_ns, memory_usage_bytes, stderr = \
run(case.judge(package))
self.assertEqual(status, STATUS_ACCEPTED)
self.assertEqual(score, 10)
self.assertEqual(stderr, b'')
logger.info('Accepted: %d ms time, %d kb memory',
time_usage_ns // 1000000, memory_usage_bytes // 1024)
def do_status(self, expected_status, expected_score, code):
package, message, time_usage_ns, memory_usage_bytes = \
run(build('c', code))
self.assertIsNotNone(package, 'Compile failed: ' + message)
logger.info('Compiled successfully in %d ms time, %d kb memory',
time_usage_ns // 1000000, memory_usage_bytes // 1024)
if message:
logger.warning('Compiler output is not empty: %s', message)
total_status = STATUS_ACCEPTED
total_score = 0
for case in self.cases:
status, score, time_usage_ns, memory_usage_bytes, stderr = \
run(case.judge(package))
total_status = max(total_status, status)
total_score += score
self.assertEqual(status, STATUS_ACCEPTED)
self.assertEqual(score, 25)
self.assertEqual(stderr, b'')
logger.info('Accepted: %d ms time, %d kb memory',
time_usage_ns // 1000000, memory_usage_bytes // 1024)
self.assertEqual(total_status, expected_status)
self.assertEqual(total_score, expected_score)
