def compile_src(srcs, exe, for_evaluation, lang, assume=None):
if lang != 'pas' or len(srcs) == 1:
call(base_dir, get_compilation_command(
lang,
srcs,
exe,
for_evaluation=for_evaluation))
# When using Pascal with graders, file naming conventions
# require us to do a bit of trickery, i.e., performing the
# compilation in a separate temporary directory
else:
tempdir = tempfile.mkdtemp()
task_name = detect_task_name(base_dir)
new_srcs = [os.path.split(srcs[0])[1],
'%s.pas' % (task_name)]
new_exe = os.path.split(srcs[1])[1][:-4]
shutil.copyfile(os.path.join(base_dir, srcs[0]),
os.path.join(tempdir, new_srcs[0]))
shutil.copyfile(os.path.join(base_dir, srcs[1]),
os.path.join(tempdir, new_srcs[1]))
lib_filename = '%slib.pas' % (task_name)
if os.path.exists(os.path.join(SOL_DIRNAME, lib_filename)):
shutil.copyfile(os.path.join(SOL_DIRNAME, lib_filename),
os.path.join(tempdir, lib_filename))
call(tempdir, get_compilation_command(
lang,
new_srcs,
new_exe,
for_evaluation=for_evaluation))
shutil.copyfile(os.path.join(tempdir, new_exe),
os.path.join(base_dir, exe))
shutil.copymode(os.path.join(tempdir, new_exe),
os.path.join(base_dir, exe))
shutil.rmtree(tempdir)
def compile_src(srcs, exe, for_evaluation, lang, assume=None):
if lang != 'pas' or len(srcs) == 1:
call(base_dir, get_compilation_command(
lang,
srcs,
exe,
for_evaluation=for_evaluation))
# When using Pascal with graders, file naming conventions
# require us to do a bit of trickery, i.e., performing the
# compilation in a separate temporary directory
else:
tempdir = tempfile.mkdtemp()
task_name = detect_task_name(base_dir)
new_srcs = [os.path.split(srcs[0])[1],
'%s.pas' % (task_name)]
new_exe = os.path.split(srcs[1])[1][:-4]
shutil.copyfile(os.path.join(base_dir, srcs[0]),
os.path.join(tempdir, new_srcs[0]))
shutil.copyfile(os.path.join(base_dir, srcs[1]),
os.path.join(tempdir, new_srcs[1]))
lib_filename = '%slib.pas' % (task_name)
if os.path.exists(os.path.join(SOL_DIRNAME, lib_filename)):
shutil.copyfile(os.path.join(SOL_DIRNAME, lib_filename),
os.path.join(tempdir, lib_filename))
call(tempdir, get_compilation_command(
lang,
new_srcs,
new_exe,
for_evaluation=for_evaluation))
shutil.copyfile(os.path.join(tempdir, new_exe),
os.path.join(base_dir, exe))
shutil.copymode(os.path.join(tempdir, new_exe),
os.path.join(base_dir, exe))
shutil.rmtree(tempdir)
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in LANGUAGES:
source_ext = LANGUAGE_TO_SOURCE_EXT_MAP[language]
header_ext = LANGUAGE_TO_HEADER_EXT_MAP[language]
source_filenames = []
for filename in submission_format:
source_filename = filename.replace(".%l", source_ext)
source_filenames.append(source_filename)
# Headers.
header_filename = filename.replace(".%l", header_ext)
source_filenames.append(header_filename)
# Manager.
manager_source_filename = "manager%s" % source_ext
source_filenames.append(manager_source_filename)
# Manager's header.
manager_header_filename = "manager%s" % header_ext
source_filenames.append(manager_header_filename)
# Get compilation command and compile.
executable_filename = "manager"
command = " ".join(get_compilation_command(language,
source_filenames,
executable_filename))
res[language] = [command]
return res
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in Submission.LANGUAGES:
header = HEADERS_MAP[language]
source_filenames = []
for filename in submission_format:
source_filename = filename.replace("%l", language)
source_filenames.append(source_filename)
# Headers.
header_filename = filename.replace("%l", header)
source_filenames.append(header_filename)
# Manager.
manager_source_filename = "manager.%s" % language
source_filenames.append(manager_source_filename)
# Manager's header.
manager_header_filename = "manager.%s" % header
source_filenames.append(manager_header_filename)
# Get compilation command and compile.
executable_filename = "manager"
command = " ".join(
get_compilation_command(language, source_filenames,
executable_filename))
res[language] = [command]
return res
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in Submission.LANGUAGES:
header = HEADERS_MAP[language]
source_filenames = []
for filename in submission_format:
source_filename = filename.replace("%l", language)
source_filenames.append(source_filename)
# Headers.
header_filename = filename.replace("%l", header)
source_filenames.append(header_filename)
# Manager.
manager_source_filename = "manager.%s" % language
source_filenames.append(manager_source_filename)
# Manager's header.
manager_header_filename = "manager.%s" % header
source_filenames.append(manager_header_filename)
# Get compilation command and compile.
executable_filename = "manager"
command = " ".join(get_compilation_command(language,
source_filenames,
executable_filename))
res[language] = [command]
return res
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in LANGUAGES:
source_ext = LANGUAGE_TO_SOURCE_EXT_MAP[language]
header_ext = LANGUAGE_TO_HEADER_EXT_MAP[language]
source_filenames = []
for filename in submission_format:
source_filename = filename.replace(".%l", source_ext)
source_filenames.append(source_filename)
# Headers.
header_filename = filename.replace(".%l", header_ext)
source_filenames.append(header_filename)
# Manager.
manager_source_filename = "manager%s" % source_ext
source_filenames.append(manager_source_filename)
# Manager's header.
manager_header_filename = "manager%s" % header_ext
source_filenames.append(manager_header_filename)
# Get compilation command and compile.
executable_filename = "manager"
command = " ".join(
get_compilation_command(language, source_filenames,
executable_filename))
res[language] = [command]
return res
def compile_src(srcs, exe, lang):
if lang != "pas" or len(srcs) == 1:
call(base_dir, get_compilation_command(lang, srcs, exe, for_evaluation=False))
# When using Pascal with graders, file naming conventions
# require us to do a bit of trickery, i.e., performing the
# compilation in a separate temporary directory
else:
tempdir = tempfile.mkdtemp()
task_name = detect_task_name(base_dir)
new_srcs = [os.path.split(srcs[0])[1], "%s.pas" % (task_name)]
new_exe = os.path.split(srcs[1])[1][:-4]
shutil.copyfile(srcs[0], os.path.join(tempdir, new_srcs[0]))
shutil.copyfile(srcs[1], os.path.join(tempdir, new_srcs[1]))
call(tempdir, get_compilation_command(lang, new_srcs, new_exe, for_evaluation=False))
shutil.copyfile(os.path.join(tempdir, new_exe), os.path.join(SOL_DIRNAME, new_exe))
shutil.copymode(os.path.join(tempdir, new_exe), os.path.join(SOL_DIRNAME, new_exe))
def compile_src(src, exe, lang, assume=None):
if lang in ['cpp', 'c', 'pas']:
call(base_dir, get_compilation_command(lang, [src], exe,
for_evaluation=False))
elif lang in ['py', 'sh']:
os.symlink(os.path.basename(src), exe)
else:
raise Exception("Wrong generator/validator language!")
def compile_src(src, exe, lang, assume=None):
if lang in ['cpp', 'c', 'pas']:
call(base_dir, get_compilation_command(lang, [src], exe,
for_evaluation=False))
elif lang in ['py', 'sh']:
os.symlink(os.path.basename(src), exe)
else:
raise Exception("Wrong generator/validator language!")
def compile(self):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = self.job.language
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(self.job.files) != 1:
self.job.success = True
self.job.compilation_success = False
self.job.text = "Invalid files in submission"
logger.error("Submission contains %d files, expecting 1" % len(self.job.files))
return True
# Create the sandbox
sandbox = create_sandbox(self)
self.job.sandboxes.append(sandbox.path)
# Prepare the source files in the sandbox
files_to_get = {}
format_filename = self.job.files.keys()[0]
source_filenames = []
# Stub.
source_filenames.append("stub.%s" % language)
files_to_get[source_filenames[-1]] = self.job.managers["stub.%s" % language].digest
# User's submission.
source_filenames.append(format_filename.replace("%l", language))
files_to_get[source_filenames[-1]] = self.job.files[format_filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Prepare the compilation command
executable_filename = format_filename.replace(".%l", "")
command = get_compilation_command(language, source_filenames, executable_filename)
# Run the compilation
operation_success, compilation_success, text, plus = compilation_step(sandbox, command)
# Retrieve the compiled executables
self.job.success = operation_success
self.job.compilation_success = compilation_success
self.job.plus = plus
self.job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename, "Executable %s for %s" % (executable_filename, self.job.info)
)
self.job.executables[executable_filename] = Executable(executable_filename, digest)
# Cleanup
delete_sandbox(sandbox)
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in Submission.LANGUAGES:
format_filename = submission_format[0]
source_filenames = []
source_filenames.append("stub.%s" % language)
source_filenames.append(format_filename.replace("%l", language))
executable_filename = format_filename.replace(".%l", "")
command = " ".join(get_compilation_command(language, source_filenames, executable_filename))
res[language] = [command]
return res
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in Submission.LANGUAGES:
format_filename = submission_format[0]
source_filenames = []
source_filenames.append("stub.%s" % language)
source_filenames.append(format_filename.replace("%l", language))
executable_filename = format_filename.replace(".%l", "")
command = " ".join(
get_compilation_command(language, source_filenames,
executable_filename))
res[language] = [command]
return res
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in Submission.LANGUAGES:
format_filename = submission_format[0]
source_filenames = []
# If a grader is specified, we add to the command line (and to
# the files to get) the corresponding manager.
if self.job.task_type_parameters[0] == "grader":
source_filenames.append("grader.%s" % language)
source_filenames.append(format_filename.replace("%l", language))
executable_filename = format_filename.replace(".%l", "")
command = " ".join(get_compilation_command(language, source_filenames, executable_filename))
res[language] = [command]
return res
def compile(self):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = self.submission.language
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(self.submission.files) != 1:
return self.finish_compilation(
True, False, "Invalid files in submission",
to_log="Submission contains %d files, expecting 1" %
len(self.submission.files))
# First and only one compilation.
sandbox = create_sandbox(self)
files_to_get = {}
format_filename = self.submission.files.keys()[0]
source_filenames = [format_filename.replace("%l", language)]
files_to_get[source_filenames[0]] = \
self.submission.files[format_filename].digest
# If a grader is specified, we add to the command line (and to
# the files to get) the corresponding manager.
if self.parameters[0] == "grader":
source_filenames.append("grader.%s" % language)
files_to_get[source_filenames[1]] = \
self.submission.task.managers["grader.%s" % language].digest
executable_filename = format_filename.replace(".%l", "")
command = get_compilation_command(language,
source_filenames,
executable_filename)
operation_success, compilation_success, text, _ = \
self.compilation_step(
sandbox,
command,
files_to_get,
{executable_filename: "Executable %s for submission %s" %
(executable_filename, self.submission.id)})
delete_sandbox(sandbox)
# We had only one compilation, hence we pipe directly its
# result to the finalization.
return self.finish_compilation(operation_success, compilation_success,
text)
def get_compilation_commands(self, submission_format):
"""See TaskType.get_compilation_commands."""
res = dict()
for language in Submission.LANGUAGES:
format_filename = submission_format[0]
source_filenames = []
# If a grader is specified, we add to the command line (and to
# the files to get) the corresponding manager.
if self.job.task_type_parameters[0] == "grader":
source_filenames.append("grader.%s" % language)
source_filenames.append(format_filename.replace("%l", language))
executable_filename = format_filename.replace(".%l", "")
command = " ".join(
get_compilation_command(language, source_filenames,
executable_filename))
res[language] = [command]
return res
def compile(self):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = self.job.language
header = HEADERS_MAP[language]
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(self.job.files) != 2:
self.job.success = True
self.job.compilation_success = False
self.job.text = "Invalid files in submission"
logger.warning("Submission contains %d files, expecting 2" %
len(self.job.files))
return True
# First and only one compilation.
sandbox = create_sandbox(self)
self.job.sandboxes.append(sandbox.path)
files_to_get = {}
# User's submissions and headers.
source_filenames = []
for filename, _file in self.job.files.iteritems():
source_filename = filename.replace("%l", language)
source_filenames.append(source_filename)
files_to_get[source_filename] = _file.digest
# Headers.
header_filename = filename.replace("%l", header)
source_filenames.append(header_filename)
files_to_get[header_filename] = \
self.job.managers[header_filename].digest
# Manager.
manager_filename = "manager.%s" % language
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
self.job.managers[manager_filename].digest
# Manager's header.
manager_filename = "manager.%s" % header
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
self.job.managers[manager_filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Get compilation command and compile.
executable_filename = "manager"
command = get_compilation_command(language,
source_filenames,
executable_filename)
operation_success, compilation_success, text, plus = \
compilation_step(sandbox, command)
# Retrieve the compiled executables
self.job.success = operation_success
self.job.compilation_success = compilation_success
self.job.plus = plus
self.job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename,
"Executable %s for %s" %
(executable_filename, self.job.info))
self.job.executables[executable_filename] = \
Executable(digest, executable_filename)
# Cleanup
delete_sandbox(sandbox)
def compile_check(src, exe, assume=None):
call(base_dir, get_compilation_command(lang, [src], exe))
def compile(self):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = self.job.language
header = HEADERS_MAP[language]
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(self.job.files) != 2:
self.job.success = True
self.job.compilation_success = False
self.job.text = "Invalid files in submission"
logger.warning("Submission contains %d files, expecting 2" %
len(self.job.files))
return True
# First and only one compilation.
sandbox = create_sandbox(self)
self.job.sandboxes.append(sandbox.path)
files_to_get = {}
# User's submissions and headers.
source_filenames = []
for filename, _file in self.job.files.iteritems():
source_filename = filename.replace("%l", language)
source_filenames.append(source_filename)
files_to_get[source_filename] = _file.digest
# Headers.
header_filename = filename.replace("%l", header)
source_filenames.append(header_filename)
files_to_get[header_filename] = \
self.job.managers[header_filename].digest
# Manager.
manager_filename = "manager.%s" % language
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
self.job.managers[manager_filename].digest
# Manager's header.
manager_filename = "manager.%s" % header
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
self.job.managers[manager_filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Get compilation command and compile.
executable_filename = "manager"
command = get_compilation_command(language, source_filenames,
executable_filename)
operation_success, compilation_success, text, plus = \
compilation_step(sandbox, command)
# Retrieve the compiled executables
self.job.success = operation_success
self.job.compilation_success = compilation_success
self.job.plus = plus
self.job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename,
"Executable %s for %s" % (executable_filename, self.job.info))
self.job.executables[executable_filename] = \
Executable(digest, executable_filename)
# Cleanup
delete_sandbox(sandbox)
def compile(self, job, file_cacher):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = job.language
source_ext = LANGUAGE_TO_SOURCE_EXT_MAP[language]
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(job.files) != 1:
job.success = True
job.compilation_success = False
job.text = [N_("Invalid files in submission")]
logger.error("Submission contains %d files, expecting 1" %
len(job.files),
extra={"operation": job.info})
return True
# Create the sandbox
sandbox = create_sandbox(file_cacher)
job.sandboxes.append(sandbox.path)
# Prepare the source files in the sandbox
files_to_get = {}
format_filename = job.files.keys()[0]
source_filenames = []
source_filenames.append(format_filename.replace(".%l", source_ext))
files_to_get[source_filenames[0]] = \
job.files[format_filename].digest
# If a grader is specified, we add to the command line (and to
# the files to get) the corresponding manager. The grader must
# be the first file in source_filenames.
if self.parameters[0] == "grader":
source_filenames.insert(0, "grader%s" % source_ext)
files_to_get["grader%s" % source_ext] = \
job.managers["grader%s" % source_ext].digest
# Also copy all *.h and *lib.pas graders
for filename in job.managers.iterkeys():
if filename.endswith('.h') or \
filename.endswith('lib.pas'):
files_to_get[filename] = \
job.managers[filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Prepare the compilation command
executable_filename = format_filename.replace(".%l", "")
command = get_compilation_command(language, source_filenames,
executable_filename)
# Run the compilation
operation_success, compilation_success, text, plus = \
compilation_step(sandbox, command)
# Retrieve the compiled executables
job.success = operation_success
job.compilation_success = compilation_success
job.plus = plus
job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename,
"Executable %s for %s" % (executable_filename, job.info))
job.executables[executable_filename] = \
Executable(executable_filename, digest)
# Cleanup
delete_sandbox(sandbox)
def compile_check(src, exe):
call(base_dir, get_compilation_command(lang, [src], exe))
def compile_src(src, exe):
call(base_dir, get_compilation_command(lang, [src], exe,
for_evaluation=False))
def compile(self, job, file_cacher):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = job.language
source_ext = LANGUAGE_TO_SOURCE_EXT_MAP[language]
header_ext = LANGUAGE_TO_HEADER_EXT_MAP[language]
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(job.files) != 2:
job.success = True
job.compilation_success = False
job.text = [N_("Invalid files in submission")]
logger.error("Submission contains %d files, expecting 2" %
len(job.files), extra={"operation": job.info})
return True
# First and only one compilation.
sandbox = create_sandbox(file_cacher)
job.sandboxes.append(sandbox.path)
files_to_get = {}
# User's submissions and headers.
source_filenames = []
for filename, file_ in job.files.iteritems():
source_filename = filename.replace(".%l", source_ext)
source_filenames.append(source_filename)
files_to_get[source_filename] = file_.digest
# Headers.
header_filename = filename.replace(".%l", header_ext)
source_filenames.append(header_filename)
files_to_get[header_filename] = \
job.managers[header_filename].digest
# Manager.
manager_filename = "manager%s" % source_ext
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
job.managers[manager_filename].digest
# Manager's header.
manager_filename = "manager%s" % header_ext
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
job.managers[manager_filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Get compilation command and compile.
executable_filename = "manager"
command = get_compilation_command(language,
source_filenames,
executable_filename)
operation_success, compilation_success, text, plus = \
compilation_step(sandbox, command)
# Retrieve the compiled executables
job.success = operation_success
job.compilation_success = compilation_success
job.plus = plus
job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename,
"Executable %s for %s" %
(executable_filename, job.info))
job.executables[executable_filename] = \
Executable(executable_filename, digest)
# Cleanup
delete_sandbox(sandbox)
def compile(self):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = self.job.language
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(self.job.files) != 1:
self.job.success = True
self.job.compilation_success = False
self.job.text = "Invalid files in submission"
logger.warning("Submission contains %d files, expecting 1" %
len(self.job.files))
return True
# Create the sandbox
sandbox = create_sandbox(self)
self.job.sandboxes.append(sandbox.path)
# Prepare the source files in the sandbox
files_to_get = {}
format_filename = self.job.files.keys()[0]
source_filenames = []
# Stub.
source_filenames.append("stub.%s" % language)
files_to_get[source_filenames[1]] = \
self.job.managers["stub.%s" % language].digest
# User's submission.
source_filenames.append(format_filename.replace("%l", language))
files_to_get[source_filenames[0]] = \
self.job.files[format_filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Prepare the compilation command
executable_filename = format_filename.replace(".%l", "")
command = get_compilation_command(language, source_filenames,
executable_filename)
# Run the compilation
operation_success, compilation_success, text, plus = \
compilation_step(sandbox, command)
# Retrieve the compiled executables
self.job.success = operation_success
self.job.compilation_success = compilation_success
self.job.plus = plus
self.job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename,
"Executable %s for %s" % (executable_filename, self.job.info))
self.job.executables[executable_filename] = \
Executable(digest, executable_filename)
# Cleanup
delete_sandbox(sandbox)
def compile(self, job, file_cacher):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = job.language
source_ext = LANGUAGE_TO_SOURCE_EXT_MAP[language]
header_ext = LANGUAGE_TO_HEADER_EXT_MAP[language]
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(job.files) != 2:
job.success = True
job.compilation_success = False
job.text = [N_("Invalid files in submission")]
logger.error("Submission contains %d files, expecting 2" %
len(job.files),
extra={"operation": job.info})
return True
# First and only one compilation.
sandbox = create_sandbox(file_cacher)
job.sandboxes.append(sandbox.path)
files_to_get = {}
# User's submissions and headers.
source_filenames = []
for filename, file_ in job.files.iteritems():
source_filename = filename.replace(".%l", source_ext)
source_filenames.append(source_filename)
files_to_get[source_filename] = file_.digest
# Headers.
header_filename = filename.replace(".%l", header_ext)
source_filenames.append(header_filename)
files_to_get[header_filename] = \
job.managers[header_filename].digest
# Manager.
manager_filename = "manager%s" % source_ext
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
job.managers[manager_filename].digest
# Manager's header.
manager_filename = "manager%s" % header_ext
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
job.managers[manager_filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Get compilation command and compile.
executable_filename = "manager"
command = get_compilation_command(language, source_filenames,
executable_filename)
operation_success, compilation_success, text, plus = \
compilation_step(sandbox, command)
# Retrieve the compiled executables
job.success = operation_success
job.compilation_success = compilation_success
job.plus = plus
job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename,
"Executable %s for %s" % (executable_filename, job.info))
job.executables[executable_filename] = \
Executable(executable_filename, digest)
# Cleanup
delete_sandbox(sandbox)
def compile(self):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = self.job.language
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(self.job.files) != 1:
self.job.success = True
self.job.compilation_success = False
self.job.text = "Invalid files in submission"
logger.warning("Submission contains %d files, expecting 1" %
len(self.job.files))
return True
# Create the sandbox
sandbox = create_sandbox(self)
self.job.sandboxes.append(sandbox.path)
# Prepare the source files in the sandbox
files_to_get = {}
format_filename = self.job.files.keys()[0]
source_filenames = []
source_filenames.append(format_filename.replace("%l", language))
files_to_get[source_filenames[0]] = \
self.job.files[format_filename].digest
# If a grader is specified, we add to the command line (and to
# the files to get) the corresponding manager. The grader must
# be the first file in source_filenames.
if self.job.task_type_parameters[0] == "grader":
source_filenames.insert(0, "grader.%s" % language)
files_to_get["grader.%s" % language] = \
self.job.managers["grader.%s" % language].digest
# Also copy all *.h and *lib.pas graders
for filename in self.job.managers.iterkeys():
if filename.endswith('.h') or \
filename.endswith('lib.pas'):
files_to_get[filename] = \
self.job.managers[filename].digest
for filename, digest in files_to_get.iteritems():
sandbox.create_file_from_storage(filename, digest)
# Prepare the compilation command
executable_filename = format_filename.replace(".%l", "")
command = get_compilation_command(language,
source_filenames,
executable_filename)
# Run the compilation
operation_success, compilation_success, text, plus = \
compilation_step(sandbox, command)
# Retrieve the compiled executables
self.job.success = operation_success
self.job.compilation_success = compilation_success
self.job.plus = plus
self.job.text = text
if operation_success and compilation_success:
digest = sandbox.get_file_to_storage(
executable_filename,
"Executable %s for %s" %
(executable_filename, self.job.info))
self.job.executables[executable_filename] = \
Executable(digest, executable_filename)
# Cleanup
delete_sandbox(sandbox)
def compile(self):
"""See TaskType.compile."""
# Detect the submission's language. The checks about the
# formal correctedness of the submission are done in CWS,
# before accepting it.
language = self.submission.language
header = HEADERS_MAP[language]
# TODO: here we are sure that submission.files are the same as
# task.submission_format. The following check shouldn't be
# here, but in the definition of the task, since this actually
# checks that task's task type and submission format agree.
if len(self.submission.files) != 2:
return self.finish_compilation(
True, False, "Invalid files in submission",
to_log="Submission contains %d files, expecting 2" %
len(self.submission.files))
# First and only one compilation.
sandbox = create_sandbox(self)
files_to_get = {}
# User's submissions and headers.
source_filenames = []
for filename, _file in self.submission.files.iteritems():
source_filename = filename.replace("%l", language)
source_filenames.append(source_filename)
files_to_get[source_filename] = _file.digest
# Headers.
header_filename = filename.replace("%l", header)
source_filenames.append(header_filename)
files_to_get[header_filename] = \
self.submission.task.managers[header_filename].digest
# Manager.
manager_filename = "manager.%s" % language
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
self.submission.task.managers[manager_filename].digest
# Manager's header.
manager_filename = "manager.%s" % header
source_filenames.append(manager_filename)
files_to_get[manager_filename] = \
self.submission.task.managers[manager_filename].digest
# Get compilation command and compile.
executable_filename = "manager"
command = get_compilation_command(language,
source_filenames,
executable_filename)
operation_success, compilation_success, text, _ = \
self.compilation_step(
sandbox,
command,
files_to_get,
{executable_filename: "Executable %s for submission %s" %
(executable_filename, self.submission.id)})
delete_sandbox(sandbox)
# We had only one compilation, hence we pipe directly its
# result to the finalization.
return self.finish_compilation(operation_success, compilation_success,
text)
