def parse_gamelog(path):
"""
parse gamelog and return list of users
:param problemId: id (as string) of problem to process
:param path: path to directory with logs
:return: list of users
"""
users = []
firstLine = True
currentUser = None
with open(path, "r") as f:
for line in f:
if firstLine:
# First line contains the name of the problem, which can be arbitrary and can therefore interfere
# with conditions below. For example the problem "960" interferes with if re.match("\d",line)
firstLine = False
continue
if re.search("User", line):
uid = int(line.rstrip().split()[-1])
currentUser = User(uid)
users.append(currentUser)
if re.search("Game", line):
currentUser.games.append(Game())
if re.match("\d", line):
currentUser.games[-1].submits.append(
Submit.parsedFromStr(line))
return users
def _on_name_reply(self, connection, source, target, args, message):
channel_name = args[-1]
channel = self.find_channel(connection.server, channel_name)
if channel is not None:
for user in message.split():
channel.add_user(User.parse_user(user))
def _on_quit(self, connection, source, message):
user = User.channel_user(source.nick)
for channel in self.get_server_channels(connection.server):
channel.remove_user(user)
if user.nick == connection.server.nick:
# TODO: Change nick to connection.server.nick
pass
class Serialise(object):
""" convert a line into a fielded object """
def __init__(self, data, (connection, eventhandler)):
self._raw = data
self.connection = connection
self.eventhandler = eventhandler
# this regular expression splits an IRC line up into four parts:
# ORIGIN, TYPE, TARGET, MESSAGE
regex = "^(?:\:([^\s]+)\s)?([A-Za-z0-9]+)\s(?:([^\s\:]+)\s)?(?:\:?(.*))?$"
# a regular expression to match and dissect IRC protocol messages
# this is around 60% faster than not using a RE
p = re.compile(regex, re.VERBOSE)
try:
self.origin, self.type, self.target, self.message = (None, None,
None, None)
self._origin, self._type, self._target, self._message = p.match(
data).groups()
# turn each serialisable field into an object
self.origin = User.User(
self.connection,
self._origin) if self._origin is not None else None
self.type = Type.Type(
self._type) if self._type is not None else None
if self._target.startswith('#', 0, 1) is True:
self.target = Channel.Channel(
self.connection,
self._target) if self._target is not None else None
else:
self.target = User.User(
self.connection,
self._target) if self._target is not None else None
self.message = Message.Message(self._message)
except (AttributeError):
pass
try:
if logging.getLogger('ashiema').getEffectiveLevel(
) is logging.DEBUG and self.connection.debug is True:
if self.type and self.message:
logging.getLogger('ashiema').debug(
"%s %s %s %s" % (str(self.origin), str(
self.type), str(self.target), str(self.message)))
except:
[
logging.getLogger('ashiema').error(trace)
for trace in traceback.format_exc(5).split('\n')
]
pass
def add_user(self, username: str, password: str, role: str,
realname: str = None) -> dict:
"""This function adds a user to the system, using their username, password, role, and real name, and throwing that all into a dictionary.
Keyword arguments:
username -- unique identifier for a user
password -- users password
role -- users initial role
"""
if self._persist.retrieve(User, username):
return {"success": False, "message": "User already exists."}
hashed_password = self._hash_password(password)
self._persist.store(User(username, hashed_password, role, realname))
return {"success": True}
def _on_quit(self, connection, source, message):
user = User.channel_user(source.nick)
for channel in self.get_server_channels(connection.server):
channel.remove_user(user)
def _line_info(self, line):
"""Line format:
[:][<source>] <command> [<target>] [<args> ...][ :<message>]"""
raw_source, command, target, args, message = '', '', '', [], ''
split_line = line.split(' :', 1)
split_line_len = len(split_line)
if split_line_len == 1:
if line.startswith(':'):
split_prefix = line[1:].split()
else:
split_prefix = line.split()
elif split_line_len == 2:
irc_protocol_prefix, message = split_line
if irc_protocol_prefix.startswith(':'):
split_prefix = irc_protocol_prefix[1:].split()
else:
split_prefix = irc_protocol_prefix.split()
prefix_len = len(split_prefix)
if prefix_len == 3:
raw_source, command, target = split_prefix
if not self.server.actual_host:
self.server.actual_host = raw_source
elif prefix_len == 1:
command = split_prefix[0]
elif prefix_len == 2:
raw_source, command = split_prefix
elif prefix_len > 3:
(raw_source, command, target), args = (split_prefix[:3],
split_prefix[3:])
if not raw_source or raw_source == self.server.actual_host:
source = raw_source
else:
source = User.parse_user(raw_source)
is_channel = target and target[0] in '#&+!'
if command == Events.PRIVMSG and is_channel:
command = Events.PUBMSG
elif command == Events.MODE and not is_channel:
command = Events.UMODE
elif command == Events.NOTICE:
if is_channel:
command = Events.PUBNOTICE
else:
command = Events.PRIVNOTICE
if self.server.actual_nick and target == self.server.actual_nick:
target = User.parse_user(target)
line_info = {
'source': source,
'command': command,
'target': target,
'args': args,
'message': message.decode('utf-8')
}
for name, value in line_info.items():
if not value:
del line_info[name]
return line_info
def retrieve(self, structure: T, structure_id: str) -> T:
"""Retrieve a structure.
Keyword arguments:
structure -- class retrieve stored
structure_id -- the structure unique id
"""
structure_name = structure.__name__
self._ensure_structure_dict(structure_name)
if structure_id in self._shelf[structure_name]:
return self._shelf[structure_name][structure_id]
atexit.register(Persistence._cleanup)
if __name__ == "__main__":
p = Persistence("persist_test")
p._wipe()
from structures import User
user = User("test", "foo", "student")
user_id = user.id
p.store(user)
same_user = p.retrieve(User, user_id)
print(same_user is user)
structure -- class being stored
"""
structure_name = structure.__class__.__name__
self._ensure_structure_dict(structure_name)
self._shelf[structure_name][structure.id] = structure
def retrieve(self, structure: T, structure_id: str) -> T:
"""This method is used to retrieve structures from the shelf. It takes in the structure itself, as well as the
name of the structure so that it can be determined from multiple structures in a module.
Keyword arguments:
structure -- class retrieve stored
structure_id -- the structure unique id
"""
structure_name = structure.__name__
self._ensure_structure_dict(structure_name)
if structure_id in self._shelf[structure_name]:
return self._shelf[structure_name][structure_id]
atexit.register(Persistence._cleanup)
if __name__ == "__main__":
p = Persistence("persist_test")
p._wipe()
from structures import User
p.store(User("jackharrhy", "nice meme", "student"))
print(p._shelf["User"].keys())
def test_persistence_store_user(self):
new_user = User('foobar', 'baz', 'student')
storage.store(new_user)
same_user = storage.retrieve(User, new_user.id)
self.assertIsNotNone(same_user)
self.assertIsInstance(same_user, User)
structure -- class being stored
'''
structure_name = structure.__class__.__name__
self._ensure_structure_dict(structure_name)
self._shelf[structure_name][structure.id] = structure
def retrieve(self, structure: T, structure_id: str) -> T:
'''This method is used to retrieve structures from the shelf. It takes in the structure itself, as well as the
name of the structure so that it can be determined from multiple structures in a module.
Keyword arguments:
structure -- class retrieve stored
structure_id -- the structure unique id
'''
structure_name = structure.__name__
self._ensure_structure_dict(structure_name)
if structure_id in self._shelf[structure_name]:
return self._shelf[structure_name][structure_id]
atexit.register(Persistence._cleanup)
if __name__ == '__main__':
p = Persistence('persist_test')
p._wipe()
from structures import User
p.store(User('jackharrhy', 'nice meme', 'student'))
print(p._shelf['User'].keys())
def do_POST(self):
try:
if not parser.validatePostRequest(self.path):
return self.http_invalid_request()
queryType = self.path.strip('/').split('/')[0]
if queryType == 'RESET':
self.server.sqldb.reset_tables()
return self.http_ok()
elif queryType == 'D':
houseID = parser.getHouseID(self.path)
roomID = parser.getRoomID(self.path)
deviceType = parser.getDeviceType(self.path)
if not sql.are_ints([houseID, roomID, deviceType]):
return self.http_invalid_request()
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
newDevice = Device(houseID, None, deviceType, data, roomID)
deviceID = ''
if roomID == 0:
deviceID = self.server.sqldb.insert_house_device(newDevice)
else:
deviceID = self.server.sqldb.insert_room_device(newDevice)
return self.http_ok(deviceID, 'Content-Type', 'text')
elif queryType == 'R':
houseID = parser.getHouseID(self.path)
if not sql.are_ints([houseID]):
return self.http_invalid_request()
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
newRoom = Room(houseID, None, data, None)
roomID = self.server.sqldb.insert_room(newRoom)
return self.http_ok(roomID, 'Content-Type', 'text')
elif queryType == 'H':
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
newHouse = House(None, data, None, None)
try:
houseID = self.server.sqldb.insert_house(newHouse)
except:
self.send_response(333)
self.end_headers()
return self.http_ok(houseID, 'Content-Type', 'text')
elif queryType == 'U':
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
username = parser.getUserName(self.path)
password = parser.getUserPass(self.path)
if username is None or password is None:
return self.http_invalid_request()
userID = self.server.sqldb.get_user_id(username, password)
if not userID is None:
return self.http_resource_not_found()
newUser = User(None, username, password, None, data)
userID = self.server.sqldb.insert_user(newUser)
return self.http_ok(userID, 'Content-Type', 'text')
elif queryType == 'UU':
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
userID = parser.getUserID(self.path)
if not sql.are_ints([userID]):
return self.http_invalid_request()
stored = self.server.sqldb.get_user_data(userID)
if stored is None or stored == '':
return self.http_resource_not_found()
self.server.sqldb.update_user(userID, data)
return self.http_ok()
elif queryType == 'UPU':
userID = parser.getUserID(self.path)
userpass = parser.getUserPass(self.path)
if not sql.are_ints([userID]) or userpass is None:
return self.http_invalid_request()
stored = self.server.sqldb.get_user_data(userID)
if stored is None or stored == '':
return self.http_resource_not_found()
self.server.sqldb.update_user_pass(userID, userpass)
return self.http_ok()
elif queryType == 'UTU':
userID = parser.getUserID(self.path)
token = parser.getUserToken(self.path)
if not sql.are_ints([userID]):
return self.http_invalid_request()
stored = self.server.sqldb.get_user_data(userID)
if stored is None or stored == '':
return self.http_resource_not_found()
self.server.sqldb.update_user_token(userID, usertoken)
return self.http_ok()
elif queryType == 'UH':
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
houseID = parser.getHouseID(self.path)
if not sql.are_ints([houseID]):
return self.http_invalid_request()
# Ensure data is already there.
stored = self.server.sqldb.get_house_data(houseID)
if stored is None or stored == '':
return self.http_resource_not_found()
# Update the house data and send a 200.
self.server.sqldb.update_house(houseID, data)
return self.http_ok()
elif queryType == 'UR':
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
houseID = parser.getHouseID(self.path)
roomID = parser.getRoomID(self.path)
if not sql.are_ints([houseID, roomID]):
return self.http_invalid_request()
# Ensure data is already there.
stored = self.server.sqldb.get_room_data(houseID, roomID)
if stored is None or stored == '':
return self.http_resource_not_found()
# Update the room data and send a 200.
self.server.sqldb.update_room(houseID, roomID, data)
return self.http_ok()
elif queryType == 'UD':
length = int(self.headers.getheader('content-length', 0))
data = self.rfile.read(length)
houseID = parser.getHouseID(self.path)
roomID = parser.getRoomID(self.path)
deviceID = parser.getDeviceID(self.path)
if not sql.are_ints([houseID, roomID, deviceID]):
return self.http_invalid_request()
# Ensure data is already there.
stored = self.server.sqldb.get_device_data(
houseID, deviceID, roomID)
if stored is None or stored == '':
return self.http_resource_not_found()
# Update the device data and send a 200.
self.server.sqldb.update_device(houseID, deviceID, data,
roomID)
return self.http_ok()
except Exception, e:
sys.stdout.write(str(e) + '\n')
self.http_internal_error()
