def test_register_ip_submission(self):
self._insert_data()
Database.add_submission("submissionid", "inputid", "outputid",
"sourceid", 42)
self.register_ip(submission_id="submissionid", _ip="1.1.1.1")
users = Database.get_users()
self.assertEqual("1.1.1.1", users[0]["ip"][0]["ip"])
def analyze_pack(pack, workdir, token, all, source_only, no_group_venue,
outdir):
packname = os.path.basename(pack)[:4]
if packname[3] == "0":
packname = packname[:3]
with common.extract_and_connect(pack, workdir):
users = Database.get_users()
if token:
users = list(filter(lambda u: u["token"] in token, users))
if not users:
return False
for user in users:
token = user["token"]
print("Found user %s %s" % (user["name"], user["surname"]))
tasks = common.get_tasks()
num_submissions = 0
for task in tasks:
submissions = Database.get_submissions(token, task)
num_submissions += len(submissions)
if no_group_venue:
taskdir = os.path.join(outdir, task, token)
else:
taskdir = os.path.join(outdir, packname, task, token)
os.makedirs(taskdir, exist_ok=True)
if not all:
best = max(submissions,
key=lambda x: x["score"],
default=None)
if best:
submissions = [best]
for submission in submissions:
store_submission(submission, taskdir, workdir, source_only)
print(" > %d submissions" % num_submissions, file=sys.stderr)
return len(token) == 1 and num_submissions > 0
def test_read_from_disk(self):
path = Utils.new_tmp_dir()
self._prepare_contest_dir(path)
Config.statementdir = Utils.new_tmp_dir()
Config.contest_path = path
with patch("gevent.spawn") as mock:
ContestManager.read_from_disk()
mock.assert_has_calls(
[call(ContestManager.worker, "poldo")], any_order=True)
self.assertEqual(18000, Database.get_meta(
"contest_duration", type=int))
tasks = Database.get_tasks()
self.assertEqual(1, len(tasks))
self.assertEqual("poldo", tasks[0]["name"])
self.assertEqual("Poldo", tasks[0]["title"])
self.assertEqual(42, tasks[0]["max_score"])
self.assertEqual(0, tasks[0]["num"])
users = Database.get_users()
self.assertEqual(1, len(users))
self.assertEqual("token", users[0]["token"])
self.assertEqual("Test", users[0]["name"])
self.assertEqual("User", users[0]["surname"])
self.assertEqual(0, users[0]["extra_time"])
user_tasks = Database.get_user_task("token", "poldo")
self.assertEqual("token", user_tasks["token"])
self.assertEqual("poldo", user_tasks["task"])
self.assertEqual(0, user_tasks["score"])
self.assertIsNone(user_tasks["current_attempt"])
self.assertTrue(Database.get_meta("contest_imported", type=bool))
self.assertTrue(ContestManager.has_contest)
self.assertIn("poldo", ContestManager.tasks)
self.assertIn("poldo", ContestManager.input_queue)
def user_list(self):
"""
POST /admin/user_list
"""
return BaseHandler.format_dates({"items": Database.get_users()},
fields=["first_date"])
def read_from_disk(remove_enc=True):
"""
Load a task from the disk and load the data into the database
"""
try:
contest = ContestManager.import_contest(Config.contest_path)
except FileNotFoundError as ex:
error = (
"Contest not found, you probably need to unzip it. Missing file %s"
% ex.filename)
Logger.warning("CONTEST", error)
shutil.rmtree(Config.statementdir, ignore_errors=True)
shutil.rmtree(Config.web_statementdir, ignore_errors=True)
shutil.rmtree(Config.contest_path, ignore_errors=True)
if remove_enc:
with suppress(Exception):
os.remove(Config.encrypted_file)
with suppress(Exception):
os.remove(Config.decrypted_file)
Database.del_meta("admin_token")
BaseHandler.raise_exc(UnprocessableEntity, "CONTEST", error)
if not Database.get_meta("contest_imported", default=False, type=bool):
Database.begin()
try:
Database.set_meta("contest_duration",
contest["duration"],
autocommit=False)
Database.set_meta("contest_name",
contest.get("name", "Contest"),
autocommit=False)
Database.set_meta(
"contest_description",
contest.get("description", ""),
autocommit=False,
)
Database.set_meta(
"window_duration",
# if None the contest is not USACO-style
contest.get("window_duration"),
autocommit=False,
)
count = 0
for task in contest["tasks"]:
Database.add_task(
task["name"],
task["description"],
task["statement_path"],
task["max_score"],
count,
autocommit=False,
)
count += 1
for user in contest["users"]:
Database.add_user(user["token"],
user["name"],
user["surname"],
autocommit=False)
for user in Database.get_users():
for task in Database.get_tasks():
Database.add_user_task(user["token"],
task["name"],
autocommit=False)
Database.set_meta("contest_imported", True, autocommit=False)
Database.commit()
except:
Database.rollback()
raise
else:
# TODO: check that the contest is still the same
pass
# store the task in the ContestManager singleton
ContestManager.tasks = dict(
(task["name"], task) for task in contest["tasks"])
ContestManager.has_contest = True
# create the queues for the task inputs
for task in ContestManager.tasks:
ContestManager.input_queue[task] = gevent.queue.Queue(
Config.queue_size)
gevent.spawn(ContestManager.worker, task)
def test_register_ip_source(self):
self._insert_data()
self.register_ip(source_id="sourceid", _ip="1.1.1.1")
users = Database.get_users()
self.assertEqual("1.1.1.1", users[0]["ip"][0]["ip"])
def test_register_ip_output(self):
self._insert_data()
self.register_ip(output_id="outputid", _ip="1.1.1.1")
users = Database.get_users()
self.assertEqual("1.1.1.1", users[0]["ip"][0]["ip"])
def test_register_ip_token(self):
self._insert_data()
self.register_ip(token="token", _ip="1.1.1.1")
users = Database.get_users()
self.assertEqual("1.1.1.1", users[0]["ip"][0]["ip"])
