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)