"Field 'extra_headers' isn't a list of strings"
assert isinstance(data['order'], int), \
"Field 'order' isn't an integer"
except KeyError as exc:
raise InvalidData("Field %s is missing" % exc.message)
except AssertionError as exc:
raise InvalidData(exc.message)
def set(self, data):
self.validate(data)
self.name = data['name']
self.short_name = data['short_name']
self.contest = data['contest']
self.max_score = data['max_score']
self.score_precision = data['score_precision']
self.extra_headers = data['extra_headers']
self.order = data['order']
self.score_mode = data['score_mode']
def get(self):
result = self.__dict__.copy()
del result['key']
return result
def consistent(self):
from cmsranking.Contest import store as contest_store
return self.contest in contest_store
store = Store(Task, 'tasks', [submission_store])
"Field 'name' isn't a string"
assert isinstance(data['begin'], int), \
"Field 'begin' isn't an integer"
assert isinstance(data['end'], int), \
"Field 'end' isn't an integer"
assert data['begin'] <= data['end'], \
"Field 'begin' is greater than 'end'"
assert isinstance(data['score_precision'], int), \
"Field 'score_precision' isn't an integer"
assert data['score_precision'] >= 0, \
"Field 'score_precision' is negative"
except KeyError as exc:
raise InvalidData("Field %s is missing" % exc.message)
except AssertionError as exc:
raise InvalidData(exc.message)
def set(self, data):
self.validate(data)
self.name = data['name']
self.begin = data['begin']
self.end = data['end']
self.score_precision = data['score_precision']
def get(self):
result = self.__dict__.copy()
del result['key']
return result
store = Store(Contest, 'contests', [task_store])
for i in data['extra']:
assert isinstance(i, str), \
"Field 'extra' isn't a list of strings"
except KeyError as exc:
raise InvalidData("Field %s is missing" % exc.message)
except AssertionError as exc:
raise InvalidData(exc.message)
def set(self, data):
self.validate(data)
self.submission = data['submission']
self.time = data['time']
self.score = (data['score'] if 'score' in data else None)
self.token = (data['token'] if 'token' in data else None)
self.extra = (data['extra'] if 'extra' in data else None)
def get(self):
result = self.__dict__.copy()
del result['key']
for field in ['score', 'token', 'extra']:
if result[field] is None:
del result[field]
return result
def consistent(self):
from cmsranking.Submission import store as submission_store
return self.submission in submission_store
store = Store(Subchange, 'subchanges')
except AssertionError as message:
raise InvalidData(str(message))
def set(self, data):
self.validate(data)
self.f_name = data['f_name']
self.l_name = data['l_name']
self.team = data['team']
def get(self):
result = self.__dict__.copy()
del result["key"]
return result
def load(self, data):
self.validate(data)
self.f_name = data['f_name']
self.l_name = data['l_name']
self.team = data['team']
def dump(self):
result = self.__dict__.copy()
del result["key"]
return result
def consistent(self):
return self.team is None or self.team in Team.store
store = Store(User, 'users', [Submission])
self.name = None
@staticmethod
def validate(data):
"""Validate the given dictionary.
See if it contains a valid representation of this entity.
"""
try:
assert isinstance(data, dict), \
"Not a dictionary"
assert isinstance(data['name'], str), \
"Field 'name' isn't a string"
except KeyError as exc:
raise InvalidData("Field %s is missing" % exc.message)
except AssertionError as exc:
raise InvalidData(exc.message)
def set(self, data):
self.validate(data)
self.name = data['name']
def get(self):
result = self.__dict__.copy()
del result['key']
return result
store = Store(Team, 'teams', [user_store])
def main():
"""Entry point for RWS.
return (int): exit code (0 on success, 1 on error)
"""
parser = argparse.ArgumentParser(
description="Ranking for CMS.")
parser.add_argument("--config", type=argparse.FileType("rt"),
help="override config file")
parser.add_argument("-d", "--drop", action="store_true",
help="drop the data already stored")
args = parser.parse_args()
config = Config()
config.load(args.config)
if args.drop:
ans = input("Are you sure you want to delete directory %s? [y/N]" %
config.lib_dir).strip().lower()
if ans in ['y', 'yes']:
print("Removing directory %s." % config.lib_dir)
shutil.rmtree(config.lib_dir)
else:
print("Not removing directory %s." % config.lib_dir)
return 1
stores = dict()
stores["subchange"] = Store(
Subchange, os.path.join(config.lib_dir, 'subchanges'), stores)
stores["submission"] = Store(
Submission, os.path.join(config.lib_dir, 'submissions'), stores,
[stores["subchange"]])
stores["user"] = Store(
User, os.path.join(config.lib_dir, 'users'), stores,
[stores["submission"]])
stores["team"] = Store(
Team, os.path.join(config.lib_dir, 'teams'), stores,
[stores["user"]])
stores["task"] = Store(
Task, os.path.join(config.lib_dir, 'tasks'), stores,
[stores["submission"]])
stores["contest"] = Store(
Contest, os.path.join(config.lib_dir, 'contests'), stores,
[stores["task"]])
stores["contest"].load_from_disk()
stores["task"].load_from_disk()
stores["team"].load_from_disk()
stores["user"].load_from_disk()
stores["submission"].load_from_disk()
stores["subchange"].load_from_disk()
stores["scoring"] = ScoringStore(stores)
stores["scoring"].init_store()
toplevel_handler = RoutingHandler(
DataWatcher(stores, config.buffer_size),
ImageHandler(
os.path.join(config.lib_dir, '%(name)s'),
os.path.join(config.web_dir, 'img', 'logo.png')),
ScoreHandler(stores),
HistoryHandler(stores))
wsgi_app = SharedDataMiddleware(DispatcherMiddleware(
toplevel_handler, {
'/contests': StoreHandler(
stores["contest"],
config.username, config.password, config.realm_name),
'/tasks': StoreHandler(
stores["task"],
config.username, config.password, config.realm_name),
'/teams': StoreHandler(
stores["team"],
config.username, config.password, config.realm_name),
'/users': StoreHandler(
stores["user"],
config.username, config.password, config.realm_name),
'/submissions': StoreHandler(
stores["submission"],
config.username, config.password, config.realm_name),
'/subchanges': StoreHandler(
stores["subchange"],
config.username, config.password, config.realm_name),
'/faces': ImageHandler(
os.path.join(config.lib_dir, 'faces', '%(name)s'),
os.path.join(config.web_dir, 'img', 'face.png')),
'/flags': ImageHandler(
os.path.join(config.lib_dir, 'flags', '%(name)s'),
os.path.join(config.web_dir, 'img', 'flag.png')),
'/sublist': SubListHandler(stores),
}), {'/': config.web_dir})
servers = list()
if config.http_port is not None:
http_server = WSGIServer(
(config.bind_address, config.http_port), wsgi_app)
servers.append(http_server)
if config.https_port is not None:
https_server = WSGIServer(
(config.bind_address, config.https_port), wsgi_app,
certfile=config.https_certfile, keyfile=config.https_keyfile)
servers.append(https_server)
try:
gevent.joinall(list(gevent.spawn(s.serve_forever) for s in servers))
except KeyboardInterrupt:
pass
finally:
gevent.joinall(list(gevent.spawn(s.stop) for s in servers))
return 0
"Not a dictionary"
assert isinstance(data['f_name'], six.text_type), \
"Field 'f_name' isn't a string"
assert isinstance(data['l_name'], six.text_type), \
"Field 'l_name' isn't a string"
assert data['team'] is None or \
isinstance(data['team'], six.text_type), \
"Field 'team' isn't a string (or null)"
except KeyError as exc:
raise InvalidData("Field %s is missing" % exc.message)
except AssertionError as exc:
raise InvalidData(exc.message)
def set(self, data):
self.validate(data)
self.f_name = data['f_name']
self.l_name = data['l_name']
self.team = data['team']
def get(self):
result = self.__dict__.copy()
del result['key']
return result
def consistent(self):
from cmsranking.Team import store as team_store
return self.team is None or self.team in team_store
store = Store(User, 'users', [submission_store])
assert isinstance(data['task'], str), \
"Field 'task' isn't a string"
assert isinstance(data['time'], int), \
"Field 'time' isn't an integer (unix timestamp)"
except KeyError as exc:
raise InvalidData("Field %s is missing" % exc.message)
except AssertionError as exc:
raise InvalidData(exc.message)
def set(self, data):
self.validate(data)
self.user = data['user']
self.task = data['task']
self.time = data['time']
def get(self):
result = self.__dict__.copy()
del result['key']
del result['score']
del result['token']
del result['extra']
return result
def consistent(self):
from cmsranking.Task import store as task_store
from cmsranking.User import store as user_store
return self.task in task_store and self.user in user_store
store = Store(Submission, 'submissions', [subchange_store])
self.short_name = data['short_name']
self.contest = data['contest']
self.max_score = data['max_score']
self.extra_headers = data['extra_headers']
self.order = data['order']
def get(self):
result = self.__dict__.copy()
del result["key"]
return result
def load(self, data):
self.validate(data)
self.name = data['name']
self.short_name = data['short_name']
self.contest = data['contest']
self.max_score = data['max_score']
self.extra_headers = data['extra_headers']
self.order = data['order']
def dump(self):
result = self.__dict__.copy()
del result["key"]
return result
def consistent(self):
return self.contest in Contest.store
store = Store(Task, 'tasks', [Submission])
assert type(data) is dict, \
"Not a dictionary"
assert type(data['name']) is unicode or \
type(data['name']) is str, \
"Field 'name' isn't a string"
except KeyError as field:
raise InvalidData("Field %s is missing" % field)
except AssertionError as message:
raise InvalidData(str(message))
def set(self, data):
self.validate(data)
self.name = data['name']
def get(self):
result = self.__dict__.copy()
del result["key"]
return result
def load(self, data):
self.validate(data)
self.name = data['name']
def dump(self):
result = self.__dict__.copy()
del result["key"]
return result
store = Store(Team, 'teams', [User])
self.task = data['task']
self.time = data['time']
def get(self):
result = self.__dict__.copy()
del result["key"]
del result["score"]
del result["token"]
del result["extra"]
return result
def load(self, data):
self.validate(data)
self.user = data['user']
self.task = data['task']
self.time = data['time']
def dump(self):
result = self.__dict__.copy()
del result["key"]
del result["score"]
del result["token"]
del result["extra"]
return result
def consistent(self):
return self.task in Task.store and self.user in User.store
store = Store(Submission, 'submissions', [Subchange])
"Field 'begin' is greater than 'end'"
except KeyError as field:
raise InvalidData("Field %s is missing" % field)
except AssertionError as message:
raise InvalidData(str(message))
def set(self, data):
self.validate(data)
self.name = data['name']
self.begin = data['begin']
self.end = data['end']
def get(self):
result = self.__dict__.copy()
del result["key"]
return result
def load(self, data):
self.validate(data)
self.name = data['name']
self.begin = data['begin']
self.end = data['end']
def dump(self):
result = self.__dict__.copy()
del result["key"]
return result
store = Store(Contest, 'contests', [Task])
