def compiler(self):
logging.debug("compiler contestant")
source_filename = ['contestant_source.' + self.lang_source]
executable_filename = "contestant_source"
lang = filename_to_language(self.path_contestant)
commands = lang.get_compilation_commands(source_filename,
executable_filename)
# print(commands)
status = compilation_step(self.sandbox, commands)
if status[0] is not True or status[1] is not True:
# logging.debug("contestant compiler fail")
self.update_status(log=status[-1])
return status
# self.update_status(log="contestant compiler succes")
self.update_status(log=status[-1])
source_filename = [
os.path.join(self.sandbox.secure_folder, 'checker') + "." +
self.jobdescription['checker_lang']
]
executable_filename = os.path.join(self.sandbox.secure_folder,
'checker')
lang = filename_to_language("." + self.jobdescription['checker_lang'])
commands = lang.get_compilation_commands(source_filename,
executable_filename)
status = compilation_step(self.sandbox, commands)
if status[0] is not True or status[1] is not True:
# logging.debug("contestant compiler fail")
self.update_status(log="checker compiler fail")
self.update_status(log=status[-1])
return status
def compiler(self):
# logging.debug("compiler contestant")
# self.update_status()
source_filename = ['contestant_source.' + self.lang_source]
executable_filename = "contestant_source"
lang = filename_to_language(self.path_contestant)
commands = lang.get_compilation_commands(source_filename,
executable_filename)
status = compilation_step(self.sandbox, commands)
if status[0] is not True or status[1] is not True:
# logging.debug("contestant compiler fail")
self.update_status(log="contestant compiler fail")
return status
self.update_status(log=status[-1])
source_filename = [
os.path.join(self.sandbox.secure_folder, 'iteractor.cpp')
]
executable_filename = os.path.join(self.sandbox.secure_folder,
"iteractor")
lang = filename_to_language("." +
self.jobdescription['iteractor_lang'])
commands = lang.get_compilation_commands(source_filename,
executable_filename)
status = compilation_step(self.sandbox, commands)
if status[0] is not True or status[1] is not True:
self.update_status(log="iteractor compiler fail")
return status
return status
def run_per_test(self, idx):
jury_input = os.path.join(self.sandbox.secure_folder,
'inputs/{}.in'.format(idx))
# jury_output = os.path.join(self.sandbox.secure_folder,'outputs/{}.out'.format(idx))
output_iteractor = '{}.out'.format(idx)
manager_command = [
"./" + os.path.join(self.sandbox.secure_folder, 'iteractor')
] # iteractir fifo user->ma : ma->user
manager_command = manager_command + self.sandbox_fifo_user_to_manager + self.sandbox_fifo_manager_to_user
manager_time_limit = max(1 * (1 + self.time_limit),
env.trusted_sandbox_max_time_s)
# run manager
manager = evaluation_step_before_run(
self.sandbox,
command=manager_command,
time_limit=manager_time_limit,
# memory_limit= env.max_file_size * 1024,
# dirs_map=dict((self.fifo_dir[0], (self.sandbox_fifo_dir[0], "rw"))
# for i in [0]),
# writable_files=[self.OUTPUT_FILENAME],
stdin_redirect=jury_input,
stdout_redirect=output_iteractor,
multiprocess=self.multiprocess,
wait=False)
user_command = ["./contestant_source"]
user_command = user_command + self.sandbox_fifo_manager_to_user + self.sandbox_fifo_user_to_manager
stdint_redirect = self.sandbox_fifo_manager_to_user[0]
stdout_redirect = self.sandbox_fifo_user_to_manager[0]
user = evaluation_step_before_run(
self.sandbox,
command=user_command,
time_limit=self.time_limit,
memory_limit=self.memory_limit,
# dirs_map={self.fifo_dir[0]: (self.sandbox_fifo_dir[0], "rw")},
stdin_redirect=stdint_redirect,
stdout_redirect=stdout_redirect,
multiprocess=self.multiprocess,
wait=False)
# communication
wait_without_std([user, manager])
status = evaluation_step_after_run(self.sandbox)
if status[0] is not True or status[1] is not True:
self.update_status(log=status[-1])
return False
if idx == 1:
# compilder_checker
source_filename = [
os.path.join(self.sandbox.secure_folder, 'checker') + ".cpp"
]
executable_filename = os.path.join(self.sandbox.secure_folder,
'checker')
lang = filename_to_language("." +
self.jobdescription['checker_lang'])
logging.debug(lang)
logging.debug(source_filename)
logging.debug(executable_filename)
commands = lang.get_compilation_commands(source_filename,
executable_filename)
logging.debug(commands)
status = compilation_step(self.sandbox, commands)
if status[0] is not True or status[1] is not True:
# logging.debug("contestant compiler fail")
logging.debug("checker compiler fail")
return False
logging.debug("checker done")
checker_exec = os.path.join(self.sandbox.secure_folder, "checker")
jury_output = os.path.join(self.sandbox.secure_folder,
"outputs/{}.out".format(idx))
commands = [[checker_exec] + [jury_input] + [output_iteractor] +
[jury_output]]
status_step = evaluation_step(self.sandbox,
commands,
self.time_limit,
self.memory_limit,
self.dirs_map,
stdin_redirect=None,
stdout_redirect=None,
multiprocess=self.multiprocess)
# self.update_status(log=status_step)
if status_step[1] != True:
log_checker = self.sandbox.get_stderr()
self.update_status(log=log_checker)
# self.score.step(idx,0)
return False
# self.update_status(log="here")
self.update_status(log=status_step[2])
return True
# from ..language import base
# from ..language.base import *
# from .test import *
try:
from ..language.base import CompiledLanguage
from ..language.cpp11_gpp import *
from ..language.python3_cpython import *
from ..languageall import get_language, filename_to_language
except:
from language.base import CompiledLanguage
from language.cpp11_gpp import *
from language.python3_cpython import *
from languageall import get_language, filename_to_language
# from language import Cpp11Gpp
print("test language is here")
print("test class cpp11_gpp", Cpp11Gpp())
print("test class python3", Python3CPython())
print(filename_to_language("a.cpp"))
print(filename_to_language("a.py"))
print(filename_to_language("a.java"))
# print(get_language(filename_to_language("a.cpp")))
print("test done")
secure=False)
sandbox.create_file_from_storage('checker.' + job_description['checker_lang'],
job_description['checker'],
secure=True)
sandbox.create_file_from_storage("testlib.h", env.TESTLIB, secure=True)
sandbox.create_file_from_storage('inputs',
job_description['inputs'],
secure=True)
sandbox.create_file_from_storage('outputs',
job_description['outputs'],
secure=True)
source_filename = ['contestant.cpp']
executable_filename = "contestant"
import os
executable_filename_checker = os.path.join(sandbox.secure_folder, "checker")
source_checker_filename = os.path.join(sandbox.secure_folder, "checker.cpp")
lang = filename_to_language(path_contestant)
commands = lang.get_compilation_commands(source_filename, executable_filename)
commands = commands + lang.get_compilation_commands(
[source_checker_filename], executable_filename_checker)
print(commands)
status = compilation_step(sandbox, commands)
print(status)
# return status
sandbox.cleanup()
#