def dataset_updated(self, task_id):
"""This function updates RWS with new data about a task. It should be
called after the live dataset of a task is changed.
task_id (int): id of the task whose dataset has changed.
"""
with SessionGen(commit=False) as session:
task = Task.get_from_id(task_id, session)
dataset_id = task.active_dataset_id
logger.info("Dataset update for task %d (dataset now is %d)." % (
task_id, dataset_id))
submission_ids = get_submissions(self.contest_id, task_id=task_id)
subchanges = []
with SessionGen(commit=False) as session:
for submission_id in submission_ids:
submission = Submission.get_from_id(submission_id, session)
submission_result = SubmissionResult.get_from_id(
(submission_id, dataset_id), session)
if submission_result is None:
# Not yet compiled, evaluated or scored.
score = None
ranking_score_details = None
else:
score = submission_result.score
try:
ranking_score_details = json.loads(
submission_result.ranking_score_details)
except (json.decoder.JSONDecodeError, TypeError):
# It may be blank.
ranking_score_details = None
# Data to send to remote rankings.
subchange_id = "%s%ss" % \
(int(make_timestamp(submission.timestamp)),
submission_id)
subchange_put_data = {
"submission": encode_id(submission_id),
"time": int(make_timestamp(submission.timestamp))}
# We're sending the unrounded score to RWS
if score is not None:
subchange_put_data["score"] = score
if ranking_score_details is not None:
subchange_put_data["extra"] = ranking_score_details
subchanges.append((subchange_id, subchange_put_data))
# Adding operations to the queue.
with self.operation_queue_lock:
for ranking in self.rankings:
for subchange_id, data in subchanges:
self.subchange_queue.setdefault(
ranking,
dict())[encode_id(subchange_id)] = data
def invalidate_submission(self,
submission_id=None,
user_id=None,
task_id=None):
"""Request for invalidating some scores.
Invalidate the scores of the Submission whose ID is
submission_id or, if None, of those whose user is user_id
and/or whose task is task_id or, if both None, of those that
belong to the contest this service is running for.
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user to invalidate, or None.
task_id (int): id of the task to invalidate, or None.
"""
logger.info("Invalidation request received.")
# Validate arguments
# TODO Check that all these objects belong to this contest.
with SessionGen(commit=True) as session:
submissions = get_submissions(
# Give contest_id only if all others are None.
self.contest_id
if {user_id, task_id, submission_id} == {None} else None,
user_id,
task_id,
submission_id,
session)
logger.info("Submissions to invalidate scores for: %d." %
len(submissions))
if len(submissions) == 0:
return
new_submissions_to_score = set()
for submission in submissions:
# If the submission is not evaluated, it does not have
# a score to invalidate, and, when evaluated,
# ScoringService will be prompted to score it. So in
# that case we do not have to do anything.
if submission.evaluated():
submission.invalidate_score()
new_submissions_to_score.add(submission.id)
old_s = len(self.submissions_to_score)
old_t = len(self.submissions_to_token)
self.submissions_to_score |= new_submissions_to_score
if old_s + old_t == 0:
self.add_timeout(self.score_old_submissions,
None,
0.5,
immediately=False)
def invalidate_submission(self,
submission_id=None,
user_id=None,
task_id=None):
"""Request for invalidating some scores.
Invalidate the scores of the Submission whose ID is
submission_id or, if None, of those whose user is user_id
and/or whose task is task_id or, if both None, of those that
belong to the contest this service is running for.
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user to invalidate, or None.
task_id (int): id of the task to invalidate, or None.
"""
logger.info("Invalidation request received.")
# Validate arguments
# TODO Check that all these objects belong to this contest.
with SessionGen(commit=True) as session:
submissions = get_submissions(
# Give contest_id only if all others are None.
self.contest_id
if {user_id, task_id, submission_id} == {None}
else None,
user_id, task_id, submission_id, session)
logger.info("Submissions to invalidate scores for: %d." %
len(submissions))
if len(submissions) == 0:
return
new_submissions_to_score = set()
for submission in submissions:
# If the submission is not evaluated, it does not have
# a score to invalidate, and, when evaluated,
# ScoringService will be prompted to score it. So in
# that case we do not have to do anything.
if submission.evaluated():
submission.invalidate_score()
new_submissions_to_score.add(submission.id)
old_s = len(self.submissions_to_score)
old_t = len(self.submissions_to_token)
self.submissions_to_score |= new_submissions_to_score
if old_s + old_t == 0:
self.add_timeout(self.score_old_submissions, None,
0.5, immediately=False)
def invalidate_submission(self,
submission_id=None,
user_id=None,
task_id=None):
"""Request for invalidating the scores of some submissions.
The scores to be cleared are the one regarding 1) a submission
or 2) all submissions of a user or 3) all submissions of a
task or 4) all submission (if all parameters are None).
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user we want to invalidate, or None.
task_id (int): id of the task we want to invalidate, or None.
"""
logger.info("Invalidation request received.")
submission_ids = get_submissions(self.contest_id, submission_id,
user_id, task_id)
logger.info("Submissions to invalidate: %s" % len(submission_ids))
if len(submission_ids) == 0:
return
new_submission_ids = []
with SessionGen(commit=True) as session:
for submission_id in submission_ids:
submission = Submission.get_from_id(submission_id, session)
# If the submission is not evaluated, it does not have
# a score to invalidate, and, when evaluated,
# ScoringService will be prompted to score it. So in
# that case we do not have to do anything.
if submission.evaluated():
submission.invalidate_score()
new_submission_ids.append(submission_id)
old_s = len(self.submission_ids_to_score)
old_t = len(self.submission_ids_to_token)
self.submission_ids_to_score |= new_submission_ids
if old_s + old_t == 0:
self.add_timeout(self.score_old_submissions,
None,
0.5,
immediately=False)
def invalidate_submission(self,
submission_id=None,
user_id=None,
task_id=None):
"""Request for invalidating the scores of some submissions.
The scores to be cleared are the one regarding 1) a submission
or 2) all submissions of a user or 3) all submissions of a
task or 4) all submission (if all parameters are None).
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user we want to invalidate, or None.
task_id (int): id of the task we want to invalidate, or None.
"""
logger.info("Invalidation request received.")
submission_ids = get_submissions(
self.contest_id,
submission_id, user_id, task_id)
logger.info("Submissions to invalidate: %s" % len(submission_ids))
if len(submission_ids) == 0:
return
new_submission_ids = []
with SessionGen(commit=True) as session:
for submission_id in submission_ids:
submission = Submission.get_from_id(submission_id, session)
# If the submission is not evaluated, it does not have
# a score to invalidate, and, when evaluated,
# ScoringService will be prompted to score it. So in
# that case we do not have to do anything.
if submission.evaluated():
submission.invalidate_score()
new_submission_ids.append(submission_id)
old_s = len(self.submission_ids_to_score)
old_t = len(self.submission_ids_to_token)
self.submission_ids_to_score |= set(new_submission_ids)
if old_s + old_t == 0:
self.add_timeout(self.score_old_submissions, None,
0.5, immediately=False)
def invalidate_submission(self,
submission_id=None,
user_id=None,
task_id=None):
"""Request for invalidating the scores of some submissions.
The scores to be cleared are the one regarding 1) a submission
or 2) all submissions of a user or 3) all submissions of a
task or 4) all submission (if all parameters are None).
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user we want to invalidate, or None.
task_id (int): id of the task we want to invalidate, or None.
"""
logger.info("Invalidation request received.")
submission_ids = get_submissions(self.contest_id, submission_id,
user_id, task_id)
logger.info("Submissions to invalidate: %s" % len(submission_ids))
if len(submission_ids) == 0:
return
with SessionGen(commit=True) as session:
for submission_id in submission_ids:
submission = Submission.get_from_id(submission_id, session)
submission.invalidate_score()
old_s = len(self.submission_ids_to_score)
old_t = len(self.submission_ids_to_token)
self.submission_ids_to_score = submission_ids + \
self.submission_ids_to_score
if old_s + old_t == 0:
self.add_timeout(self.score_old_submissions,
None,
0.5,
immediately=False)
def invalidate_submission(self,
submission_id=None,
user_id=None,
task_id=None):
"""Request for invalidating the scores of some submissions.
The scores to be cleared are the one regarding 1) a submission
or 2) all submissions of a user or 3) all submissions of a
task or 4) all submission (if all parameters are None).
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user we want to invalidate, or None.
task_id (int): id of the task we want to invalidate, or None.
"""
logger.info("Invalidation request received.")
submission_ids = get_submissions(
self.contest_id,
submission_id, user_id, task_id)
logger.info("Submissions to invalidate: %s" % len(submission_ids))
if len(submission_ids) == 0:
return
with SessionGen(commit=True) as session:
for submission_id in submission_ids:
submission = Submission.get_from_id(submission_id, session)
submission.invalidate_score()
old_s = len(self.submission_ids_to_score)
old_t = len(self.submission_ids_to_token)
self.submission_ids_to_score = submission_ids + \
self.submission_ids_to_score
if old_s + old_t == 0:
self.add_timeout(self.score_old_submissions, None,
0.5, immediately=False)
def invalidate_submission(self,
contest_id=None,
submission_id=None,
dataset_id=None,
participation_id=None,
task_id=None,
level="compilation"):
"""Request to invalidate some computed data.
Invalidate the compilation and/or evaluation data of the
SubmissionResults that:
- belong to submission_id or, if None, to any submission of
participation_id and/or task_id or, if both None, to any
submission of the contest asked for, or, if all three are
None, the contest this service is running for (or all contests).
- belong to dataset_id or, if None, to any dataset of task_id
or, if None, to any dataset of any task of the contest this
service is running for.
The data is cleared, the operations involving the submissions
currently enqueued are deleted, and the ones already assigned to
the workers are ignored. New appropriate operations are
enqueued.
submission_id (int|None): id of the submission to invalidate,
or None.
dataset_id (int|None): id of the dataset to invalidate, or
None.
participation_id (int|None): id of the participation to
invalidate, or None.
task_id (int|None): id of the task to invalidate, or None.
level (string): 'compilation' or 'evaluation'
"""
logger.info("Invalidation request received.")
# Validate arguments
# TODO Check that all these objects belong to this contest.
if level not in ("compilation", "evaluation"):
raise ValueError("Unexpected invalidation level `%s'." % level)
if contest_id is None:
contest_id = self.contest_id
with SessionGen() as session:
# When invalidating a dataset we need to know the task_id, otherwise
# get_submissions will return all the submissions of the contest.
if dataset_id is not None and task_id is None \
and submission_id is None:
task_id = Dataset.get_from_id(dataset_id, session).task_id
# First we load all involved submissions.
submissions = get_submissions(
# Give contest_id only if all others are None.
contest_id if {participation_id, task_id, submission_id}
== {None} else None,
participation_id,
task_id,
submission_id,
session)
# Then we get all relevant operations, and we remove them
# both from the queue and from the pool (i.e., we ignore
# the workers involved in those operations).
operations = get_relevant_operations(level, submissions,
dataset_id)
for operation in operations:
try:
self.dequeue(operation)
except KeyError:
pass # Ok, the operation wasn't in the queue.
try:
self.get_executor().pool.ignore_operation(operation)
except LookupError:
pass # Ok, the operation wasn't in the pool.
# Then we find all existing results in the database, and
# we remove them.
submission_results = get_submission_results(
# Give contest_id only if all others are None.
contest_id if {
participation_id, task_id, submission_id, dataset_id
} == {None} else None,
participation_id,
# Provide the task_id only if the entire task has to be
# reevaluated and not only a specific dataset.
task_id if dataset_id is None else None,
submission_id,
dataset_id,
session)
logger.info("Submission results to invalidate %s for: %d.", level,
len(submission_results))
for submission_result in submission_results:
# We invalidate the appropriate data and queue the
# operations to recompute those data.
if level == "compilation":
submission_result.invalidate_compilation()
elif level == "evaluation":
submission_result.invalidate_evaluation()
# Finally, we re-enqueue the operations for the
# submissions.
for submission in submissions:
self.submission_enqueue_operations(submission)
session.commit()
logger.info("Invalidate successfully completed.")
def invalidate_submission(self,
submission_id=None,
user_id=None,
task_id=None,
level="compilation"):
"""Request for invalidating some computed data.
The data (compilations and evaluations, or evaluations only)
to be cleared are the one regarding 1) a submission or 2) all
submissions of a user or 3) all submissions of a task or 4)
all submission (if all parameters are None).
The data are cleared, the jobs involving the submissions
currently enqueued are deleted, and the one already assigned
to the workers are ignored. New appropriate jobs are enqueued.
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user we want to invalidate, or None.
task_id (int): id of the task we want to invalidate, or None.
level (string): 'compilation' or 'evaluation'
"""
logger.info("Invalidation request received.")
if level not in ["compilation", "evaluation"]:
err_msg = "Unexpected invalidation level `%s'." % level
logger.warning(err_msg)
raise ValueError(err_msg)
submission_ids = get_submissions(
self.contest_id,
submission_id, user_id, task_id)
logger.info("Submissions to invalidate for %s: %s." %
(level, len(submission_ids)))
if len(submission_ids) == 0:
return
for submission_id in submission_ids:
jobs = [(EvaluationService.JOB_TYPE_COMPILATION, submission_id),
(EvaluationService.JOB_TYPE_EVALUATION, submission_id)]
for job in jobs:
try:
self.queue.remove(job)
except KeyError:
pass # Ok, the job wasn't in the queue.
try:
self.pool.ignore_job(job)
except LookupError:
pass # Ok, the job wasn't in the pool.
# We invalidate the appropriate data and queue the jobs to
# recompute those data.
with SessionGen(commit=True) as session:
for submission_id in submission_ids:
submission = Submission.get_from_id(submission_id, session)
if level == "compilation":
submission.invalidate_compilation()
if to_compile(submission):
self.push_in_queue(
(EvaluationService.JOB_TYPE_COMPILATION,
submission_id),
EvaluationService.JOB_PRIORITY_HIGH,
submission.timestamp)
elif level == "evaluation":
submission.invalidate_evaluation()
if to_evaluate(submission):
self.push_in_queue(
(EvaluationService.JOB_TYPE_EVALUATION,
submission_id),
EvaluationService.JOB_PRIORITY_MEDIUM,
submission.timestamp)
def invalidate_submission(self,
contest_id=None,
submission_id=None,
dataset_id=None,
participation_id=None,
task_id=None,
testcases=None,
overwrite=None,
force_priority=None,
level="compilation"):
"""Request to invalidate some computed data.
Invalidate the compilation and/or evaluation data of the
SubmissionResults that:
- belong to submission_id or, if None, to any submission of
participation_id and/or task_id or, if both None, to any
submission of the contest asked for, or, if all three are
None, the contest this service is running for (or all contests).
- belong to dataset_id or, if None, to any dataset of task_id
or, if None, to any dataset of any task of the contest this
service is running for.
The data is cleared, the operations involving the submissions
currently enqueued are deleted, and the ones already assigned to
the workers are ignored. New appropriate operations are
enqueued.
submission_id (int|None): id of the submission to invalidate,
or None.
dataset_id (int|None): id of the dataset to invalidate, or
None.
participation_id (int|None): id of the participation to
invalidate, or None.
task_id (int|None): id of the task to invalidate, or None.
level (string): 'compilation' or 'evaluation'
"""
logger.info("Invalidation request received.")
# Avoid running the sweeper for the next 10-ish minutes, to
# avoid race conditions between invalidate's requeuing of
# submissions and the sweeper's.
self.avoid_next_sweepers = 1
# Validate arguments
# TODO Check that all these objects belong to this contest.
if level not in ("compilation", "evaluation"):
raise ValueError("Unexpected invalidation level `%s'." % level)
if contest_id is None:
contest_id = self.contest_id
with SessionGen() as session:
# First we load all involved submissions.
if (dataset_id is not None) and (submission_id is None):
dataset = Dataset.get_from_id(dataset_id, session)
task_id_for_submissions = dataset.task_id
else:
task_id_for_submissions = task_id
submissions = get_submissions(
# Give contest_id only if all others are None.
contest_id if {
participation_id, task_id_for_submissions, submission_id
} == {None} else None,
participation_id,
task_id_for_submissions,
submission_id,
session)
# Then we get all relevant operations, and we remove them
# both from the queue and from the pool (i.e., we ignore
# the workers involved in those operations).
operations = get_relevant_operations(level, submissions,
dataset_id, testcases)
for operation in operations:
try:
self.dequeue(operation)
except KeyError:
pass # Ok, the operation wasn't in the queue.
try:
self.get_executor().pool.ignore_operation(operation)
except LookupError:
pass # Ok, the operation wasn't in the pool.
# Then we find all existing results in the database, and
# we remove them.
submission_results = get_submission_results(
# Give contest_id only if all others are None.
contest_id if {
participation_id, task_id, submission_id, dataset_id
} == {None} else None,
participation_id,
task_id,
submission_id,
dataset_id,
session)
logger.info("Submission results to invalidate %s for: %d.", level,
len(submission_results))
for submission_result in submission_results:
# We invalidate the appropriate data and queue the
# operations to recompute those data.
if level == "compilation":
submission_result.invalidate_compilation(
testcases if overwrite is not False else [])
elif level == "evaluation":
submission_result.invalidate_evaluation(
testcases if overwrite is not False else [])
# There is a small chance that an invalidate won't
# succeed: if a result is in the pending structure, it
# might be written after the commit here.
session.commit()
# Collecting the ids so that we can close the session
# before the rpcs.
submission_ids = [submission.id for submission in submissions]
# Finally, we re-enqueue the operations for the submissions.
for idx in range(0, len(submission_ids), 500):
random_service(self.evaluation_services).new_submissions(
submission_ids=submission_ids[idx:min(idx +
500, len(submission_ids
))],
dataset_id=dataset_id,
force_priority=force_priority)
logger.info("Invalidate successfully completed.")
def invalidate_submission(self,
contest_id=None,
submission_id=None,
dataset_id=None,
participation_id=None,
task_id=None,
level="compilation"):
"""Request to invalidate some computed data.
Invalidate the compilation and/or evaluation data of the
SubmissionResults that:
- belong to submission_id or, if None, to any submission of
participation_id and/or task_id or, if both None, to any
submission of the contest asked for, or, if all three are
None, the contest this service is running for (or all contests).
- belong to dataset_id or, if None, to any dataset of task_id
or, if None, to any dataset of any task of the contest this
service is running for.
The data is cleared, the operations involving the submissions
currently enqueued are deleted, and the ones already assigned to
the workers are ignored. New appropriate operations are
enqueued.
submission_id (int|None): id of the submission to invalidate,
or None.
dataset_id (int|None): id of the dataset to invalidate, or
None.
participation_id (int|None): id of the participation to
invalidate, or None.
task_id (int|None): id of the task to invalidate, or None.
level (string): 'compilation' or 'evaluation'
"""
logger.info("Invalidation request received.")
# Validate arguments
# TODO Check that all these objects belong to this contest.
if level not in ("compilation", "evaluation"):
raise ValueError(
"Unexpected invalidation level `%s'." % level)
if contest_id is None:
contest_id = self.contest_id
with SessionGen() as session:
# First we load all involved submissions.
submissions = get_submissions(
# Give contest_id only if all others are None.
contest_id
if {participation_id, task_id, submission_id} == {None}
else None,
participation_id, task_id, submission_id, session)
# Then we get all relevant operations, and we remove them
# both from the queue and from the pool (i.e., we ignore
# the workers involved in those operations).
operations = get_relevant_operations(
level, submissions, dataset_id)
for operation in operations:
try:
self.dequeue(operation)
except KeyError:
pass # Ok, the operation wasn't in the queue.
try:
self.get_executor().pool.ignore_operation(operation)
except LookupError:
pass # Ok, the operation wasn't in the pool.
# Then we find all existing results in the database, and
# we remove them.
submission_results = get_submission_results(
# Give contest_id only if all others are None.
contest_id
if {participation_id,
task_id,
submission_id,
dataset_id} == {None}
else None,
participation_id, task_id, submission_id, dataset_id, session)
logger.info("Submission results to invalidate %s for: %d.",
level, len(submission_results))
for submission_result in submission_results:
# We invalidate the appropriate data and queue the
# operations to recompute those data.
if level == "compilation":
submission_result.invalidate_compilation()
elif level == "evaluation":
submission_result.invalidate_evaluation()
# Finally, we re-enqueue the operations for the
# submissions.
for submission in submissions:
self.submission_enqueue_operations(submission)
session.commit()
logger.info("Invalidate successfully completed.")
def invalidate_submission(self,
submission_id=None,
user_id=None,
dataset_id=None,
task_id=None):
"""Request for invalidating the scores of some submissions.
The scores to be cleared are the one regarding
1) a submission (only submission_id and dataset_id given)
or 2) all submissions of a user for the active dataset (only user_id
given)
or 3) all submissions for a dataset (only dataset_id given)
submission_id (int): id of the submission to invalidate, or
None.
user_id (int): id of the user we want to invalidate, or None.
dataset_id (int): id of the dataset we want to invalidate, or None.
"""
logger.info("Invalidation request received.")
# If we are invalidating a dataset, get the task so we can find all the
# relevant submissions.
if submission_id is None and dataset_id is not None:
with SessionGen(commit=False) as session:
dataset = Dataset.get_from_id(dataset_id, session)
task_id = dataset.task_id
else:
task_id = None
submission_ids = get_submissions(
self.contest_id,
submission_id, user_id, task_id)
logger.info("Submissions to invalidate: %s" % len(submission_ids))
if len(submission_ids) == 0:
return
new_submission_ids = []
with SessionGen(commit=True) as session:
for submission_id in submission_ids:
submission = Submission.get_from_id(submission_id, session)
if dataset_id is None:
this_dataset_id = submission.task.active_dataset_id
else:
this_dataset_id = dataset_id
sr = SubmissionResult.get_from_id(
(submission_id, this_dataset_id), session)
# If the submission is not evaluated, it does not have
# a score to invalidate, and, when evaluated,
# ScoringService will be prompted to score it. So in
# that case we do not have to do anything.
if sr is not None and sr.evaluated():
sr.invalidate_score()
new_submission_ids.append((submission_id, this_dataset_id))
old_s = len(self.submission_ids_to_score)
old_t = len(self.submission_ids_to_token)
self.submission_ids_to_score |= set(new_submission_ids)
if old_s + old_t == 0:
self.add_timeout(self.score_old_submissions, None,
0.5, immediately=False)
