Added raw packet builder command

does the hide tag even work lol

.gitignore

@@ -7,3 +7,4 @@ filters.txt
 redistest.py
 *.c
 *.so
+.pyenv

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "common"]
 	path = common
-	url = git@git.zxq.co:ripple/ripple-python-common.git
+	url = https://github.com/osufx/ripple-python-common.git

.landscape.yaml

@@ -0,0 +1,7 @@
+python-targets:
+  - 3
+pep8:
+  none: true
+pylint:
+  disable:
+    - cyclic-import

README.md

@@ -1,4 +1,4 @@
-## pep.py
+## pep.py [![Code Health](https://landscape.io/github/osuripple/pep.py/master/landscape.svg?style=flat)](https://landscape.io/github/osuripple/pep.py/master)
 
 - Origin: https://git.zxq.co/ripple/pep.py
 - Mirror: https://github.com/osuripple/pep.py

config.json

@@ -0,0 +1,18 @@
+{
+    "support-email": "support@ripple.moe",
+    "faq":
+    {
+        "rules": "Please make sure to check (Ripple's rules)[http://ripple.moe/?p=23].",
+        "swearing": "Please don't abuse swearing",
+        "spam": "Please don't spam",
+        "offend": "Please don't offend other players",
+        "github": "(Ripple's Github page!)[https://github.com/osuripple/ripple]",
+        "discord": "(Join Ripple's Discord!)[https://discord.gg/0rJcZruIsA6rXuIx]",
+        "blog": "You can find the latest Ripple news on the (blog)[https://ripple.moe/blog/]!",
+        "changelog": "Check the (changelog)[https://ripple.moe/index.php?p=17] !",
+        "status": "Check the server status (here!)[https://ripple.moe/index.php?p=27]",
+        "english": "Please keep this channel in english.",
+        "topic": "Can you please drop the topic and talk about something else?",
+        "lines": "Please try to keep your sentences on a single line to avoid getting silenced."
+    }
+}

constants/clientPackets.py

@@ -143,6 +143,26 @@ def transferHost(stream):
 def matchInvite(stream):
 	return packetHelper.readPacketData(stream, [["userID", dataTypes.UINT32]])
 
+def matchFrames(stream):
+	return packetHelper.readPacketData(stream,
+	[
+		["time", dataTypes.SINT32],
+		["id", dataTypes.BYTE],
+		["count300", dataTypes.UINT16],
+		["count100", dataTypes.UINT16],
+		["count50", dataTypes.UINT16],
+		["countGeki", dataTypes.UINT16],
+		["countKatu", dataTypes.UINT16],
+		["countMiss", dataTypes.UINT16],
+		["totalScore", dataTypes.SINT32],
+		["maxCombo", dataTypes.UINT16],
+		["currentCombo", dataTypes.UINT16],
+		["perfect", dataTypes.BYTE],
+		["currentHp", dataTypes.BYTE],
+		["tagByte", dataTypes.BYTE],
+		["usingScoreV2", dataTypes.BYTE]
+	])
+
 def tournamentMatchInfoRequest(stream):
 	return packetHelper.readPacketData(stream, [["matchID", dataTypes.UINT32]])
 

constants/exceptions.py

@@ -90,3 +90,18 @@ class unknownStreamException(Exception):
 
 class userTournamentException(Exception):
 	pass
+
+class userAlreadyInChannelException(Exception):
+	pass
+
+class userNotInChannelException(Exception):
+	pass
+
+class missingReportInfoException(Exception):
+	pass
+
+class invalidUserException(Exception):
+	pass
+
+class wrongChannelException(Exception):
+	pass

constants/fokabotCommands.py

@@ -1,19 +1,25 @@
 import json
 import random
+import re
+import threading
 
 import requests
+import time
 
 from common import generalUtils
 from common.constants import mods
 from common.log import logUtils as log
 from common.ripple import userUtils
-from constants import exceptions
+from constants import exceptions, slotStatuses, matchModModes, matchTeams, matchTeamTypes
 from common.constants import gameModes
 from common.constants import privileges
 from constants import serverPackets
 from helpers import systemHelper
 from objects import fokabot
 from objects import glob
+from helpers import chatHelper as chat
+from helpers import packetHelper
+from common.web import cheesegull
 
 """
 Commands callbacks
@@ -31,33 +37,14 @@ TODO: Change False to None, because False doesn't make any sense
 """
 def instantRestart(fro, chan, message):
 	glob.streams.broadcast("main", serverPackets.notification("We are restarting Bancho. Be right back!"))
-	systemHelper.scheduleShutdown(0, True, delay=1)
+	systemHelper.scheduleShutdown(0, True, delay=5)
 	return False
 
 def faq(fro, chan, message):
-	# TODO: Unhardcode this
-	if message[0] == "rules":
-		return "Please make sure to check (Ripple's rules)[http://ripple.moe/?p=23]."
-	elif message[0] == "swearing":
-		return "Please don't abuse swearing"
-	elif message[0] == "spam":
-		return "Please don't spam"
-	elif message[0] == "offend":
-		return "Please don't offend other players"
-	elif message[0] == "github":
-		return "(Ripple's Github page!)[https://github.com/osuripple/ripple]"
-	elif message[0] == "discord":
-		return "(Join Ripple's Discord!)[https://discord.gg/0rJcZruIsA6rXuIx]"
-	elif message[0] == "blog":
-		return "You can find the latest Ripple news on the (blog)[https://ripple.moe/blog/]!"
-	elif message[0] == "changelog":
-		return "Check the (changelog)[https://ripple.moe/index.php?p=17] !"
-	elif message[0] == "status":
-		return "Check the server status (here!)[https://ripple.moe/index.php?p=27]"
-	elif message[0] == "english":
-		return "Please keep this channel in english."
-	else:
+	key = message[0].lower()
+	if key not in glob.conf.extra["faq"]:
 		return False
+	return glob.conf.extra["faq"][key]
 
 def roll(fro, chan, message):
 	maxPoints = 100
@@ -72,15 +59,20 @@ def roll(fro, chan, message):
 #	return random.choice(["yes", "no", "maybe"])
 
 def alert(fro, chan, message):
-	glob.streams.broadcast("main", serverPackets.notification(' '.join(message[:])))
+	msg = ' '.join(message[:]).strip()
+	if not msg:
+		return False
+	glob.streams.broadcast("main", serverPackets.notification(msg))
 	return False
 
 def alertUser(fro, chan, message):
-	target = message[0].replace("_", " ")
-
-	targetToken = glob.tokens.getTokenFromUsername(target)
+	target = message[0].lower()
+	targetToken = glob.tokens.getTokenFromUsername(userUtils.safeUsername(target), safe=True)
 	if targetToken is not None:
-		targetToken.enqueue(serverPackets.notification(' '.join(message[1:])))
+		msg = ' '.join(message[1:]).strip()
+		if not msg:
+			return False
+		targetToken.enqueue(serverPackets.notification(msg))
 		return False
 	else:
 		return "User offline."
@@ -106,6 +98,7 @@ def moderated(fro, chan, message):
 def kickAll(fro, chan, message):
 	# Kick everyone but mods/admins
 	toKick = []
+	with glob.tokens:
 		for key, value in glob.tokens.tokens.items():
 			if not value.admin:
 				toKick.append(key)
@@ -119,15 +112,18 @@ def kickAll(fro, chan, message):
 
 def kick(fro, chan, message):
 	# Get parameters
-	target = message[0].replace("_", " ")
+	target = message[0].lower()
+	if target == glob.BOT_NAME.lower():
+		return "Nope."
 
 	# Get target token and make sure is connected
-	targetToken = glob.tokens.getTokenFromUsername(target)
-	if targetToken is None:
+	tokens = glob.tokens.getTokenFromUsername(userUtils.safeUsername(target), safe=True, _all=True)
+	if len(tokens) == 0:
 		return "{} is not online".format(target)
 
-	# Kick user
-	targetToken.kick()
+	# Kick users
+	for i in tokens:
+		i.kick()
 
 	# Bot response
 	return "{} has been kicked from the server.".format(target)
@@ -135,22 +131,25 @@ def kick(fro, chan, message):
 def fokabotReconnect(fro, chan, message):
 	# Check if fokabot is already connected
 	if glob.tokens.getTokenFromUserID(999) is not None:
-		return "Fokabot is already connected to Bancho"
+		return "{} is already connected to Bancho".format(glob.BOT_NAME)
 
 	# Fokabot is not connected, connect it
 	fokabot.connect()
 	return False
 
 def silence(fro, chan, message):
-	for i in message:
-		i = i.lower()
-	target = message[0].replace("_", " ")
+	message = [x.lower() for x in message]
+	target = message[0]
 	amount = message[1]
 	unit = message[2]
-	reason = ' '.join(message[3:])
+	reason = ' '.join(message[3:]).strip()
+	if not reason:
+		return "Please provide a valid reason."
+	if not amount.isdigit():
+		return "The amount must be a number."
 
 	# Get target user ID
-	targetUserID = userUtils.getID(target)
+	targetUserID = userUtils.getIDSafe(target)
 	userID = userUtils.getID(fro)
 
 	# Make sure the user exists
@@ -174,7 +173,7 @@ def silence(fro, chan, message):
 		return "Invalid silence time. Max silence time is 7 days."
 
 	# Send silence packet to target if he's connected
-	targetToken = glob.tokens.getTokenFromUsername(target)
+	targetToken = glob.tokens.getTokenFromUsername(userUtils.safeUsername(target), safe=True)
 	if targetToken is not None:
 		# user online, silence both in db and with packet
 		targetToken.silence(silenceTime, reason, userID)
@@ -190,16 +189,16 @@ def removeSilence(fro, chan, message):
 	# Get parameters
 	for i in message:
 		i = i.lower()
-	target = message[0].replace("_", " ")
+	target = message[0]
 
 	# Make sure the user exists
-	targetUserID = userUtils.getID(target)
+	targetUserID = userUtils.getIDSafe(target)
 	userID = userUtils.getID(fro)
 	if not targetUserID:
 		return "{}: user not found".format(target)
 
 	# Send new silence end packet to user if he's online
-	targetToken = glob.tokens.getTokenFromUsername(target)
+	targetToken = glob.tokens.getTokenFromUsername(userUtils.safeUsername(target), safe=True)
 	if targetToken is not None:
 		# User online, remove silence both in db and with packet
 		targetToken.silence(0, "", userID)
@@ -213,10 +212,10 @@ def ban(fro, chan, message):
 	# Get parameters
 	for i in message:
 		i = i.lower()
-	target = message[0].replace("_", " ")
+	target = message[0]
 
 	# Make sure the user exists
-	targetUserID = userUtils.getID(target)
+	targetUserID = userUtils.getIDSafe(target)
 	userID = userUtils.getID(fro)
 	if not targetUserID:
 		return "{}: user not found".format(target)
@@ -225,7 +224,7 @@ def ban(fro, chan, message):
 	userUtils.ban(targetUserID)
 
 	# Send ban packet to the user if he's online
-	targetToken = glob.tokens.getTokenFromUsername(target)
+	targetToken = glob.tokens.getTokenFromUsername(userUtils.safeUsername(target), safe=True)
 	if targetToken is not None:
 		targetToken.enqueue(serverPackets.loginBanned())
 
@@ -236,10 +235,10 @@ def unban(fro, chan, message):
 	# Get parameters
 	for i in message:
 		i = i.lower()
-	target = message[0].replace("_", " ")
+	target = message[0]
 
 	# Make sure the user exists
-	targetUserID = userUtils.getID(target)
+	targetUserID = userUtils.getIDSafe(target)
 	userID = userUtils.getID(fro)
 	if not targetUserID:
 		return "{}: user not found".format(target)
@@ -254,10 +253,10 @@ def restrict(fro, chan, message):
 	# Get parameters
 	for i in message:
 		i = i.lower()
-	target = message[0].replace("_", " ")
+	target = message[0]
 
 	# Make sure the user exists
-	targetUserID = userUtils.getID(target)
+	targetUserID = userUtils.getIDSafe(target)
 	userID = userUtils.getID(fro)
 	if not targetUserID:
 		return "{}: user not found".format(target)
@@ -266,7 +265,7 @@ def restrict(fro, chan, message):
 	userUtils.restrict(targetUserID)
 
 	# Send restricted mode packet to this user if he's online
-	targetToken = glob.tokens.getTokenFromUsername(target)
+	targetToken = glob.tokens.getTokenFromUsername(userUtils.safeUsername(target), safe=True)
 	if targetToken is not None:
 		targetToken.setRestricted()
 
@@ -277,10 +276,10 @@ def unrestrict(fro, chan, message):
 	# Get parameters
 	for i in message:
 		i = i.lower()
-	target = message[0].replace("_", " ")
+	target = message[0]
 
 	# Make sure the user exists
-	targetUserID = userUtils.getID(target)
+	targetUserID = userUtils.getIDSafe(target)
 	userID = userUtils.getID(fro)
 	if not targetUserID:
 		return "{}: user not found".format(target)
@@ -325,6 +324,7 @@ def systemMaintenance(fro, chan, message):
 		who = []
 
 		# Disconnect everyone but mod/admins
+		with glob.tokens:
 			for _, value in glob.tokens.tokens.items():
 				if not value.admin:
 					who.append(value.userID)
@@ -380,7 +380,7 @@ def getPPMessage(userID, just_data = False):
 		currentAcc = token.tillerino[2]
 
 		# Send request to LETS api
-		resp = requests.get("http://127.0.0.1:5002/api/v1/pp?b={}&m={}".format(currentMap, currentMods, currentAcc), timeout=10).text
+		resp = requests.get("http://127.0.0.1:5002/api/v1/pp?b={}&m={}".format(currentMap, currentMods), timeout=10).text
 		data = json.loads(resp)
 
 		# Make sure status is in response data
@@ -390,7 +390,7 @@ def getPPMessage(userID, just_data = False):
 		# Make sure status is 200
 		if data["status"] != 200:
 			if "message" in data:
-				return "Error in LETS API call ({}). Please tell this to a dev.".format(data["message"])
+				return "Error in LETS API call ({}).".format(data["message"])
 			else:
 				raise exceptions.apiException
 
@@ -426,7 +426,7 @@ def getPPMessage(userID, just_data = False):
 		return "API Timeout. Please try again in a few seconds."
 	except exceptions.apiException:
 		# API error
-		return "Unknown error in LETS API call. Please tell this to a dev."
+		return "Unknown error in LETS API call."
 	#except:
 		# Unknown exception
 		# TODO: print exception
@@ -564,6 +564,10 @@ def tillerinoAcc(fro, chan, message):
 
 def tillerinoLast(fro, chan, message):
 	try:
+		# Run the command in PM only
+		if chan.startswith("#"):
+			return False
+
 		data = glob.db.fetch("""SELECT beatmaps.song_name as sn, scores.*,
 			beatmaps.beatmap_id as bid, beatmaps.difficulty_std, beatmaps.difficulty_taiko, beatmaps.difficulty_ctb, beatmaps.difficulty_mania, beatmaps.max_combo as fc
 		FROM scores
@@ -579,11 +583,11 @@ def tillerinoLast(fro, chan, message):
 		rank = generalUtils.getRank(data["play_mode"], data["mods"], data["accuracy"],
 									data["300_count"], data["100_count"], data["50_count"], data["misses_count"])
 
-		ifPlayer = "{0} | ".format(fro) if chan != "FokaBot" else ""
+		ifPlayer = "{0} | ".format(fro) if chan != glob.BOT_NAME else ""
 		ifFc = " (FC)" if data["max_combo"] == data["fc"] else " {0}x/{1}x".format(data["max_combo"], data["fc"])
 		beatmapLink = "[http://osu.ppy.sh/b/{1} {0}]".format(data["sn"], data["bid"])
 
-		hasPP = data["play_mode"] == gameModes.STD or data["play_mode"] == gameModes.MANIA
+		hasPP = data["play_mode"] != gameModes.CTB
 
 		msg = ifPlayer
 		msg += beatmapLink
@@ -656,7 +660,7 @@ def pp(fro, chan, message):
 	pp = userUtils.getPP(token.userID, gameMode)
 	return "You have {:,} pp".format(pp)
 
-def updateBeatmap(fro, chan, to):
+def updateBeatmap(fro, chan, message):
 	try:
 		# Run the command in PM only
 		if chan.startswith("#"):
@@ -671,26 +675,478 @@ def updateBeatmap(fro, chan, to):
 		if token.tillerino[0] == 0:
 			return "Please give me a beatmap first with /np command."
 
-		# Send request
-		beatmapData = glob.db.fetch("SELECT beatmapset_id, song_name FROM beatmaps WHERE beatmap_id = %s LIMIT 1", [token.tillerino[0]])
-		if beatmapData is None:
-			return "Couldn't find beatmap data in database. Please load the beatmap's leaderboard and try again."
-
-		response = requests.post("{}/api/v1/update_beatmap".format(glob.conf.config["mirror"]["url"]), {
-			"beatmap_set_id": beatmapData["beatmapset_id"],
-			"beatmap_name": beatmapData["song_name"],
-			"username": token.username,
-			"key": glob.conf.config["mirror"]["apikey"]
-		})
-		if response.status_code == 200:
-			return "An update request for that beatmap has been queued. You'll receive a message once the beatmap has been updated on our mirror!"
-		elif response.status_code == 429:
-			return "You are sending too many beatmaps update requests. Wait a bit and retry later."
+		# Send the request to cheesegull
+		ok, message = cheesegull.updateBeatmap(token.tillerino[0])
+		if ok:
+			return "An update request for that beatmap has been queued. Check back in a few minutes and the beatmap should be updated!"
 		else:
-			return "Error in beatmap mirror API request. Tell this to a dev: {}".format(response.text)
+			return "Error in beatmap mirror API request: {}".format(message)
 	except:
 		return False
 
+def report(fro, chan, message):
+	msg = ""
+	try:
+		# TODO: Rate limit
+		# Regex on message
+		reportRegex = re.compile("^(.+) \((.+)\)\:(?: )?(.+)?$")
+		result = reportRegex.search(" ".join(message))
+
+		# Make sure the message matches the regex
+		if result is None:
+			raise exceptions.invalidArgumentsException()
+
+		# Get username, report reason and report info
+		target, reason, additionalInfo = result.groups()
+		target = chat.fixUsernameForBancho(target)
+
+		# Make sure the target is not foka
+		if target.lower() == glob.BOT_NAME.lower():
+			raise exceptions.invalidUserException()
+
+		# Make sure the user exists
+		targetID = userUtils.getID(target)
+		if targetID == 0:
+			raise exceptions.userNotFoundException()
+
+		# Make sure that the user has specified additional info if report reason is 'Other'
+		if reason.lower() == "other" and additionalInfo is None:
+			raise exceptions.missingReportInfoException()
+
+		# Get the token if possible
+		chatlog = ""
+		token = glob.tokens.getTokenFromUsername(userUtils.safeUsername(target), safe=True)
+		if token is not None:
+			chatlog = token.getMessagesBufferString()
+
+		# Everything is fine, submit report
+		glob.db.execute("INSERT INTO reports (id, from_uid, to_uid, reason, chatlog, time) VALUES (NULL, %s, %s, %s, %s, %s)", [userUtils.getID(fro), targetID, "{reason} - ingame {info}".format(reason=reason, info="({})".format(additionalInfo) if additionalInfo is not None else ""), chatlog, int(time.time())])
+		msg = "You've reported {target} for {reason}{info}. A Community Manager will check your report as soon as possible. Every !report message you may see in chat wasn't sent to anyone, so nobody in chat, but admins, know about your report. Thank you for reporting!".format(target=target, reason=reason, info="" if additionalInfo is None else " (" + additionalInfo + ")")
+		adminMsg = "{user} has reported {target} for {reason} ({info})".format(user=fro, target=target, reason=reason, info=additionalInfo)
+
+		# Log report in #admin and on discord
+		chat.sendMessage(glob.BOT_NAME, "#admin", adminMsg)
+		log.warning(adminMsg, discord="cm")
+	except exceptions.invalidUserException:
+		msg = "Hello, {} here! You can't report me. I won't forget what you've tried to do. Watch out.".format(glob.BOT_NAME)
+	except exceptions.invalidArgumentsException:
+		msg = "Invalid report command syntax. To report an user, click on it and select 'Report user'."
+	except exceptions.userNotFoundException:
+		msg = "The user you've tried to report doesn't exist."
+	except exceptions.missingReportInfoException:
+		msg = "Please specify the reason of your report."
+	except:
+		raise
+	finally:
+		if msg != "":
+			token = glob.tokens.getTokenFromUsername(fro)
+			if token is not None:
+				if token.irc:
+					chat.sendMessage(glob.BOT_NAME, fro, msg)
+				else:
+					token.enqueue(serverPackets.notification(msg))
+	return False
+
+def multiplayer(fro, chan, message):
+	def getMatchIDFromChannel(chan):
+		if not chan.lower().startswith("#multi_"):
+			raise exceptions.wrongChannelException()
+		parts = chan.lower().split("_")
+		if len(parts) < 2 or not parts[1].isdigit():
+			raise exceptions.wrongChannelException()
+		matchID = int(parts[1])
+		if matchID not in glob.matches.matches:
+			raise exceptions.matchNotFoundException()
+		return matchID
+
+	def mpMake():
+		if len(message) < 2:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp make <name>")
+		matchName = " ".join(message[1:]).strip()
+		if not matchName:
+			raise exceptions.invalidArgumentsException("Match name must not be empty!")
+		matchID = glob.matches.createMatch(matchName, generalUtils.stringMd5(generalUtils.randomString(32)), 0, "Tournament", "", 0, -1, isTourney=True)
+		glob.matches.matches[matchID].sendUpdates()
+		return "Tourney match #{} created!".format(matchID)
+
+	def mpJoin():
+		if len(message) < 2 or not message[1].isdigit():
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp join <id>")
+		matchID = int(message[1])
+		userToken = glob.tokens.getTokenFromUsername(fro, ignoreIRC=True)
+		userToken.joinMatch(matchID)
+		return "Attempting to join match #{}!".format(matchID)
+
+	def mpClose():
+		matchID = getMatchIDFromChannel(chan)
+		glob.matches.disposeMatch(matchID)
+		return "Multiplayer match #{} disposed successfully".format(matchID)
+
+	def mpLock():
+		matchID = getMatchIDFromChannel(chan)
+		glob.matches.matches[matchID].isLocked = True
+		return "This match has been locked"
+
+	def mpUnlock():
+		matchID = getMatchIDFromChannel(chan)
+		glob.matches.matches[matchID].isLocked = False
+		return "This match has been unlocked"
+
+	def mpSize():
+		if len(message) < 2 or not message[1].isdigit() or int(message[1]) < 2 or int(message[1]) > 16:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp size <slots(2-16)>")
+		matchSize = int(message[1])
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		_match.forceSize(matchSize)
+		return "Match size changed to {}".format(matchSize)
+
+	def mpMove():
+		if len(message) < 3 or not message[2].isdigit() or int(message[2]) < 0 or int(message[2]) > 16:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp move <username> <slot>")
+		username = message[1]
+		newSlotID = int(message[2])
+		userID = userUtils.getIDSafe(username)
+		if userID is None:
+			raise exceptions.userNotFoundException("No such user")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		success = _match.userChangeSlot(userID, newSlotID)
+		if success:
+			result = "Player {} moved to slot {}".format(username, newSlotID)
+		else:
+			result = "You can't use that slot: it's either already occupied by someone else or locked"
+		return result
+
+	def mpHost():
+		if len(message) < 2:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp host <username>")
+		username = message[1].strip()
+		if not username:
+			raise exceptions.invalidArgumentsException("Please provide a username")
+		userID = userUtils.getIDSafe(username)
+		if userID is None:
+			raise exceptions.userNotFoundException("No such user")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		success = _match.setHost(userID)
+		return "{} is now the host".format(username) if success else "Couldn't give host to {}".format(username)
+
+	def mpClearHost():
+		matchID = getMatchIDFromChannel(chan)
+		glob.matches.matches[matchID].removeHost()
+		return "Host has been removed from this match"
+
+	def mpStart():
+		def _start():
+			matchID = getMatchIDFromChannel(chan)
+			success = glob.matches.matches[matchID].start()
+			if not success:
+				chat.sendMessage(glob.BOT_NAME, chan, "Couldn't start match. Make sure there are enough players and "
+												  "teams are valid. The match has been unlocked.")
+			else:
+				chat.sendMessage(glob.BOT_NAME, chan, "Have fun!")
+
+
+		def _decreaseTimer(t):
+			if t <= 0:
+				_start()
+			else:
+				if t % 10 == 0 or t <= 5:
+					chat.sendMessage(glob.BOT_NAME, chan, "Match starts in {} seconds.".format(t))
+				threading.Timer(1.00, _decreaseTimer, [t - 1]).start()
+
+		if len(message) < 2 or not message[1].isdigit():
+			startTime = 0
+		else:
+			startTime = int(message[1])
+
+		force = False if len(message) < 3 else message[2].lower() == "force"
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+
+		# Force everyone to ready
+		someoneNotReady = False
+		for i, slot in enumerate(_match.slots):
+			if slot.status != slotStatuses.READY and slot.user is not None:
+				someoneNotReady = True
+				if force:
+					_match.toggleSlotReady(i)
+
+		if someoneNotReady and not force:
+			return "Some users aren't ready yet. Use '!mp start force' if you want to start the match, " \
+				   "even with non-ready players."
+
+		if startTime == 0:
+			_start()
+			return "Starting match"
+		else:
+			_match.isStarting = True
+			threading.Timer(1.00, _decreaseTimer, [startTime - 1]).start()
+			return "Match starts in {} seconds. The match has been locked. " \
+				   "Please don't leave the match during the countdown " \
+				   "or you might receive a penalty.".format(startTime)
+
+	def mpInvite():
+		if len(message) < 2:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp invite <username>")
+		username = message[1].strip()
+		if not username:
+			raise exceptions.invalidArgumentsException("Please provide a username")
+		userID = userUtils.getIDSafe(username)
+		if userID is None:
+			raise exceptions.userNotFoundException("No such user")
+		token = glob.tokens.getTokenFromUserID(userID, ignoreIRC=True)
+		if token is None:
+			raise exceptions.invalidUserException("That user is not connected to bancho right now.")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		_match.invite(999, userID)
+		token.enqueue(serverPackets.notification("Please accept the invite you've just received from {} to "
+												 "enter your tourney match.".format(glob.BOT_NAME)))
+		return "An invite to this match has been sent to {}".format(username)
+
+	def mpMap():
+		if len(message) < 2 or not message[1].isdigit() or (len(message) == 3 and not message[2].isdigit()):
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp map <beatmapid> [<gamemode>]")
+		beatmapID = int(message[1])
+		gameMode = int(message[2]) if len(message) == 3 else 0
+		if gameMode < 0 or gameMode > 3:
+			raise exceptions.invalidArgumentsException("Gamemode must be 0, 1, 2 or 3")
+		beatmapData = glob.db.fetch("SELECT * FROM beatmaps WHERE beatmap_id = %s LIMIT 1", [beatmapID])
+		if beatmapData is None:
+			raise exceptions.invalidArgumentsException("The beatmap you've selected couldn't be found in the database."
+													   "If the beatmap id is valid, please load the scoreboard first in "
+													   "order to cache it, then try again.")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		_match.beatmapID = beatmapID
+		_match.beatmapName = beatmapData["song_name"]
+		_match.beatmapMD5 = beatmapData["beatmap_md5"]
+		_match.gameMode = gameMode
+		_match.resetReady()
+		_match.sendUpdates()
+		return "Match map has been updated"
+
+	def mpSet():
+		if len(message) < 2 or not message[1].isdigit() or \
+				(len(message) >= 3 and not message[2].isdigit()) or \
+				(len(message) >= 4 and not message[3].isdigit()):
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp set <teammode> [<scoremode>] [<size>]")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		matchTeamType = int(message[1])
+		matchScoringType = int(message[2]) if len(message) >= 3 else _match.matchScoringType
+		if not 0 <= matchTeamType <= 3:
+			raise exceptions.invalidArgumentsException("Match team type must be between 0 and 3")
+		if not 0 <= matchScoringType <= 3:
+			raise exceptions.invalidArgumentsException("Match scoring type must be between 0 and 3")
+		oldMatchTeamType = _match.matchTeamType
+		_match.matchTeamType = matchTeamType
+		_match.matchScoringType = matchScoringType
+		if len(message) >= 4:
+			_match.forceSize(int(message[3]))
+		if _match.matchTeamType != oldMatchTeamType:
+			_match.initializeTeams()
+		if _match.matchTeamType == matchTeamTypes.TAG_COOP or _match.matchTeamType == matchTeamTypes.TAG_TEAM_VS:
+			_match.matchModMode = matchModModes.NORMAL
+
+		_match.sendUpdates()
+		return "Match settings have been updated!"
+
+	def mpAbort():
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		_match.abort()
+		return "Match aborted!"
+
+	def mpKick():
+		if len(message) < 2:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp kick <username>")
+		username = message[1].strip()
+		if not username:
+			raise exceptions.invalidArgumentsException("Please provide a username")
+		userID = userUtils.getIDSafe(username)
+		if userID is None:
+			raise exceptions.userNotFoundException("No such user")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		slotID = _match.getUserSlotID(userID)
+		if slotID is None:
+			raise exceptions.userNotFoundException("The specified user is not in this match")
+		for i in range(0, 2):
+			_match.toggleSlotLocked(slotID)
+		return "{} has been kicked from the match.".format(username)
+
+	def mpPassword():
+		password = "" if len(message) < 2 or not message[1].strip() else message[1]
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		_match.changePassword(password)
+		return "Match password has been changed!"
+
+	def mpRandomPassword():
+		password = generalUtils.stringMd5(generalUtils.randomString(32))
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		_match.changePassword(password)
+		return "Match password has been changed to a random one"
+
+	def mpMods():
+		if len(message) < 2:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp <mod1> [<mod2>] ...")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		newMods = 0
+		freeMod = False
+		for _mod in message[1:]:
+			if _mod.lower().strip() == "hd":
+				newMods |= mods.HIDDEN
+			elif _mod.lower().strip() == "hr":
+				newMods |= mods.HARDROCK
+			elif _mod.lower().strip() == "dt":
+				newMods |= mods.DOUBLETIME
+			elif _mod.lower().strip() == "fl":
+				newMods |= mods.FLASHLIGHT
+			elif _mod.lower().strip() == "fi":
+				newMods |= mods.FADEIN
+			if _mod.lower().strip() == "none":
+				newMods = 0
+
+			if _mod.lower().strip() == "freemod":
+				freeMod = True
+
+		_match.matchModMode = matchModModes.FREE_MOD if freeMod else matchModModes.NORMAL
+		_match.resetReady()
+		if _match.matchModMode == matchModModes.FREE_MOD:
+			_match.resetMods()
+		_match.changeMods(newMods)
+		return "Match mods have been updated!"
+
+	def mpTeam():
+		if len(message) < 3:
+			raise exceptions.invalidArgumentsException("Wrong syntax: !mp team <username> <colour>")
+		username = message[1].strip()
+		if not username:
+			raise exceptions.invalidArgumentsException("Please provide a username")
+		colour = message[2].lower().strip()
+		if colour not in ["red", "blue"]:
+			raise exceptions.invalidArgumentsException("Team colour must be red or blue")
+		userID = userUtils.getIDSafe(username)
+		if userID is None:
+			raise exceptions.userNotFoundException("No such user")
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		_match.changeTeam(userID, matchTeams.BLUE if colour == "blue" else matchTeams.RED)
+		return "{} is now in {} team".format(username, colour)
+
+	def mpSettings():
+		_match = glob.matches.matches[getMatchIDFromChannel(chan)]
+		msg = "PLAYERS IN THIS MATCH:\n"
+		empty = True
+		for slot in _match.slots:
+			if slot.user is None:
+				continue
+			readableStatuses = {
+				slotStatuses.READY: "ready",
+				slotStatuses.NOT_READY: "not ready",
+				slotStatuses.NO_MAP: "no map",
+				slotStatuses.PLAYING: "playing",
+			}
+			if slot.status not in readableStatuses:
+				readableStatus = "???"
+			else:
+				readableStatus = readableStatuses[slot.status]
+			empty = False
+			msg += "* [{team}] <{status}> ~ {username}{mods}\n".format(
+				team="red" if slot.team == matchTeams.RED else "blue" if slot.team == matchTeams.BLUE else "!! no team !!",
+				status=readableStatus,
+				username=glob.tokens.tokens[slot.user].username,
+				mods=" (+ {})".format(generalUtils.readableMods(slot.mods)) if slot.mods > 0 else ""
+			)
+		if empty:
+			msg += "Nobody.\n"
+		return msg
+
+
+	try:
+		subcommands = {
+			"make": mpMake,
+			"close": mpClose,
+			"join": mpJoin,
+			"lock": mpLock,
+			"unlock": mpUnlock,
+			"size": mpSize,
+			"move": mpMove,
+			"host": mpHost,
+			"clearhost": mpClearHost,
+			"start": mpStart,
+			"invite": mpInvite,
+			"map": mpMap,
+			"set": mpSet,
+			"abort": mpAbort,
+			"kick": mpKick,
+			"password": mpPassword,
+			"randompassword": mpRandomPassword,
+			"mods": mpMods,
+			"team": mpTeam,
+			"settings": mpSettings,
+		}
+		requestedSubcommand = message[0].lower().strip()
+		if requestedSubcommand not in subcommands:
+			raise exceptions.invalidArgumentsException("Invalid subcommand")
+		return subcommands[requestedSubcommand]()
+	except (exceptions.invalidArgumentsException, exceptions.userNotFoundException, exceptions.invalidUserException) as e:
+		return str(e)
+	except exceptions.wrongChannelException:
+		return "This command only works in multiplayer chat channels"
+	except exceptions.matchNotFoundException:
+		return "Match not found"
+	except:
+		raise
+
+def switchServer(fro, chan, message):
+	# Get target user ID
+	target = message[0]
+	newServer = message[1].strip()
+	if not newServer:
+		return "Invalid server IP"
+	targetUserID = userUtils.getIDSafe(target)
+	userID = userUtils.getID(fro)
+
+	# Make sure the user exists
+	if not targetUserID:
+		return "{}: user not found".format(target)
+
+	# Connect the user to the end server
+	userToken = glob.tokens.getTokenFromUserID(userID, ignoreIRC=True, _all=False)
+	userToken.enqueue(serverPackets.switchServer(newServer))
+
+	# Disconnect the user from the origin server
+	# userToken.kick()
+	return "{} has been connected to {}".format(target, newServer)
+
+def rtx(fro, chan, message):
+	target = message[0]
+	message = " ".join(message[1:]).strip()
+	if not message:
+		return "Invalid message"
+	targetUserID = userUtils.getIDSafe(target)
+	if not targetUserID:
+		return "{}: user not found".format(target)
+	userToken = glob.tokens.getTokenFromUserID(targetUserID, ignoreIRC=True, _all=False)
+	userToken.enqueue(serverPackets.rtx(message))
+	return ":ok_hand:"
+
+def rawPacket(fro, chan, message):
+	target = message[0]
+	message = " ".join(message[1:]).strip()
+	if not message:
+		return "Invalid message"
+	targetUserID = userUtils.getIDSafe(target)
+	if not targetUserID:
+		return "{}: user not found".format(target)
+	userToken = glob.tokens.getTokenFromUserID(targetUserID, ignoreIRC=True, _all=False)
+
+	p = message.split(" ", 1)
+
+	try:
+		packetID = int(p[0])
+		packetData = eval(p[1])
+	except Exception:
+		return "Error"
+
+	userToken.enqueue(packetHelper.buildPacket(packetID, packetData))
+	return ":thinking:"
+
+
 """
 Commands list
 
@@ -710,10 +1166,10 @@ commands = [
 		"callback": faq
 	}, {
 		"trigger": "!report",
-		"response": "Report command isn't here yet :c"
+		"callback": report
 	}, {
 		"trigger": "!help",
-		"response": "Click (here)[https://ripple.moe/index.php?p=16&id=4] for FokaBot's full command list"
+		"response": "Click (here)[https://ripple.moe/index.php?p=16&id=4] for the full command list"
 	}, #{
 		#"trigger": "!ask",
 		#"syntax": "<question>",
@@ -746,7 +1202,7 @@ commands = [
 		"privileges": privileges.ADMIN_KICK_USERS,
 		"callback": kick
 	}, {
-		"trigger": "!fokabot reconnect",
+		"trigger": "!bot reconnect",
 		"privileges": privileges.ADMIN_MANAGE_SERVERS,
 		"callback": fokabotReconnect
 	}, {
@@ -825,6 +1281,26 @@ commands = [
 	}, {
 		"trigger": "!update",
 		"callback": updateBeatmap
+	}, {
+		"trigger": "!mp",
+		"privileges": privileges.USER_TOURNAMENT_STAFF,
+		"syntax": "<subcommand>",
+		"callback": multiplayer
+	}, {
+		"trigger": "!switchserver",
+		"privileges": privileges.ADMIN_MANAGE_SERVERS,
+		"syntax": "<username> <server_address>",
+		"callback": switchServer
+	}, {
+		"trigger": "!rtx",
+		"privileges": privileges.ADMIN_MANAGE_USERS,
+		"syntax": "<username> <message>",
+		"callback": rtx
+	}, {
+		"trigger": "!raw",
+		"privileges": privileges.ADMIN_MANAGE_SERVERS,
+		"syntax": "<username> <byte> <array>",
+		"callback": rawPacket
 	}
 	#
 	#	"trigger": "!acc",

constants/packetIDs.py

@@ -78,5 +78,7 @@ server_userSilenced = 94
 server_userPresenceBundle = 96
 client_userPanelRequest = 97
 client_tournamentMatchInfoRequest = 93
+server_matchAbort = 106
+server_switchServer = 107
 client_tournamentJoinMatchChannel = 108
 client_tournamentLeaveMatchChannel = 109

constants/serverPackets.py

@@ -16,12 +16,12 @@ def forceUpdate():
 
 def loginBanned():
 	packets = packetHelper.buildPacket(packetIDs.server_userID, [[-1, dataTypes.SINT32]])
-	packets += notification("You are banned. You can appeal after one month since your ban by sending an email to support@ripple.moe from the email address you've used to sign up.")
+	packets += notification("You are banned. You can appeal after one month since your ban by sending an email to {} from the email address you've used to sign up.".format(glob.conf.extra["support-email"]))
 	return packets
 
 def loginLocked():
 	packets = packetHelper.buildPacket(packetIDs.server_userID, [[-1, dataTypes.SINT32]])
-	packets += notification("Your account is locked. You can't log in, but your profile and scores are still visible from the website. If you want to unlock your account, send an email to support@ripple.moe from the email address you've used to sign up.")
+	packets += notification("Your account is locked. You can't log in, but your profile and scores are still visible from the website. If you want to unlock your account, send an email to {} from the email address you've used to sign up.".format(glob.conf.extra["support-email"]))
 	return packets
 
 def loginError():
@@ -94,12 +94,12 @@ def userPanel(userID, force = False):
 	# Get username color according to rank
 	# Only admins and normal users are currently supported
 	userRank = 0
-	if username == "FokaBot":
-		userRank |= userRanks.MOD
-	elif userUtils.isInPrivilegeGroup(userID, "community manager"):
+	if username == glob.BOT_NAME:
 		userRank |= userRanks.MOD
 	elif userUtils.isInPrivilegeGroup(userID, "developer"):
 		userRank |= userRanks.ADMIN
+	elif userUtils.isInPrivilegeGroup(userID, "chat mod"):
+		userRank |= userRanks.MOD
 	elif (userToken.privileges & privileges.USER_DONOR) > 0:
 		userRank |= userRanks.SUPPORTER
 	else:
@@ -155,11 +155,13 @@ def channelJoinSuccess(userID, chan):
 	return packetHelper.buildPacket(packetIDs.server_channelJoinSuccess, [[chan, dataTypes.STRING]])
 
 def channelInfo(chan):
+	if chan not in glob.channels.channels:
+		return bytes()
 	channel = glob.channels.channels[chan]
 	return packetHelper.buildPacket(packetIDs.server_channelInfo, [
-		[chan, dataTypes.STRING],
+		[channel.name, dataTypes.STRING],
 		[channel.description, dataTypes.STRING],
-		[len(channel.connectedUsers), dataTypes.UINT16]
+		[len(glob.streams.streams["chat/{}".format(chan)].clients), dataTypes.UINT16]
 	])
 
 def channelInfoEnd():
@@ -200,17 +202,18 @@ def createMatch(matchID):
 
 	# Get match binary data and build packet
 	match = glob.matches.matches[matchID]
-	return packetHelper.buildPacket(packetIDs.server_newMatch, match.getMatchData())
+	matchData = match.getMatchData(censored=True)
+	return packetHelper.buildPacket(packetIDs.server_newMatch, matchData)
 
 # TODO: Add match object argument to save some CPU
-def updateMatch(matchID):
+def updateMatch(matchID, censored = False):
 	# Make sure the match exists
 	if matchID not in glob.matches.matches:
 		return bytes()
 
 	# Get match binary data and build packet
 	match = glob.matches.matches[matchID]
-	return packetHelper.buildPacket(packetIDs.server_updateMatch, match.getMatchData())
+	return packetHelper.buildPacket(packetIDs.server_updateMatch, match.getMatchData(censored=censored))
 
 def matchStart(matchID):
 	# Make sure the match exists
@@ -261,6 +264,11 @@ def playerFailed(slotID):
 def matchTransferHost():
 	return packetHelper.buildPacket(packetIDs.server_matchTransferHost)
 
+def matchAbort():
+	return packetHelper.buildPacket(packetIDs.server_matchAbort)
+
+def switchServer(address):
+	return packetHelper.buildPacket(packetIDs.server_switchServer, [[address, dataTypes.STRING]])
 
 """ Other packets """
 def notification(message):
@@ -268,3 +276,6 @@ def notification(message):
 
 def banchoRestart(msUntilReconnection):
 	return packetHelper.buildPacket(packetIDs.server_restart, [[msUntilReconnection, dataTypes.UINT32]])
+
+def rtx(message):
+	return packetHelper.buildPacket(0x69, [[message, dataTypes.STRING]])

events/changeActionEvent.py

@@ -1,6 +1,4 @@
-from common.constants import actions
 from common.log import logUtils as log
-from common.ripple import userUtils
 from constants import clientPackets
 from constants import serverPackets
 from objects import glob

events/changeMatchModsEvent.py

@@ -15,9 +15,9 @@ def handle(userToken, packetData):
 	matchID = userToken.matchID
 	if matchID not in glob.matches.matches:
 		return
-	match = glob.matches.matches[matchID]
 
 	# Set slot or match mods according to modType
+	with glob.matches.matches[matchID] as match:
 		if match.matchModMode == matchModModes.FREE_MOD:
 			# Freemod
 			# Host can set global DT/HT

events/changeMatchPasswordEvent.py

@@ -10,9 +10,7 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# Get our match
-	match = glob.matches.matches[matchID]
-
+	with glob.matches.matches[matchID] as match:
 		# Host check
 		if userToken.userID != match.hostUserID:
 			return

events/changeMatchSettingsEvent.py

@@ -21,10 +21,8 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# Get match object
-	match = glob.matches.matches[matchID]
-
 	# Host check
+	with glob.matches.matches[matchID] as match:
 		if userToken.userID != match.hostUserID:
 			return
 
@@ -71,6 +69,7 @@ def handle(userToken, packetData):
 
 		oldBeatmapMD5 = match.beatmapMD5
 		oldMods = match.mods
+		oldMatchTeamType = match.matchTeamType
 
 		match.mods = packetData["mods"]
 		match.beatmapMD5 = packetData["beatmapMD5"]
@@ -80,31 +79,19 @@ def handle(userToken, packetData):
 
 		# Reset ready if needed
 		if oldMods != match.mods or oldBeatmapMD5 != match.beatmapMD5:
-		for i in range(0,16):
-			if match.slots[i].status == slotStatuses.READY:
-				match.slots[i].status = slotStatuses.NOT_READY
+			match.resetReady()
 
 		# Reset mods if needed
 		if match.matchModMode == matchModModes.NORMAL:
 			# Reset slot mods if not freeMods
-		for i in range(0,16):
-			match.slots[i].mods = 0
+			match.resetMods()
 		else:
 			# Reset match mods if freemod
 			match.mods = 0
 
-	# Set/reset teams
-	if match.matchTeamType == matchTeamTypes.TEAM_VS or match.matchTeamType == matchTeamTypes.TAG_TEAM_VS:
-		# Set teams
-		c=0
-		for i in range(0,16):
-			if match.slots[i].team == matchTeams.NO_TEAM:
-				match.slots[i].team = matchTeams.RED if c % 2 == 0 else matchTeams.BLUE
-				c+=1
-	else:
-		# Reset teams
-		for i in range(0,16):
-			match.slots[i].team = matchTeams.NO_TEAM
+		# Initialize teams if team type changed
+		if match.matchTeamType != oldMatchTeamType:
+			match.initializeTeams()
 
 		# Force no freemods if tag coop
 		if match.matchTeamType == matchTeamTypes.TAG_COOP or match.matchTeamType == matchTeamTypes.TAG_TEAM_VS:

events/changeSlotEvent.py

@@ -8,8 +8,6 @@ def handle(userToken, packetData):
 	# Read packet data
 	packetData = clientPackets.changeSlot(packetData)
 
-	# Get match
-	match = glob.matches.matches[userToken.matchID]
-
+	with glob.matches.matches[userToken.matchID] as match:
 		# Change slot
 		match.userChangeSlot(userID, packetData["slotID"])

events/createMatchEvent.py

@@ -1,7 +1,6 @@
 from common.log import logUtils as log
-from constants import clientPackets
+from constants import clientPackets, serverPackets
 from constants import exceptions
-from constants import serverPackets
 from objects import glob
 
 
@@ -13,17 +12,20 @@ def handle(userToken, packetData):
 		# Read packet data
 		packetData = clientPackets.createMatch(packetData)
 
+		# Make sure the name is valid
+		matchName = packetData["matchName"].strip()
+		if not matchName:
+			raise exceptions.matchCreateError()
+
 		# Create a match object
 		# TODO: Player number check
-		matchID = glob.matches.createMatch(packetData["matchName"], packetData["matchPassword"], packetData["beatmapID"], packetData["beatmapName"], packetData["beatmapMD5"], packetData["gameMode"], userID)
+		matchID = glob.matches.createMatch(matchName, packetData["matchPassword"].strip(), packetData["beatmapID"], packetData["beatmapName"], packetData["beatmapMD5"], packetData["gameMode"], userID)
 
 		# Make sure the match has been created
 		if matchID not in glob.matches.matches:
-			raise exceptions.matchCreateError
-
-		# Get match object
-		match = glob.matches.matches[matchID]
+			raise exceptions.matchCreateError()
 
+		with glob.matches.matches[matchID] as match:
 			# Join that match
 			userToken.joinMatch(matchID)
 
@@ -31,8 +33,6 @@ def handle(userToken, packetData):
 			match.setHost(userID)
 			match.sendUpdates()
 			match.changePassword(packetData["matchPassword"])
-
-		# Console output
-		log.info("MPROOM{}: Room created!".format(matchID))
 	except exceptions.matchCreateError:
 		log.error("Error while creating match!")
+		userToken.enqueue(serverPackets.matchJoinFail())

events/joinMatchEvent.py

@@ -1,4 +1,3 @@
-from common import generalUtils
 from common.log import logUtils as log
 from constants import clientPackets
 from constants import exceptions
@@ -18,18 +17,14 @@ def handle(userToken, packetData):
 		if matchID not in glob.matches.matches:
 			return
 
-		# Match exists, get object
-		match = glob.matches.matches[matchID]
-
 		# Hash password if needed
-		#if password != "":
+		# if password != "":
 		#	password = generalUtils.stringMd5(password)
 
 		# Check password
-		# TODO: Admins can enter every match
-		if match.matchPassword != "":
-			if match.matchPassword != password:
-				raise exceptions.matchWrongPasswordException
+		with glob.matches.matches[matchID] as match:
+			if match.matchPassword != "" and match.matchPassword != password:
+				raise exceptions.matchWrongPasswordException()
 
 			# Password is correct, join match
 			userToken.joinMatch(matchID)

events/loginEvent.py

@@ -15,6 +15,7 @@ from objects import glob
 
 def handle(tornadoRequest):
 	# Data to return
+	responseToken = None
 	responseTokenString = "ayy"
 	responseData = bytes()
 
@@ -29,9 +30,6 @@ def handle(tornadoRequest):
 	# 2:-3 thing is because requestData has some escape stuff that we don't need
 	loginData = str(tornadoRequest.request.body)[2:-3].split("\\n")
 	try:
-		# If true, print error to console
-		err = False
-
 		# Make sure loginData is valid
 		if len(loginData) < 3:
 			raise exceptions.invalidArgumentsException()
@@ -185,8 +183,11 @@ def handle(tornadoRequest):
 		if glob.banchoConf.config["menuIcon"] != "":
 			responseToken.enqueue(serverPackets.mainMenuIcon(glob.banchoConf.config["menuIcon"]))
 
-		# Send online users IDs array
-		responseToken.enqueue(serverPackets.onlineUsers())
+		# Send online users' panels
+		with glob.tokens:
+			for _, token in glob.tokens.tokens.items():
+				if not token.restricted:
+					responseToken.enqueue(serverPackets.userPanel(token.userID))
 
 		# Get location and country from ip.zxq.co or database
 		if glob.localize:
@@ -220,24 +221,22 @@ def handle(tornadoRequest):
 	except exceptions.loginFailedException:
 		# Login failed error packet
 		# (we don't use enqueue because we don't have a token since login has failed)
-		err = True
 		responseData += serverPackets.loginFailed()
 	except exceptions.invalidArgumentsException:
 		# Invalid POST data
 		# (we don't use enqueue because we don't have a token since login has failed)
-		err = True
 		responseData += serverPackets.loginFailed()
 		responseData += serverPackets.notification("I see what you're doing...")
 	except exceptions.loginBannedException:
 		# Login banned error packet
-		err = True
 		responseData += serverPackets.loginBanned()
 	except exceptions.loginLockedException:
 		# Login banned error packet
-		err = True
 		responseData += serverPackets.loginLocked()
 	except exceptions.banchoMaintenanceException:
 		# Bancho is in maintenance mode
+		responseData = bytes()
+		if responseToken is not None:
 			responseData = responseToken.queue
 		responseData += serverPackets.notification("Our bancho server is in maintenance mode. Please try to login again later.")
 		responseData += serverPackets.loginFailed()
@@ -251,7 +250,6 @@ def handle(tornadoRequest):
 	except exceptions.haxException:
 		# Using oldoldold client, we don't have client data. Force update.
 		# (we don't use enqueue because we don't have a token since login has failed)
-		err = True
 		responseData += serverPackets.forceUpdate()
 		responseData += serverPackets.notification("Hory shitto, your client is TOO old! Nice prehistory! Please turn update it from the settings!")
 	except:
@@ -259,10 +257,7 @@ def handle(tornadoRequest):
 	finally:
 		# Console and discord log
 		if len(loginData) < 3:
-			msg = "Invalid bancho login request from **{}** (insufficient POST data)".format(requestIP)
-		else:
-			msg = "Bancho login request from **{}** for user **{}** ({})".format(requestIP, loginData[0], "failed" if err == True else "success")
-		log.info(msg, "bunker")
+			log.info("Invalid bancho login request from **{}** (insufficient POST data)".format(requestIP), "bunker")
 
 		# Return token string and data
 		return responseTokenString, responseData

events/logoutEvent.py

@@ -17,7 +17,7 @@ def handle(userToken, _=None, deleteToken=True):
 	# the old logout packet will still be in the queue and will be sent to
 	# the server, so we accept logout packets sent at least 5 seconds after login
 	# if the user logs out before 5 seconds, he will be disconnected later with timeout check
-	if (int(time.time()-userToken.loginTime) >= 5 or userToken.irc):
+	if int(time.time() - userToken.loginTime) >= 5 or userToken.irc:
 		# Stop spectating
 		userToken.stopSpectating()
 
@@ -35,7 +35,7 @@ def handle(userToken, _=None, deleteToken=True):
 		glob.streams.broadcast("main", serverPackets.userLogout(userID))
 
 		# Disconnect from IRC if needed
-		if userToken.irc == True and glob.irc == True:
+		if userToken.irc and glob.irc:
 			glob.ircServer.forceDisconnection(userToken.username)
 
 		# Delete token

events/matchBeatmapEvent.py

@@ -1,6 +1,6 @@
 from objects import glob
 
-def handle(userToken, packetData, has):
+def handle(userToken, _, has):
 	# Get usertoken data
 	userID = userToken.userID
 
@@ -15,8 +15,6 @@ def handle(userToken, packetData, has):
 	if matchID not in glob.matches.matches:
 		return
 
-	# The match exists, get object
-	match = glob.matches.matches[matchID]
-
 	# Set has beatmap/no beatmap
+	with glob.matches.matches[matchID] as match:
 		match.userHasBeatmap(userID, has)

events/matchChangeTeamEvent.py

@@ -15,8 +15,6 @@ def handle(userToken, _):
 	if matchID not in glob.matches.matches:
 		return
 
-	# Get match object
-	match = glob.matches.matches[matchID]
-
 	# Change team
+	with glob.matches.matches[matchID] as match:
 		match.changeTeam(userID)

events/matchCompleteEvent.py

@@ -1,6 +1,6 @@
 from objects import glob
 
-def handle(userToken, packetData):
+def handle(userToken, _):
 	# Get usertoken data
 	userID = userToken.userID
 
@@ -15,8 +15,6 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# The match exists, get object
-	match = glob.matches.matches[matchID]
-
 	# Set our match complete
+	with glob.matches.matches[matchID] as match:
 		match.playerCompleted(userID)

events/matchFailedEvent.py

@@ -15,8 +15,6 @@ def handle(userToken, _):
 	if matchID not in glob.matches.matches:
 		return
 
-	# Match exists, get object
-	match = glob.matches.matches[matchID]
-
 	# Fail user
+	with glob.matches.matches[matchID] as match:
 		match.playerFailed(userID)

events/matchFramesEvent.py

@@ -1,6 +1,5 @@
 from objects import glob
-from constants import slotStatuses
-from constants import serverPackets
+from constants import serverPackets, clientPackets
 
 def handle(userToken, packetData):
 	# Get usertoken data
@@ -17,11 +16,16 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# The match exists, get object
-	match = glob.matches.matches[matchID]
+	# Parse the data
+	data = clientPackets.matchFrames(packetData)
 
+	with glob.matches.matches[matchID] as match:
 		# Change slot id in packetData
 		slotID = match.getUserSlotID(userID)
 
+		# Update the score
+		match.updateScore(slotID, data["totalScore"])
+		match.updateHP(slotID, data["currentHp"])
+
 		# Enqueue frames to who's playing
 		glob.streams.broadcast(match.playingStreamName, serverPackets.matchFrames(slotID, packetData))

events/matchInviteEvent.py

@@ -17,8 +17,6 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# Get match object
-	match = glob.matches.matches[matchID]
-
 	# Send invite
+	with glob.matches.matches[matchID] as match:
 		match.invite(userID, packetData["userID"])

events/matchLockEvent.py

@@ -12,8 +12,8 @@ def handle(userToken, packetData):
 	matchID = userToken.matchID
 	if matchID not in glob.matches.matches:
 		return
-	match = glob.matches.matches[matchID]
 
+	with glob.matches.matches[matchID] as match:
 		# Host check
 		if userID != match.hostUserID:
 			return
@@ -24,4 +24,4 @@ def handle(userToken, packetData):
 			return
 
 		# Lock/Unlock slot
-	match.toggleSlotLock(packetData["slotID"])
+		match.toggleSlotLocked(packetData["slotID"])

events/matchPlayerLoadEvent.py

@@ -1,6 +1,6 @@
 from objects import glob
 
-def handle(userToken, packetData):
+def handle(userToken, _):
 	# Get userToken data
 	userID = userToken.userID
 
@@ -15,8 +15,6 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# The match exists, get object
-	match = glob.matches.matches[matchID]
-
 	# Set our load status
+	with glob.matches.matches[matchID] as match:
 		match.playerLoaded(userID)

events/matchReadyEvent.py

@@ -8,9 +8,14 @@ def handle(userToken, _):
 	matchID = userToken.matchID
 	if matchID not in glob.matches.matches:
 		return
-	match = glob.matches.matches[matchID]
 
+	with glob.matches.matches[matchID] as match:
 		# Get our slotID and change ready status
 		slotID = match.getUserSlotID(userID)
 		if slotID is not None:
 			match.toggleSlotReady(slotID)
+
+		# If this is a tournament match, we should send the current status of ready
+		# players.
+		if match.isTourney:
+			match.sendReadyStatus()

events/matchSkipEvent.py

@@ -1,6 +1,6 @@
 from objects import glob
 
-def handle(userToken, packetData):
+def handle(userToken, _):
 	# Get userToken data
 	userID = userToken.userID
 
@@ -15,8 +15,6 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# The match exists, get object
-	match = glob.matches.matches[matchID]
-
 	# Skip
+	with glob.matches.matches[matchID] as match:
 		match.playerSkip(userID)

events/matchStartEvent.py

@@ -1,6 +1,4 @@
 from objects import glob
-from constants import slotStatuses
-from constants import serverPackets
 
 def handle(userToken, _):
 
@@ -15,9 +13,7 @@ def handle(userToken, _):
 	if matchID not in glob.matches.matches:
 		return
 
-	# The match exists, get object
-	match = glob.matches.matches[matchID]
-
+	with glob.matches.matches[matchID] as match:
 		# Host check
 		if userToken.userID != match.hostUserID:
 			return

events/matchTransferHostEvent.py

@@ -16,10 +16,8 @@ def handle(userToken, packetData):
 	if matchID not in glob.matches.matches:
 		return
 
-	# Match exists, get object
-	match = glob.matches.matches[matchID]
-
 	# Host check
+	with glob.matches.matches[matchID] as match:
 		if userToken.userID != match.hostUserID:
 			return
 

events/partLobbyEvent.py

@@ -1,17 +1,15 @@
 from common.log import logUtils as log
 from helpers import chatHelper as chat
-from objects import glob
-
 
 def handle(userToken, _):
 	# Get usertoken data
-	userID = userToken.userID
 	username = userToken.username
 
 	# Remove user from users in lobby
 	userToken.leaveStream("lobby")
 
 	# Part lobby channel
+	# Done automatically by the client
 	chat.partChannel(channel="#lobby", token=userToken, kick=True)
 
 	# Console output

events/setAwayMessageEvent.py

@@ -1,6 +1,7 @@
 from common.log import logUtils as log
 from constants import clientPackets
 from constants import serverPackets
+from objects import glob
 
 
 def handle(userToken, packetData):
@@ -18,5 +19,5 @@ def handle(userToken, packetData):
 		fokaMessage = "Your away message has been reset"
 	else:
 		fokaMessage = "Your away message is now: {}".format(packetData["awayMessage"])
-	userToken.enqueue(serverPackets.sendMessage("FokaBot", username, fokaMessage))
+	userToken.enqueue(serverPackets.sendMessage(glob.BOT_NAME, username, fokaMessage))
 	log.info("{} has changed their away message to: {}".format(username, packetData["awayMessage"]))

events/spectateFramesEvent.py

@@ -1,31 +1,15 @@
 from objects import glob
 from constants import serverPackets
-from constants import exceptions
+from common.log import logUtils as log
 
 def handle(userToken, packetData):
 	# get token data
 	userID = userToken.userID
 
 	# Send spectator frames to every spectator
-	glob.streams.broadcast("spect/{}".format(userID), serverPackets.spectatorFrames(packetData[7:]))
-	'''for i in userToken.spectators:
-		# Send to every user but host
-		if i != userID:
-			try:
-				# Get spectator token object
-				spectatorToken = glob.tokens.getTokenFromUserID(i)
-
-				# Make sure the token exists
-				if spectatorToken is None:
-					raise exceptions.stopSpectating
-
-				# Make sure this user is spectating us
-				if spectatorToken.spectating != userID:
-					raise exceptions.stopSpectating
-
-				# Everything seems fine, send spectator frames to this spectator
-				spectatorToken.enqueue(serverPackets.spectatorFrames(packetData[7:]))
-			except exceptions.stopSpectating:
-				# Remove this user from spectators
-				userToken.removeSpectator(i)
-				userToken.enqueue(serverPackets.removeSpectator(i))'''
+	streamName = "spect/{}".format(userID)
+	glob.streams.broadcast(streamName, serverPackets.spectatorFrames(packetData[7:]))
+	log.debug("Broadcasting {}'s frames to {} clients".format(
+		userID,
+		len(glob.streams.streams[streamName].clients))
+	)

events/startSpectatingEvent.py

@@ -8,6 +8,11 @@ def handle(userToken, packetData):
 		# Start spectating packet
 		packetData = clientPackets.startSpectating(packetData)
 
+		# If the user id is less than 0, treat this as a stop spectating packet
+		if packetData["userID"] < 0:
+			userToken.stopSpectating()
+			return
+
 		# Get host token
 		targetToken = glob.tokens.getTokenFromUserID(packetData["userID"])
 		if targetToken is None:

events/tournamentJoinMatchChannelEvent.py

@@ -5,7 +5,7 @@ from helpers import chatHelper as chat
 def handle(userToken, packetData):
 	packetData = clientPackets.tournamentJoinMatchChannel(packetData)
 	matchID = packetData["matchID"]
-	if matchID not in glob.matches.matches:
+	if matchID not in glob.matches.matches or not userToken.tournament:
 		return
 	userToken.matchID = matchID
 	chat.joinChannel(token=userToken, channel="#multi_{}".format(matchID))

events/tournamentLeaveMatchChannelEvent.py

@@ -5,7 +5,7 @@ from helpers import chatHelper as chat
 def handle(userToken, packetData):
 	packetData = clientPackets.tournamentLeaveMatchChannel(packetData)
 	matchID = packetData["matchID"]
-	if matchID not in glob.matches.matches:
+	if matchID not in glob.matches.matches or not userToken.tournament:
 		return
 	chat.partChannel(token=userToken, channel="#multi_{}".format(matchID))
 	userToken.matchID = 0

events/tournamentMatchInfoRequestEvent.py

@@ -1,10 +1,10 @@
 from constants import clientPackets
-from constants import serverPackets
 from objects import glob
 
 def handle(userToken, packetData):
 	packetData = clientPackets.tournamentMatchInfoRequest(packetData)
 	matchID = packetData["matchID"]
-	if matchID not in glob.matches.matches:
+	if matchID not in glob.matches.matches or not userToken.tournament:
 		return
-	userToken.enqueue(glob.matches.matches[matchID].matchDataCache)
+	with glob.matches.matches[matchID] as m:
+		userToken.enqueue(m.matchDataCache)

filters.txt

@@ -14,3 +14,10 @@ boobs=bob
 tits=teeth
 cum=yogurt
 cunt=count
+nigger=flowers
+ngger=flowers
+niggers=flowers
+weed=grass
+AQN=meme
+theaquila=meme
+aquila=meme

handlers/apiFokabotMessageHandler.py

@@ -1,6 +1,9 @@
 import json
 
-from common.log import logUtils as log
+import tornado.web
+import tornado.gen
+
+from common.sentry import sentry
 from common.web import requestsManager
 from constants import exceptions
 from helpers import chatHelper
@@ -8,6 +11,9 @@ from objects import glob
 
 
 class handler(requestsManager.asyncRequestHandler):
+	@tornado.web.asynchronous
+	@tornado.gen.engine
+	@sentry.captureTornado
 	def asyncGet(self):
 		statusCode = 400
 		data = {"message": "unknown error"}
@@ -21,7 +27,11 @@ class handler(requestsManager.asyncRequestHandler):
 			if key is None or key != glob.conf.config["server"]["cikey"]:
 				raise exceptions.invalidArgumentsException()
 
-			chatHelper.sendMessage("FokaBot", self.get_argument("to"), self.get_argument("msg"))
+			chatHelper.sendMessage(
+				glob.BOT_NAME,
+				self.get_argument("to").encode().decode("ASCII", "ignore"),
+				self.get_argument("msg").encode().decode("ASCII", "ignore")
+			)
 
 			# Status code and message
 			statusCode = 200

handlers/apiIsOnlineHandler.py

@@ -1,11 +1,19 @@
 import json
 
+import tornado.web
+import tornado.gen
+
+from common.sentry import sentry
+from common.ripple import userUtils
 from common.web import requestsManager
 from constants import exceptions
 from objects import glob
 
 
 class handler(requestsManager.asyncRequestHandler):
+	@tornado.web.asynchronous
+	@tornado.gen.engine
+	@sentry.captureTornado
 	def asyncGet(self):
 		statusCode = 400
 		data = {"message": "unknown error"}
@@ -18,7 +26,8 @@ class handler(requestsManager.asyncRequestHandler):
 			username = None
 			userID = None
 			if "u" in self.request.arguments:
-				username = self.get_argument("u").lower().replace(" ", "_")
+				#username = self.get_argument("u").lower().replace(" ", "_")
+				username = userUtils.safeUsername(self.get_argument("u"))
 			else:
 				try:
 					userID = int(self.get_argument("id"))

handlers/apiOnlineUsersHandler.py

@@ -1,10 +1,17 @@
 import json
 
+import tornado.web
+import tornado.gen
+
+from common.sentry import sentry
 from common.web import requestsManager
 from objects import glob
 
 
 class handler(requestsManager.asyncRequestHandler):
+	@tornado.web.asynchronous
+	@tornado.gen.engine
+	@sentry.captureTornado
 	def asyncGet(self):
 		statusCode = 400
 		data = {"message": "unknown error"}

handlers/apiServerStatusHandler.py

@@ -1,10 +1,17 @@
 import json
 
+import tornado.web
+import tornado.gen
+
+from common.sentry import sentry
 from common.web import requestsManager
 from objects import glob
 
 
 class handler(requestsManager.asyncRequestHandler):
+	@tornado.web.asynchronous
+	@tornado.gen.engine
+	@sentry.captureTornado
 	def asyncGet(self):
 		statusCode = 400
 		data = {"message": "unknown error"}

handlers/apiVerifiedStatusHandler.py

@@ -1,11 +1,18 @@
 import json
 
+import tornado.web
+import tornado.gen
+
+from common.sentry import sentry
 from common.web import requestsManager
 from constants import exceptions
 from objects import glob
 
 
 class handler(requestsManager.asyncRequestHandler):
+	@tornado.web.asynchronous
+	@tornado.gen.engine
+	@sentry.captureTornado
 	def asyncGet(self):
 		statusCode = 400
 		data = {"message": "unknown error"}

handlers/ciTriggerHandler.py

@@ -1,5 +1,9 @@
 import json
 
+import tornado.web
+import tornado.gen
+
+from common.sentry import sentry
 from common.log import logUtils as log
 from common.web import requestsManager
 from constants import exceptions
@@ -8,6 +12,9 @@ from objects import glob
 
 
 class handler(requestsManager.asyncRequestHandler):
+	@tornado.web.asynchronous
+	@tornado.gen.engine
+	@sentry.captureTornado
 	def asyncGet(self):
 		statusCode = 400
 		data = {"message": "unknown error"}

handlers/mainHandler.pyx

@@ -56,13 +56,14 @@ from events import tournamentJoinMatchChannelEvent
 from events import tournamentLeaveMatchChannelEvent
 from helpers import packetHelper
 from objects import glob
+from common.sentry import sentry
 
 
-class handler(SentryMixin, requestsManager.asyncRequestHandler):
+class handler(requestsManager.asyncRequestHandler):
 	@tornado.web.asynchronous
 	@tornado.gen.engine
+	@sentry.captureTornado
 	def asyncPost(self):
-		try:
 		# Track time if needed
 		if glob.outputRequestTime:
 			# Start time
@@ -92,7 +93,7 @@ class handler(SentryMixin, requestsManager.asyncRequestHandler):
 
 				# Token exists, get its object and lock it
 				userToken = glob.tokens.tokens[requestTokenString]
-					userToken.lock.acquire()
+				userToken.processingLock.acquire()
 
 				# Keep reading packets until everything has been read
 				while pos < len(requestData):
@@ -204,8 +205,8 @@ class handler(SentryMixin, requestsManager.asyncRequestHandler):
 				if userToken is not None:
 					# Update ping time for timeout
 					userToken.updatePingTime()
-						# Release token lock
-						userToken.lock.release()
+					# Release processing lock
+					userToken.processingLock.release()
 					# Delete token if kicked
 					if userToken.kicked:
 						glob.tokens.deleteToken(userToken)
@@ -238,12 +239,6 @@ class handler(SentryMixin, requestsManager.asyncRequestHandler):
 		self.add_header("Connection", "keep-alive")
 		self.add_header("Keep-Alive", "timeout=5, max=100")
 		self.add_header("Content-Type", "text/html; charset=UTF-8")
-		except:
-			log.error("Unknown error!\n```\n{}\n{}```".format(sys.exc_info(), traceback.format_exc()))
-			if glob.sentry:
-				yield tornado.gen.Task(self.captureException, exc_info=True)
-		#finally:
-		#	self.finish()
 
 	@tornado.web.asynchronous
 	@tornado.gen.engine

helpers/chatHelper.py

@@ -27,44 +27,32 @@ def joinChannel(userID = 0, channel = "", token = None, toIRC = True):
 				raise exceptions.userNotFoundException
 		else:
 			token = token
-			userID = token.userID
-
-		# Get usertoken data
-		username = token.username
 
 		# Normal channel, do check stuff
 		# Make sure the channel exists
 		if channel not in glob.channels.channels:
-			raise exceptions.channelUnknownException
-
-		# Check channel permissions
-		channelObject = glob.channels.channels[channel]
-		if channelObject.publicRead == False and token.admin == False:
-			raise exceptions.channelNoPermissionsException
-
-		# Add our userID to users in that channel
-		channelObject.userJoin(userID)
+			raise exceptions.channelUnknownException()
 
 		# Add the channel to our joined channel
-		token.joinChannel(channel)
-
-		# Send channel joined (bancho). We use clientName here because of #multiplayer and #spectator channels
-		token.enqueue(serverPackets.channelJoinSuccess(userID, channelObject.clientName))
+		token.joinChannel(glob.channels.channels[channel])
 
 		# Send channel joined (IRC)
 		if glob.irc == True and toIRC == True:
-			glob.ircServer.banchoJoinChannel(username, channel)
+			glob.ircServer.banchoJoinChannel(token.username, channel)
 
 		# Console output
-		log.info("{} joined channel {}".format(username, channel))
+		log.info("{} joined channel {}".format(token.username, channel))
 
 		# IRC code return
 		return 0
 	except exceptions.channelNoPermissionsException:
-		log.warning("{} attempted to join channel {}, but they have no read permissions".format(username, channel))
+		log.warning("{} attempted to join channel {}, but they have no read permissions".format(token.username, channel))
 		return 403
 	except exceptions.channelUnknownException:
-		log.warning("{} attempted to join an unknown channel ({})".format(username, channel))
+		log.warning("{} attempted to join an unknown channel ({})".format(token.username, channel))
+		return 403
+	except exceptions.userAlreadyInChannelException:
+		log.warning("User {} already in channel {}".format(token.username, channel))
 		return 403
 	except exceptions.userNotFoundException:
 		log.warning("User not connected to IRC/Bancho")
@@ -82,18 +70,18 @@ def partChannel(userID = 0, channel = "", token = None, toIRC = True, kick = Fal
 	:return: 0 if joined or other IRC code in case of error. Needed only on IRC-side
 	"""
 	try:
+		# Make sure the client is not drunk and sends partChannel when closing a PM tab
+		if not channel.startswith("#"):
+			return
+
 		# Get token if not defined
 		if token is None:
 			token = glob.tokens.getTokenFromUserID(userID)
 			# Make sure the token exists
 			if token is None:
-				raise exceptions.userNotFoundException
+				raise exceptions.userNotFoundException()
 		else:
 			token = token
-			userID = token.userID
-
-		# Get usertoken data
-		username = token.username
 
 		# Determine internal/client name if needed
 		# (toclient is used clientwise for #multiplayer and #spectator channels)
@@ -113,12 +101,20 @@ def partChannel(userID = 0, channel = "", token = None, toIRC = True, kick = Fal
 
 		# Make sure the channel exists
 		if channel not in glob.channels.channels:
-			raise exceptions.channelUnknownException
+			raise exceptions.channelUnknownException()
+
+		# Make sure the user is in the channel
+		if channel not in token.joinedChannels:
+			raise exceptions.userNotInChannelException()
 
 		# Part channel (token-side and channel-side)
 		channelObject = glob.channels.channels[channel]
-		token.partChannel(channel)
-		channelObject.userPart(userID)
+		token.partChannel(channelObject)
+
+		# Delete temporary channel if everyone left
+		if "chat/{}".format(channelObject.name) in glob.streams.streams:
+			if channelObject.temp == True and len(glob.streams.streams["chat/{}".format(channelObject.name)].clients) - 1 == 0:
+				glob.channels.removeChannel(channelObject.name)
 
 		# Force close tab if needed
 		# NOTE: Maybe always needed, will check later
@@ -127,16 +123,19 @@ def partChannel(userID = 0, channel = "", token = None, toIRC = True, kick = Fal
 
 		# IRC part
 		if glob.irc == True and toIRC == True:
-			glob.ircServer.banchoPartChannel(username, channel)
+			glob.ircServer.banchoPartChannel(token.username, channel)
 
 		# Console output
-		log.info("{} parted channel {} ({})".format(username, channel, channelClient))
+		log.info("{} parted channel {} ({})".format(token.username, channel, channelClient))
 
 		# Return IRC code
 		return 0
 	except exceptions.channelUnknownException:
-		log.warning("{} attempted to part an unknown channel ({})".format(username, channel))
+		log.warning("{} attempted to part an unknown channel ({})".format(token.username, channel))
 		return 403
+	except exceptions.userNotInChannelException:
+		log.warning("{} attempted to part {}, but he's not in that channel".format(token.username, channel))
+		return 442
 	except exceptions.userNotFoundException:
 		log.warning("User not connected to IRC/Bancho")
 		return 442	# idk
@@ -153,24 +152,20 @@ def sendMessage(fro = "", to = "", message = "", token = None, toIRC = True):
 	:return: 0 if joined or other IRC code in case of error. Needed only on IRC-side
 	"""
 	try:
-		tokenString = ""
+		#tokenString = ""
 		# Get token object if not passed
 		if token is None:
 			token = glob.tokens.getTokenFromUsername(fro)
 			if token is None:
-				raise exceptions.userNotFoundException
+				raise exceptions.userNotFoundException()
 		else:
 			# token object alredy passed, get its string and its username (fro)
 			fro = token.username
-			tokenString = token.token
-
-		# Set some variables
-		userID = token.userID
-		username = token.username
+			#tokenString = token.token
 
 		# Make sure this is not a tournament client
-		if token.tournament:
-			raise exceptions.userTournamentException()
+		# if token.tournament:
+		# 	raise exceptions.userTournamentException()
 
 		# Make sure the user is not in restricted mode
 		if token.restricted:
@@ -180,12 +175,16 @@ def sendMessage(fro = "", to = "", message = "", token = None, toIRC = True):
 		if token.isSilenced():
 			raise exceptions.userSilencedException()
 
+		# Redirect !report to FokaBot
+		if message.startswith("!report"):
+			to = glob.BOT_NAME
+
 		# Determine internal name if needed
 		# (toclient is used clientwise for #multiplayer and #spectator channels)
 		toClient = to
 		if to == "#spectator":
 			if token.spectating is None:
-				s = userID
+				s = token.userID
 			else:
 				s = token.spectatingUserID
 			to = "#spect_{}".format(s)
@@ -196,6 +195,10 @@ def sendMessage(fro = "", to = "", message = "", token = None, toIRC = True):
 		elif to.startswith("#multi_"):
 			toClient = "#multiplayer"
 
+		# Make sure the message is valid
+		if not message.strip():
+			raise exceptions.invalidArgumentsException()
+
 		# Truncate message if > 2048 characters
 		message = message[:2048]+"..." if len(message) > 2048 else message
 
@@ -203,7 +206,7 @@ def sendMessage(fro = "", to = "", message = "", token = None, toIRC = True):
 		message = glob.chatFilters.filterMessage(message)
 
 		# Build packet bytes
-		packet = serverPackets.sendMessage(username, toClient, message)
+		packet = serverPackets.sendMessage(token.username, toClient, message)
 
 		# Send the message
 		isChannel = to.startswith("#")
@@ -211,45 +214,41 @@ def sendMessage(fro = "", to = "", message = "", token = None, toIRC = True):
 			# CHANNEL
 			# Make sure the channel exists
 			if to not in glob.channels.channels:
-				raise exceptions.channelUnknownException
+				raise exceptions.channelUnknownException()
 
 			# Make sure the channel is not in moderated mode
 			if glob.channels.channels[to].moderated == True and token.admin == False:
-				raise exceptions.channelModeratedException
+				raise exceptions.channelModeratedException()
 
 			# Make sure we have write permissions
 			if glob.channels.channels[to].publicWrite == False and token.admin == False:
-				raise exceptions.channelNoPermissionsException
+				raise exceptions.channelNoPermissionsException()
+
+			# Add message in buffer
+			token.addMessageInBuffer(to, message)
 
 			# Everything seems fine, build recipients list and send packet
-			recipients = glob.channels.channels[to].connectedUsers[:]
-			for key, value in glob.tokens.tokens.items():
-				# Skip our client and irc clients
-				if key == tokenString or value.irc == True:
-					continue
-				# Send to this client if it's connected to the channel
-				if value.userID in recipients:
-					value.enqueue(packet)
+			glob.streams.broadcast("chat/{}".format(to), packet, but=[token.token])
 		else:
 			# USER
 			# Make sure recipient user is connected
 			recipientToken = glob.tokens.getTokenFromUsername(to)
 			if recipientToken is None:
-				raise exceptions.userNotFoundException
+				raise exceptions.userNotFoundException()
 
 			# Make sure the recipient is not a tournament client
-			if recipientToken.tournament:
-				raise exceptions.userTournamentException()
+			#if recipientToken.tournament:
+			#	raise exceptions.userTournamentException()
 
 			# Make sure the recipient is not restricted or we are FokaBot
-			if recipientToken.restricted == True and fro.lower() != "fokabot":
+			if recipientToken.restricted == True and fro.lower() != glob.BOT_NAME.lower():
 				raise exceptions.userRestrictedException()
 
 			# TODO: Make sure the recipient has not disabled PMs for non-friends or he's our friend
 
 			# Away check
-			if recipientToken.awayCheck(userID):
-				sendMessage(to, fro, "\x01ACTION is away: {message}\x01".format(code=chr(int(1)), message=recipientToken.awayMessage))
+			if recipientToken.awayCheck(token.userID):
+				sendMessage(to, fro, "\x01ACTION is away: {}\x01".format(recipientToken.awayMessage))
 
 			# Check message templates (mods/admins only)
 			if message in messageTemplates.templates and token.admin == True:
@@ -260,45 +259,52 @@ def sendMessage(fro = "", to = "", message = "", token = None, toIRC = True):
 
 		# Send the message to IRC
 		if glob.irc == True and toIRC == True:
-			glob.ircServer.banchoMessage(fro, to, message)
+			messageSplitInLines = message.encode("latin-1").decode("utf-8").split("\n")
+			for line in messageSplitInLines:
+				if line == messageSplitInLines[:1] and line == "":
+					continue
+				glob.ircServer.banchoMessage(fro, to, line)
 
 		# Spam protection (ignore FokaBot)
-		if userID > 999:
+		if token.userID > 999:
 			token.spamProtection()
 
 		# Fokabot message
-		if isChannel == True or to.lower() == "fokabot":
-			fokaMessage = fokabot.fokabotResponse(username, to, message)
+		if isChannel == True or to.lower() == glob.BOT_NAME.lower():
+			fokaMessage = fokabot.fokabotResponse(token.username, to, message)
 			if fokaMessage:
-				sendMessage("FokaBot", to if isChannel else fro, fokaMessage)
+				sendMessage(glob.BOT_NAME, to if isChannel else fro, fokaMessage)
 
 		# File and discord logs (public chat only)
 		if to.startswith("#") and not (message.startswith("\x01ACTION is playing") and to.startswith("#spect_")):
-			log.chat("{fro} @ {to}: {message}".format(fro=username, to=to, message=str(message.encode("utf-8"))))
-			glob.schiavo.sendChatlog("**{fro} @ {to}:** {message}".format(fro=username, to=to, message=str(message.encode("utf-8"))[2:-1]))
+			log.chat("{fro} @ {to}: {message}".format(fro=token.username, to=to, message=message.encode("latin-1").decode("utf-8")))
+			glob.schiavo.sendChatlog("**{fro} @ {to}:** {message}".format(fro=token.username, to=to, message=message.encode("latin-1").decode("utf-8")))
 		return 0
 	except exceptions.userSilencedException:
 		token.enqueue(serverPackets.silenceEndTime(token.getSilenceSecondsLeft()))
-		log.warning("{} tried to send a message during silence".format(username))
+		log.warning("{} tried to send a message during silence".format(token.username))
 		return 404
 	except exceptions.channelModeratedException:
-		log.warning("{} tried to send a message to a channel that is in moderated mode ({})".format(username, to))
+		log.warning("{} tried to send a message to a channel that is in moderated mode ({})".format(token.username, to))
 		return 404
 	except exceptions.channelUnknownException:
-		log.warning("{} tried to send a message to an unknown channel ({})".format(username, to))
+		log.warning("{} tried to send a message to an unknown channel ({})".format(token.username, to))
 		return 403
 	except exceptions.channelNoPermissionsException:
-		log.warning("{} tried to send a message to channel {}, but they have no write permissions".format(username, to))
+		log.warning("{} tried to send a message to channel {}, but they have no write permissions".format(token.username, to))
 		return 404
 	except exceptions.userRestrictedException:
-		log.warning("{} tried to send a message {}, but the recipient is in restricted mode".format(username, to))
+		log.warning("{} tried to send a message {}, but the recipient is in restricted mode".format(token.username, to))
 		return 404
 	except exceptions.userTournamentException:
-		log.warning("{} tried to send a message {}, but the recipient is a tournament client".format(username, to))
+		log.warning("{} tried to send a message {}, but the recipient is a tournament client".format(token.username, to))
 		return 404
 	except exceptions.userNotFoundException:
 		log.warning("User not connected to IRC/Bancho")
 		return 401
+	except exceptions.invalidArgumentsException:
+		log.warning("{} tried to send an invalid message to {}".format(token.username, to))
+		return 404
 
 
 """ IRC-Bancho Connect/Disconnect/Join/Part interfaces"""

helpers/configHelper.py

@@ -48,8 +48,8 @@ class config:
 			self.config.get("server","gziplevel")
 			self.config.get("server","cikey")
 
-			self.config.get("mirror","url")
-			self.config.get("mirror","apikey")
+			self.config.get("cheesegull", "apiurl")
+			self.config.get("cheesegull", "apikey")
 
 			self.config.get("debug","enable")
 			self.config.get("debug","packets")
@@ -74,7 +74,7 @@ class config:
 			self.config.get("localize","enable")
 			self.config.get("localize","ipapiurl")
 			return True
-		except:
+		except configparser.Error:
 			return False
 
 	def generateDefaultConfig(self):
@@ -107,9 +107,9 @@ class config:
 		self.config.set("server", "gziplevel", "6")
 		self.config.set("server", "cikey", "changeme")
 
-		self.config.add_section("mirror")
-		self.config.set("mirror", "url", "http://storage.ripple.moe")
-		self.config.set("mirror", "apikey", "anotherkey")
+		self.config.add_section("cheesegull")
+		self.config.set("cheesegull", "apiurl", "http://cheesegu.ll/api")
+		self.config.set("cheesegull", "apikey", "")
 
 		self.config.add_section("debug")
 		self.config.set("debug", "enable", "0")

helpers/consoleHelper.py

@@ -28,7 +28,7 @@ def printServerStartHeader(asciiArt=True):
 
 	printColored("> Welcome to pep.py osu!bancho server v{}".format(glob.VERSION), bcolors.GREEN)
 	printColored("> Made by the Ripple team", bcolors.GREEN)
-	printColored("> {}https://git.zxq.co/ripple/pep.py".format(bcolors.UNDERLINE), bcolors.GREEN)
+	printColored("> {}https://zxq.co/ripple/pep.py".format(bcolors.UNDERLINE), bcolors.GREEN)
 	printColored("> Press CTRL+C to exit\n", bcolors.GREEN)
 
 def printNoNl(string):

helpers/locationHelper.py

@@ -30,7 +30,7 @@ def getLocation(ip):
 	try:
 		# Try to get position from Pikolo Aul's Go-Sanic ip API
 		result = json.loads(urllib.request.urlopen("{}/{}".format(glob.conf.config["localize"]["ipapiurl"], ip), timeout=3).read().decode())["loc"].split(",")
-		return (float(result[0]), float(result[1]))
+		return float(result[0]), float(result[1])
 	except:
 		log.error("Error in get position")
-		return (0, 0)
+		return 0, 0

helpers/packetHelper.pyx

@@ -136,7 +136,7 @@ cpdef bytes packData(__data, int dataType):
 
 	return data
 
-cpdef bytes buildPacket(int __packet, list __packetData = []):
+cpdef bytes buildPacket(int __packet, list __packetData = None):
 	"""
 	Builds a packet
 
@@ -144,6 +144,9 @@ cpdef bytes buildPacket(int __packet, list __packetData = []):
 	:param __packetData: packet structure [[data, dataType], [data, dataType], ...]
 	:return: packet bytes
 	"""
+	# Default argument
+	if __packetData is None:
+		__packetData = []
 	# Set some variables
 	cdef bytes packetData = bytes()
 	cdef int packetLength = 0
@@ -183,7 +186,7 @@ cpdef int readPacketLength(bytes stream):
 	return unpackData(stream[3:7], dataTypes.UINT32)
 
 
-cpdef readPacketData(bytes stream, list structure=[], bint hasFirstBytes = True):
+cpdef readPacketData(bytes stream, list structure=None, bint hasFirstBytes = True):
 	"""
 	Read packet data from `stream` according to `structure`
 	:param stream: packet bytes
@@ -192,6 +195,10 @@ cpdef readPacketData(bytes stream, list structure=[], bint hasFirstBytes = True)
 							if False, `stream` has only packet data. Default: True
 	:return: {name: unpackedValue, ...}
 	"""
+	# Default list argument
+	if structure is None:
+		structure = []
+
 	# Read packet ID (first 2 bytes)
 	cdef dict data = {}
 

helpers/systemHelper.py

@@ -43,7 +43,7 @@ def scheduleShutdown(sendRestartTime, restart, message = "", delay=20):
 	:return:
 	"""
 	# Console output
-	log.info("Pep.py will {} in {} seconds!".format("restart" if restart else "shutdown", sendRestartTime+delay))
+	log.info("Pep.py will {} in {} seconds!".format("restart" if restart else "shutdown", sendRestartTime+delay), "bunker")
 	log.info("Sending server restart packets in {} seconds...".format(sendRestartTime))
 
 	# Send notification if set

irc/ircserver.py

@@ -17,6 +17,7 @@ import traceback
 import raven
 
 from common.log import logUtils as log
+from common.ripple import userUtils
 from helpers import chatHelper as chat
 from objects import glob
 
@@ -44,6 +45,7 @@ class Client:
 		self.IRCUsername = ""
 		self.banchoUsername = ""
 		self.supposedUsername = ""
+		self.supposedUserID = 0
 		self.joinedChannels = []
 
 	def messageChannel(self, channel, command, message, includeSelf=False):
@@ -136,7 +138,7 @@ class Client:
 		self.server.removeClient(self, quitmsg)
 
 		# Bancho logout
-		if callLogout:
+		if callLogout and self.banchoUsername != "":
 			chat.IRCDisconnect(self.IRCUsername)
 
 
@@ -280,9 +282,10 @@ class Client:
 				m = hashlib.md5()
 				m.update(arguments[0].encode("utf-8"))
 				tokenHash = m.hexdigest()
-				supposedUsername = glob.db.fetch("SELECT users.username FROM users LEFT JOIN irc_tokens ON users.id = irc_tokens.userid WHERE irc_tokens.token = %s LIMIT 1", [tokenHash])
-				if supposedUsername:
-					self.supposedUsername = chat.fixUsernameForIRC(supposedUsername["username"])
+				supposedUser = glob.db.fetch("SELECT users.username, users.id FROM users LEFT JOIN irc_tokens ON users.id = irc_tokens.userid WHERE irc_tokens.token = %s LIMIT 1", [tokenHash])
+				if supposedUser:
+					self.supposedUsername = chat.fixUsernameForIRC(supposedUser["username"])
+					self.supposedUserID = supposedUser["id"]
 					self.__handleCommand = self.registerHandler
 				else:
 					# Wrong IRC Token
@@ -310,6 +313,11 @@ class Client:
 				self.reply("464 :Password incorrect")
 				return
 
+			# Make sure that the user is not banned/restricted:
+			if not userUtils.isAllowed(self.supposedUserID):
+				self.reply("465 :You're banned")
+				return
+
 			# Make sure we are not connected to Bancho
 			token = glob.tokens.getTokenFromUsername(chat.fixUsernameForBancho(nick), True)
 			if token is not None:
@@ -350,11 +358,11 @@ class Client:
 			self.sendMotd()
 			self.__handleCommand = self.mainHandler
 
-	def quitHandler(self, command, arguments):
+	def quitHandler(self, _, arguments):
 		"""QUIT command handler"""
 		self.disconnect(self.IRCUsername if len(arguments) < 1 else arguments[0])
 
-	def joinHandler(self, command, arguments):
+	def joinHandler(self, _, arguments):
 		"""JOIN command handler"""
 		if len(arguments) < 1:
 			self.reply461("JOIN")
@@ -402,13 +410,15 @@ class Client:
 					self.replyCode(332, description, channel=channel)
 
 				# Build connected users list
-				users = glob.channels.channels[channel].connectedUsers[:]
+				if "chat/{}".format(channel) not in glob.streams.streams:
+					self.reply403(channel)
+					continue
+				users = glob.streams.streams["chat/{}".format(channel)].clients
 				usernames = []
 				for user in users:
-					token = glob.tokens.getTokenFromUserID(user)
-					if token is None:
+					if user not in glob.tokens.tokens:
 						continue
-					usernames.append(chat.fixUsernameForIRC(token.username))
+					usernames.append(chat.fixUsernameForIRC(glob.tokens.tokens[user].username))
 				usernames = " ".join(usernames)
 
 				# Send IRC users list
@@ -419,7 +429,7 @@ class Client:
 				self.reply403(channel)
 				continue
 
-	def partHandler(self, command, arguments):
+	def partHandler(self, _, arguments):
 		"""PART command handler"""
 		if len(arguments) < 1:
 			self.reply461("PART")
@@ -503,7 +513,7 @@ class Client:
 		"""LUSERS command handler"""
 		self.sendLusers()
 
-	def pingHandler(self, command, arguments):
+	def pingHandler(self, _, arguments):
 		"""PING command handler"""
 		if len(arguments) < 1:
 			self.replyCode(409, "No origin specified")
@@ -514,7 +524,7 @@ class Client:
 		"""(fake) PONG command handler"""
 		pass
 
-	def awayHandler(self, command, arguments):
+	def awayHandler(self, _, arguments):
 		"""AWAY command handler"""
 		response = chat.IRCAway(self.banchoUsername, " ".join(arguments))
 		self.replyCode(response, "You are no longer marked as being away" if response == 305 else "You have been marked as being away")
@@ -619,12 +629,11 @@ class Server:
 					value.message(":{} PRIVMSG {} :{}".format(fro, to, message))
 
 
-	def removeClient(self, client, quitmsg):
+	def removeClient(self, client, _):
 		"""
 		Remove a client from connected clients
 
 		:param client: client object
-		:param quitmsg: QUIT argument, useless atm
 		:return:
 		"""
 		if client.socket in self.clients:
@@ -637,6 +646,7 @@ class Server:
 		:return:
 		"""
 		# Sentry
+		sentryClient = None
 		if glob.sentry:
 			sentryClient = raven.Client(glob.conf.config["sentry"]["ircdns"])
 
@@ -669,7 +679,7 @@ class Server:
 						try:
 							self.clients[conn] = Client(self, conn)
 							log.info("[IRC] Accepted connection from {}:{}".format(addr[0], addr[1]))
-						except socket.error as e:
+						except socket.error:
 							try:
 								conn.close()
 							except:
@@ -688,7 +698,7 @@ class Server:
 					lastAliveCheck = now
 			except:
 				log.error("[IRC] Unknown error!\n```\n{}\n{}```".format(sys.exc_info(), traceback.format_exc()))
-				if glob.sentry:
+				if glob.sentry and sentryClient is not None:
 					sentryClient.captureException()
 
 def main(port=6667):

objects/channel.py

@@ -18,7 +18,6 @@ class channel:
 		self.publicWrite = publicWrite
 		self.moderated = False
 		self.temp = temp
-		self.connectedUsers = [999]	# Fokabot is always connected to every channels (otherwise it doesn't show up in IRC users list)
 		self.hidden = hidden
 
 		# Client name (#spectator/#multiplayer)
@@ -28,27 +27,7 @@ class channel:
 		elif self.name.startswith("#multi_"):
 			self.clientName = "#multiplayer"
 
-	def userJoin(self, userID):
-		"""
-		Add a user to connected users
-
-		:param userID:
-		:return:
-		"""
-		if userID not in self.connectedUsers:
-			self.connectedUsers.append(userID)
-
-	def userPart(self, userID):
-		"""
-		Remove a user from connected users
-
-		:param userID:
-		:return:
-		"""
-		if userID in self.connectedUsers:
-			self.connectedUsers.remove(userID)
-
-		# Remove temp channels if empty or there's only fokabot connected
-		l = len(self.connectedUsers)
-		if self.temp == True and ((l == 0) or (l == 1 and 999 in self.connectedUsers)):
-			glob.channels.removeChannel(self.name)
+		# Make Foka join the channel
+		fokaToken = glob.tokens.getTokenFromUserID(999)
+		if fokaToken is not None:
+			fokaToken.joinChannel(self)

objects/channelList.py

@@ -1,6 +1,7 @@
 from common.log import logUtils as log
 from objects import channel
 from objects import glob
+from helpers import chatHelper as chat
 
 
 class channelList:
@@ -34,6 +35,7 @@ class channelList:
 		:param hidden: if True, thic channel won't be shown in channels list
 		:return:
 		"""
+		glob.streams.add("chat/{}".format(name))
 		self.channels[name] = channel.channel(name, description, publicRead, publicWrite, temp, hidden)
 		log.info("Created channel {}".format(name))
 
@@ -47,9 +49,24 @@ class channelList:
 		"""
 		if name in self.channels:
 			return False
+		glob.streams.add("chat/{}".format(name))
 		self.channels[name] = channel.channel(name, "Chat", True, True, True, True)
 		log.info("Created temp channel {}".format(name))
 
+	def addHiddenChannel(self, name):
+		"""
+		Add a hidden channel. It's like a normal channel and must be deleted manually,
+		but it's not shown in channels list.
+
+		:param name: channel name
+		:return: True if the channel was created, otherwise False
+		"""
+		if name in self.channels:
+			return False
+		glob.streams.add("chat/{}".format(name))
+		self.channels[name] = channel.channel(name, "Chat", True, True, False, True)
+		log.info("Created hidden channel {}".format(name))
+
 	def removeChannel(self, name):
 		"""
 		Removes a channel from channels list
@@ -60,5 +77,13 @@ class channelList:
 		if name not in self.channels:
 			log.debug("{} is not in channels list".format(name))
 			return
+		#glob.streams.broadcast("chat/{}".format(name), serverPackets.channelKicked(name))
+		stream = glob.streams.getStream("chat/{}".format(name))
+		if stream is not None:
+			for token in stream.clients:
+				if token in glob.tokens.tokens:
+					chat.partChannel(channel=name, token=glob.tokens.tokens[token], kick=True)
+		glob.streams.dispose("chat/{}".format(name))
+		glob.streams.remove("chat/{}".format(name))
 		self.channels.pop(name)
 		log.info("Removed channel {}".format(name))

objects/chatFilters.py

@@ -36,6 +36,8 @@ class chatFilters:
 		:param message: normal message
 		:return: filtered message
 		"""
+		return message
+		"""
 		# Split words by spaces
 		messageTemp = message.split(" ")
 
@@ -49,3 +51,4 @@ class chatFilters:
 
 		# Return filtered message
 		return message
+		"""

objects/fokabot.py

@@ -17,6 +17,7 @@ def connect():
 
 	:return:
 	"""
+	glob.BOT_NAME = userUtils.getUsername(999)
 	token = glob.tokens.addToken(999)
 	token.actionID = actions.IDLE
 	glob.streams.broadcast("main", serverPackets.userPanel(999))
@@ -41,7 +42,7 @@ def fokabotResponse(fro, chan, message):
 	"""
 	for i in fokabotCommands.commands:
 		# Loop though all commands
-		if generalUtils.strContains(message, i["trigger"]):
+		if re.compile("^{}( (.+)?)?$".format(i["trigger"])).match(message.strip()):
 			# message has triggered a command
 
 			# Make sure the user has right permissions

objects/glob.py

@@ -11,13 +11,14 @@ from common.web import schiavo
 
 try:
 	with open("version") as f:
-		VERSION = f.read()
+		VERSION = f.read().strip()
 	if VERSION == "":
 		raise Exception
 except:
 	VERSION = "Unknown"
 
 DATADOG_PREFIX = "peppy"
+BOT_NAME = "FokaBot"
 application = None
 db = None
 redis = None

objects/match.py

@@ -1,4 +1,9 @@
 import copy
+import json
+import threading
+
+import time
+
 from common.log import logUtils as log
 from constants import dataTypes
 from constants import matchModModes
@@ -14,16 +19,19 @@ from objects import glob
 class slot:
 	def __init__(self):
 		self.status = slotStatuses.FREE
-		self.team = 0
+		self.team = matchTeams.NO_TEAM
 		self.userID = -1
 		self.user = None
 		self.mods = 0
 		self.loaded = False
 		self.skip = False
 		self.complete = False
+		self.score = 0
+		self.failed = False
+		self.passed = True
 
 class match:
-	def __init__(self, matchID, matchName, matchPassword, beatmapID, beatmapName, beatmapMD5, gameMode, hostUserID):
+	def __init__(self, matchID, matchName, matchPassword, beatmapID, beatmapName, beatmapMD5, gameMode, hostUserID, isTourney=False):
 		"""
 		Create a new match object
 
@@ -53,6 +61,11 @@ class match:
 		self.matchModMode = matchModModes.NORMAL			# default value
 		self.seed = 0
 		self.matchDataCache = bytes()
+		self.isTourney = isTourney
+		self.isLocked = False 	# if True, users can't change slots/teams. Used in tourney matches
+		self.isStarting = False
+		self._lock = threading.Lock()
+		self.createTime = int(time.time())
 
 		# Create all slots and reset them
 		self.slots = []
@@ -64,59 +77,67 @@ class match:
 		glob.streams.add(self.playingStreamName)
 
 		# Create #multiplayer channel
-		glob.channels.addTempChannel("#multi_{}".format(self.matchID))
+		glob.channels.addHiddenChannel("#multi_{}".format(self.matchID))
+		log.info("MPROOM{}: {} match created!".format(self.matchID, "Tourney" if self.isTourney else "Normal"))
 
-	def getMatchData(self):
+	def getMatchData(self, censored = False):
 		"""
 		Return binary match data structure for packetHelper
+		Return binary match data structure for packetHelper
 
 		:return:
 		"""
 		# General match info
 		# TODO: Test without safe copy, the error might have been caused by outdated python bytecode cache
-		safeMatch = copy.deepcopy(self)
+		# safeMatch = copy.deepcopy(self)
 		struct = [
-			[safeMatch.matchID, dataTypes.UINT16],
-			[int(safeMatch.inProgress), dataTypes.BYTE],
+			[self.matchID, dataTypes.UINT16],
+			[int(self.inProgress), dataTypes.BYTE],
 			[0, dataTypes.BYTE],
-			[safeMatch.mods, dataTypes.UINT32],
-			[safeMatch.matchName, dataTypes.STRING],
-			[safeMatch.matchPassword, dataTypes.STRING],
-			[safeMatch.beatmapName, dataTypes.STRING],
-			[safeMatch.beatmapID, dataTypes.UINT32],
-			[safeMatch.beatmapMD5, dataTypes.STRING],
+			[self.mods, dataTypes.UINT32],
+			[self.matchName, dataTypes.STRING]
 		]
+		if censored and self.matchPassword:
+			struct.append(["redacted", dataTypes.STRING])
+		else:
+			struct.append([self.matchPassword, dataTypes.STRING])
+
+		struct.extend([
+			[self.beatmapName, dataTypes.STRING],
+			[self.beatmapID, dataTypes.UINT32],
+			[self.beatmapMD5, dataTypes.STRING]
+		])
 
 		# Slots status IDs, always 16 elements
 		for i in range(0,16):
-			struct.append([safeMatch.slots[i].status, dataTypes.BYTE])
+			struct.append([self.slots[i].status, dataTypes.BYTE])
 
 		# Slot teams, always 16 elements
 		for i in range(0,16):
-			struct.append([safeMatch.slots[i].team, dataTypes.BYTE])
+			struct.append([self.slots[i].team, dataTypes.BYTE])
 
 		# Slot user ID. Write only if slot is occupied
 		for i in range(0,16):
-			if safeMatch.slots[i].user is not None and safeMatch.slots[i].user in glob.tokens.tokens:
-				struct.append([glob.tokens.tokens[safeMatch.slots[i].user].userID, dataTypes.UINT32])
+			if self.slots[i].user is not None and self.slots[i].user in glob.tokens.tokens:
+				struct.append([glob.tokens.tokens[self.slots[i].user].userID, dataTypes.UINT32])
 
 		# Other match data
 		struct.extend([
-			[safeMatch.hostUserID, dataTypes.SINT32],
-			[safeMatch.gameMode, dataTypes.BYTE],
-			[safeMatch.matchScoringType, dataTypes.BYTE],
-			[safeMatch.matchTeamType, dataTypes.BYTE],
-			[safeMatch.matchModMode, dataTypes.BYTE],
+			[self.hostUserID, dataTypes.SINT32],
+			[self.gameMode, dataTypes.BYTE],
+			[self.matchScoringType, dataTypes.BYTE],
+			[self.matchTeamType, dataTypes.BYTE],
+			[self.matchModMode, dataTypes.BYTE],
 		])
 
 		# Slot mods if free mod is enabled
-		if safeMatch.matchModMode == matchModModes.FREE_MOD:
+		if self.matchModMode == matchModModes.FREE_MOD:
 			for i in range(0,16):
-				struct.append([safeMatch.slots[i].mods, dataTypes.UINT32])
+				struct.append([self.slots[i].mods, dataTypes.UINT32])
 
 		# Seed idk
 		# TODO: Implement this, it should be used for mania "random" mod
-		struct.append([safeMatch.seed, dataTypes.UINT32])
+		struct.append([self.seed, dataTypes.UINT32])
 
 		return struct
 
@@ -129,12 +150,22 @@ class match:
 		"""
 		slotID = self.getUserSlotID(newHost)
 		if slotID is None or self.slots[slotID].user not in glob.tokens.tokens:
-			return
+			return False
 		token = glob.tokens.tokens[self.slots[slotID].user]
 		self.hostUserID = newHost
 		token.enqueue(serverPackets.matchTransferHost())
 		self.sendUpdates()
 		log.info("MPROOM{}: {} is now the host".format(self.matchID, token.username))
+		return True
+
+	def removeHost(self):
+		"""
+		Removes the host (for tourney matches)
+		:return:
+		"""
+		self.hostUserID = -1
+		self.sendUpdates()
+		log.info("MPROOM{}: Removed host".format(self.matchID))
 
 	def setSlot(self, slotID, status = None, team = None, user = "", mods = None, loaded = None, skip = None, complete = None):
 		"""
@@ -195,6 +226,8 @@ class match:
 		:return:
 		"""
 		# Update ready status and setnd update
+		if self.slots[slotID].user is None or self.isStarting:
+			return
 		oldStatus = self.slots[slotID].status
 		if oldStatus == slotStatuses.READY:
 			newStatus = slotStatuses.NOT_READY
@@ -204,7 +237,7 @@ class match:
 		self.sendUpdates()
 		log.info("MPROOM{}: Slot{} changed ready status to {}".format(self.matchID, slotID, self.slots[slotID].status))
 
-	def toggleSlotLock(self, slotID):
+	def toggleSlotLocked(self, slotID):
 		"""
 		Lock a slot
 		Same as calling setSlot and then sendUpdate
@@ -305,6 +338,26 @@ class match:
 		glob.streams.broadcast(self.playingStreamName, serverPackets.allPlayersSkipped())
 		log.info("MPROOM{}: All players have skipped!".format(self.matchID))
 
+	def updateScore(self, slotID, score):
+		"""
+		Update score for a slot
+
+		:param slotID: the slot that the user that is updating their score is in
+		:param score: the new score to update
+		:return:
+		"""
+		self.slots[slotID].score = score
+
+	def updateHP(self, slotID, hp):
+		"""
+		Update HP for a slot
+
+		:param slotID: the slot that the user that is updating their hp is in
+		:param hp: the new hp to update
+		:return:
+		"""
+		self.slots[slotID].failed = True if hp == 254 else False
+
 	def playerCompleted(self, userID):
 		"""
 		Set userID's slot completed to True
@@ -337,16 +390,35 @@ class match:
 
 		:return:
 		"""
+		# Collect some info about the match that just ended to send to the api
+		infoToSend = {
+			"id": self.matchID,
+			"name": self.matchName,
+			"beatmap_id": self.beatmapID,
+			"mods": self.mods,
+			"game_mode": self.gameMode,
+			"scores": {}
+		}
+
+		# Add score info for each player
+		for i in range(0,16):
+			if self.slots[i].user is not None and self.slots[i].status == slotStatuses.PLAYING:
+				infoToSend["scores"][glob.tokens.tokens[self.slots[i].user].userID] = {
+					"score": self.slots[i].score,
+					"mods": self.slots[i].mods,
+					"failed": self.slots[i].failed,
+					"pass": self.slots[i].passed,
+					"team": self.slots[i].team
+				}
+
+		# Send the info to the api
+		glob.redis.publish("api:mp_complete_match", json.dumps(infoToSend))
+
 		# Reset inProgress
 		self.inProgress = False
 
 		# Reset slots
-		for i in range(0,16):
-			if self.slots[i].user is not None and self.slots[i].status == slotStatuses.PLAYING:
-				self.slots[i].status = slotStatuses.NOT_READY
-				self.slots[i].loaded = False
-				self.slots[i].skip = False
-				self.slots[i].complete = False
+		self.resetSlots()
 
 		# Send match update
 		self.sendUpdates()
@@ -355,11 +427,29 @@ class match:
 		glob.streams.broadcast(self.streamName, serverPackets.matchComplete())
 
 		# Destroy playing stream
+		glob.streams.dispose(self.playingStreamName)
 		glob.streams.remove(self.playingStreamName)
 
 		# Console output
 		log.info("MPROOM{}: Match completed".format(self.matchID))
 
+		# If this is a tournament match, then we send a notification in the chat
+		# saying that the match has completed.
+		chanName = "#multi_{}".format(self.matchID)
+		if self.isTourney and (chanName in glob.channels.channels):
+			chat.sendMessage(glob.BOT_NAME, chanName, "Match has just finished.")
+
+	def resetSlots(self):
+		for i in range(0,16):
+			if self.slots[i].user is not None and self.slots[i].status == slotStatuses.PLAYING:
+				self.slots[i].status = slotStatuses.NOT_READY
+				self.slots[i].loaded = False
+				self.slots[i].skip = False
+				self.slots[i].complete = False
+				self.slots[i].score = 0
+				self.slots[i].failed = False
+				self.slots[i].passed = True
+
 	def getUserSlotID(self, userID):
 		"""
 		Get slot ID occupied by userID
@@ -375,7 +465,7 @@ class match:
 		"""
 		Add someone to users in match
 
-		:param userID: user id of the user
+		:param user: user object of the user
 		:return: True if join success, False if fail (room is full)
 		"""
 		# Make sure we're not in this match
@@ -388,7 +478,10 @@ class match:
 		for i in range(0,16):
 			if self.slots[i].status == slotStatuses.FREE:
 				# Occupy slot
-				self.setSlot(i, slotStatuses.NOT_READY, 0, user.token, 0)
+				team = matchTeams.NO_TEAM
+				if self.matchTeamType == matchTeamTypes.TEAM_VS or self.matchTeamType == matchTeamTypes.TAG_TEAM_VS:
+					team = matchTeams.RED if i % 2 == 0 else matchTeams.BLUE
+				self.setSlot(i, slotStatuses.NOT_READY, team, user.token, 0)
 
 				# Send updated match data
 				self.sendUpdates()
@@ -399,11 +492,12 @@ class match:
 
 		return False
 
-	def userLeft(self, user):
+	def userLeft(self, user, disposeMatch=True):
 		"""
 		Remove someone from users in match
 
-		:param userID: user if of the user
+		:param user: user object of the user
+		:param disposeMatch: if `True`, will try to dispose match if there are no users in the room
 		:return:
 		"""
 		# Make sure the user is in room
@@ -415,10 +509,10 @@ class match:
 		self.setSlot(slotID, slotStatuses.FREE, 0, None, 0)
 
 		# Check if everyone left
-		if self.countUsers() == 0:
+		if self.countUsers() == 0 and disposeMatch and not self.isTourney:
 			# Dispose match
 			glob.matches.disposeMatch(self.matchID)
-			log.info("MPROOM{}: Room disposed".format(self.matchID))
+			log.info("MPROOM{}: Room disposed because all users left".format(self.matchID))
 			return
 
 		# Check if host left
@@ -443,14 +537,18 @@ class match:
 		:param newSlotID: slot id of new slot
 		:return:
 		"""
+		# Make sure the match is not locked
+		if self.isLocked or self.isStarting:
+			return False
+
 		# Make sure the user is in room
 		oldSlotID = self.getUserSlotID(userID)
 		if oldSlotID is None:
-			return
+			return False
 
 		# Make sure there is no one inside new slot
-		if self.slots[newSlotID].user is not None and self.slots[newSlotID].status != slotStatuses.FREE:
-			return
+		if self.slots[newSlotID].user is not None or self.slots[newSlotID].status != slotStatuses.FREE:
+			return False
 
 		# Get old slot data
 		#oldData = dill.copy(self.slots[oldSlotID])
@@ -467,6 +565,7 @@ class match:
 
 		# Console output
 		log.info("MPROOM{}: {} moved to slot {}".format(self.matchID, userID, newSlotID))
+		return True
 
 	def changePassword(self, newPassword):
 		"""
@@ -532,7 +631,7 @@ class match:
 		self.setHost(glob.tokens.tokens[self.slots[slotID].user].userID)
 
 		# Send updates
-		self.sendUpdates()
+		# self.sendUpdates()
 
 	def playerFailed(self, userID):
 		"""
@@ -546,6 +645,8 @@ class match:
 		if slotID is None:
 			return
 
+		self.slots[slotID].passed = False
+
 		# Send packet to everyone
 		glob.streams.broadcast(self.playingStreamName, serverPackets.playerFailed(slotID))
 
@@ -568,7 +669,7 @@ class match:
 
 		# FokaBot is too busy
 		if to == 999:
-			chat.sendMessage("FokaBot", froToken.username, "I would love to join your match, but I'm busy keeping ripple up and running. Sorry. Beep Boop.")
+			chat.sendMessage(glob.BOT_NAME, froToken.username, "I would love to join your match, but I'm busy keeping ripple up and running. Sorry. Beep Boop.")
 
 		# Send message
 		message = "Come join my multiplayer match: \"[osump://{}/{} {}]\"".format(self.matchID, self.matchPassword.replace(" ", "_"), self.matchName)
@@ -586,19 +687,28 @@ class match:
 				c+=1
 		return c
 
-	def changeTeam(self, userID):
+	def changeTeam(self, userID, newTeam=None):
 		"""
 		Change userID's team
 
 		:param userID: id of user
 		:return:
 		"""
+		# Make sure this match's mode has teams
+		if self.matchTeamType != matchTeamTypes.TEAM_VS and self.matchTeamType != matchTeamTypes.TAG_TEAM_VS:
+			return
+
+		# Make sure the match is not locked
+		if self.isLocked or self.isStarting:
+			return
+
 		# Make sure the user is in room
 		slotID = self.getUserSlotID(userID)
 		if slotID is None:
 			return
 
 		# Update slot and send update
+		if newTeam is None:
 			newTeam = matchTeams.BLUE if self.slots[slotID].team == matchTeams.RED else matchTeams.RED
 		self.setSlot(slotID, None, newTeam)
 		self.sendUpdates()
@@ -610,9 +720,11 @@ class match:
 		:return:
 		"""
 		self.matchDataCache = serverPackets.updateMatch(self.matchID)
+		censoredDataCache = serverPackets.updateMatch(self.matchID, censored=True)
 		if self.matchDataCache is not None:
 			glob.streams.broadcast(self.streamName, self.matchDataCache)
-			glob.streams.broadcast("lobby", self.matchDataCache)
+		if censoredDataCache is not None:
+			glob.streams.broadcast("lobby", censoredDataCache)
 		else:
 			log.error("MPROOM{}: Can't send match update packet, match data is None!!!".format(self.matchID))
 
@@ -623,7 +735,7 @@ class match:
 		:return: True if valid, False if invalid
 		:return:
 		"""
-		if self.matchTeamType != matchTeamTypes.TEAM_VS or self.matchTeamType != matchTeamTypes.TAG_TEAM_VS:
+		if self.matchTeamType != matchTeamTypes.TEAM_VS and self.matchTeamType != matchTeamTypes.TAG_TEAM_VS:
 			# Teams are always valid if we have no teams
 			return True
 
@@ -646,20 +758,23 @@ class match:
 
 		:return:
 		"""
+		# Remove isStarting timer flag thingie
+		self.isStarting = False
+
 		# Make sure we have enough players
 		if self.countUsers() < 2 or not self.checkTeams():
-			return
+			return False
 
 		# Create playing channel
 		glob.streams.add(self.playingStreamName)
 
 		# Change inProgress value
-		match.inProgress = True
+		self.inProgress = True
 
 		# Set playing to ready players and set load, skip and complete to False
 		# Make clients join playing stream
 		for i in range(0, 16):
-			if (self.slots[i].status & slotStatuses.READY) > 0 and self.slots[i].user in glob.tokens.tokens:
+			if self.slots[i].user in glob.tokens.tokens:
 				self.slots[i].status = slotStatuses.PLAYING
 				self.slots[i].loaded = False
 				self.slots[i].skip = False
@@ -671,3 +786,85 @@ class match:
 
 		# Send updates
 		self.sendUpdates()
+		return True
+
+	def forceSize(self, matchSize):
+		for i in range(0, matchSize):
+			if self.slots[i].status == slotStatuses.LOCKED:
+				self.toggleSlotLocked(i)
+		for i in range(matchSize, 16):
+			if self.slots[i].status != slotStatuses.LOCKED:
+				self.toggleSlotLocked(i)
+
+	def abort(self):
+		if not self.inProgress:
+			log.warning("MPROOM{}: Match is not in progress!".format(self.matchID))
+			return
+		self.inProgress = False
+		self.isStarting = False
+		self.resetSlots()
+		self.sendUpdates()
+		glob.streams.broadcast(self.playingStreamName, serverPackets.matchAbort())
+		glob.streams.dispose(self.playingStreamName)
+		glob.streams.remove(self.playingStreamName)
+		log.info("MPROOM{}: Match aborted".format(self.matchID))
+
+	def initializeTeams(self):
+		if self.matchTeamType == matchTeamTypes.TEAM_VS or self.matchTeamType == matchTeamTypes.TAG_TEAM_VS:
+			# Set teams
+			for i, _slot in enumerate(self.slots):
+				_slot.team = matchTeams.RED if i % 2 == 0 else matchTeams.BLUE
+		else:
+			# Reset teams
+			for _slot in self.slots:
+				_slot.team = matchTeams.NO_TEAM
+
+	def resetMods(self):
+		for _slot in self.slots:
+			_slot.mods = 0
+
+	def resetReady(self):
+		for _slot in self.slots:
+			if _slot.status == slotStatuses.READY:
+				_slot.status = slotStatuses.NOT_READY
+
+	def sendReadyStatus(self):
+		chanName = "#multi_{}".format(self.matchID)
+
+		# Make sure match exists before attempting to do anything else
+		if chanName not in glob.channels.channels:
+			return
+
+		totalUsers = 0
+		readyUsers = 0
+
+		for slot in self.slots:
+			# Make sure there is a user in this slot
+			if slot.user is None:
+				continue
+
+			# In this slot there is a user, so we increase the amount of total users
+			# in this multi room.
+			totalUsers += 1
+
+			if slot.status == slotStatuses.READY:
+				readyUsers += 1
+
+		message = "{} users ready out of {}.".format(readyUsers, totalUsers)
+
+		if totalUsers == readyUsers:
+			message += " All users ready!"
+
+		# Check whether there is anyone left in this match.
+		if totalUsers == 0:
+			message = "The match is now empty."
+
+		chat.sendMessage(glob.BOT_NAME, chanName, message)
+
+	def __enter__(self):
+		# 🌚🌚🌚🌚🌚
+		self._lock.acquire()
+		return self
+
+	def __exit__(self, exc_type, exc_val, exc_tb):
+		self._lock.release()

objects/matchList.py

@@ -1,3 +1,6 @@
+import threading
+import time
+
 from objects import match
 from objects import glob
 from constants import serverPackets
@@ -9,7 +12,7 @@ class matchList:
 		self.matches = {}
 		self.lastID = 1
 
-	def createMatch(self, matchName, matchPassword, beatmapID, beatmapName, beatmapMD5, gameMode, hostUserID):
+	def createMatch(self, matchName, matchPassword, beatmapID, beatmapName, beatmapMD5, gameMode, hostUserID, isTourney=False):
 		"""
 		Add a new match to matches list
 
@@ -25,7 +28,7 @@ class matchList:
 		# Add a new match to matches list and create its stream
 		matchID = self.lastID
 		self.lastID+=1
-		self.matches[matchID] = match.match(matchID, matchName, matchPassword, beatmapID, beatmapName, beatmapMD5, gameMode, hostUserID)
+		self.matches[matchID] = match.match(matchID, matchName, matchPassword, beatmapID, beatmapName, beatmapMD5, gameMode, hostUserID, isTourney)
 		return matchID
 
 	def disposeMatch(self, matchID):
@@ -39,10 +42,55 @@ class matchList:
 		if matchID not in self.matches:
 			return
 
-		# Remove match object and stream
-		match = self.matches.pop(matchID)
-		glob.streams.remove(match.streamName)
-		glob.streams.remove(match.playingStreamName)
+		# Get match and disconnect all players
+		_match = self.matches[matchID]
+		for slot in _match.slots:
+			_token = glob.tokens.getTokenFromUserID(slot.userID, ignoreIRC=True)
+			if _token is None:
+				continue
+			_match.userLeft(_token, disposeMatch=False)	# don't dispose the match twice when we remove all players
+
+		# Delete chat channel
+		glob.channels.removeChannel("#multi_{}".format(_match.matchID))
+
+		# Send matchDisposed packet before disposing streams
+		glob.streams.broadcast(_match.streamName, serverPackets.disposeMatch(_match.matchID))
+
+		# Dispose all streams
+		glob.streams.dispose(_match.streamName)
+		glob.streams.dispose(_match.playingStreamName)
+		glob.streams.remove(_match.streamName)
+		glob.streams.remove(_match.playingStreamName)
 
 		# Send match dispose packet to everyone in lobby
 		glob.streams.broadcast("lobby", serverPackets.disposeMatch(matchID))
+		del self.matches[matchID]
+		log.info("MPROOM{}: Room disposed manually".format(_match.matchID))
+
+	def cleanupLoop(self):
+		"""
+		Start match cleanup loop.
+		Empty matches that have been created more than 60 seconds ago will get deleted.
+		Useful when people create useless lobbies with `!mp make`.
+		The check is done every 30 seconds.
+		This method starts an infinite loop, call it only once!
+		:return:
+		"""
+		log.debug("Checking empty matches")
+		t = int(time.time())
+		emptyMatches = []
+
+		# Collect all empty matches
+		for key, m in self.matches.items():
+			if [x for x in m.slots if x.user is not None]:
+				continue
+			if t - m.createTime >= 120:
+				log.debug("Match #{} marked for cleanup".format(m.matchID))
+				emptyMatches.append(m.matchID)
+
+		# Dispose all empty matches
+		for matchID in emptyMatches:
+			self.disposeMatch(matchID)
+
+		# Schedule a new check (endless loop)
+		threading.Timer(30, self.cleanupLoop).start()

objects/osuToken.py

@@ -5,6 +5,7 @@ import uuid
 from common.constants import gameModes, actions
 from common.log import logUtils as log
 from common.ripple import userUtils
+from constants import exceptions
 from constants import serverPackets
 from events import logoutEvent
 from helpers import chatHelper as chat
@@ -29,16 +30,18 @@ class token:
 		self.username = userUtils.getUsername(self.userID)
 		self.safeUsername = userUtils.getSafeUsername(self.userID)
 		self.privileges = userUtils.getPrivileges(self.userID)
-		self.admin = userUtils.isInPrivilegeGroup(self.userID, "developer") or userUtils.isInPrivilegeGroup(self.userID, "community manager")
+		self.admin = userUtils.isInPrivilegeGroup(self.userID, "developer")\
+					 or userUtils.isInPrivilegeGroup(self.userID, "community manager")\
+					 or userUtils.isInPrivilegeGroup(self.userID, "chat mod")
 		self.irc = irc
 		self.kicked = False
 		self.restricted = userUtils.isRestricted(self.userID)
 		self.loginTime = int(time.time())
 		self.pingTime = self.loginTime
 		self.timeOffset = timeOffset
-		self.lock = threading.Lock()	# Sync primitive
 		self.streams = []
 		self.tournament = tournament
+		self.messagesBuffer = []
 
 		# Default variables
 		self.spectators = []
@@ -82,6 +85,11 @@ class token:
 		else:
 			self.token = str(uuid.uuid4())
 
+		# Locks
+		self.processingLock = threading.Lock()	# Acquired while there's an incoming packet from this user
+		self._bufferLock = threading.Lock()		# Acquired while writing to packets buffer
+		self._spectLock = threading.RLock()
+
 		# Set stats
 		self.updateCachedStats()
 
@@ -96,41 +104,64 @@ class token:
 		"""
 		Add bytes (packets) to queue
 
-		:param bytes: (packet) bytes to enqueue
+		:param bytes_: (packet) bytes to enqueue
 		"""
-		# TODO: reduce max queue size
+		try:
+			# Acquire the buffer lock
+			self._bufferLock.acquire()
+
+			# Never enqueue for IRC clients or Foka
+			if self.irc or self.userID < 999:
+				return
+
+			# Avoid memory leaks
 			if len(bytes_) < 10 * 10 ** 6:
 				self.queue += bytes_
 			else:
 				log.warning("{}'s packets buffer is above 10M!! Lost some data!".format(self.username))
+		finally:
+			# Release the buffer lock
+			self._bufferLock.release()
 
 	def resetQueue(self):
 		"""Resets the queue. Call when enqueued packets have been sent"""
+		try:
+			self._bufferLock.acquire()
 			self.queue = bytes()
+		finally:
+			self._bufferLock.release()
 
-	def joinChannel(self, channel):
+	def joinChannel(self, channelObject):
 		"""
-		Add channel to joined channels list
+		Join a channel
 
-		:param channel: channel name
+		:param channelObject: channel object
+		:raises: exceptions.userAlreadyInChannelException()
+				 exceptions.channelNoPermissionsException()
 		"""
-		if channel not in self.joinedChannels:
-			self.joinedChannels.append(channel)
+		if channelObject.name in self.joinedChannels:
+			raise exceptions.userAlreadyInChannelException()
+		if channelObject.publicRead == False and self.admin == False:
+			raise exceptions.channelNoPermissionsException()
+		self.joinedChannels.append(channelObject.name)
+		self.joinStream("chat/{}".format(channelObject.name))
+		self.enqueue(serverPackets.channelJoinSuccess(self.userID, channelObject.clientName))
 
-	def partChannel(self, channel):
+	def partChannel(self, channelObject):
 		"""
 		Remove channel from joined channels list
 
-		:param channel: channel name
+		:param channelObject: channel object
 		"""
-		if channel in self.joinedChannels:
-			self.joinedChannels.remove(channel)
+		self.joinedChannels.remove(channelObject.name)
+		self.leaveStream("chat/{}".format(channelObject.name))
 
 	def setLocation(self, latitude, longitude):
 		"""
 		Set client location
 
-		:param location: [latitude, longitude]
+		:param latitude: latitude
+		:param longitude: longitude
 		"""
 		self.location = (latitude, longitude)
 
@@ -157,6 +188,9 @@ class token:
 
 		:param host: host osuToken object
 		"""
+		try:
+			self._spectLock.acquire()
+
 			# Stop spectating old client
 			self.stopSpectating()
 
@@ -193,6 +227,8 @@ class token:
 
 			# Log
 			log.info("{} is spectating {}".format(self.username, host.username))
+		finally:
+			self._spectLock.release()
 
 	def stopSpectating(self):
 		"""
@@ -201,8 +237,11 @@ class token:
 
 		:return:
 		"""
+		try:
+			self._spectLock.acquire()
+
 			# Remove our userID from host's spectators
-		if self.spectating is None:
+			if self.spectating is None or self.spectatingUserID <= 0:
 				return
 			if self.spectating in glob.tokens.tokens:
 				hostToken = glob.tokens.tokens[self.spectating]
@@ -229,15 +268,17 @@ class token:
 					chat.partChannel(token=hostToken, channel="#spect_{}".format(hostToken.userID), kick=True)
 					hostToken.leaveStream(streamName)
 
+				# Console output
+				log.info("{} is no longer spectating {}. Current spectators: {}".format(self.username, self.spectatingUserID, hostToken.spectators))
+
 			# Part #spectator channel
 			chat.partChannel(token=self, channel="#spect_{}".format(self.spectatingUserID), kick=True)
 
-		# Console output
-		log.info("{} is no longer spectating {}".format(self.username, self.spectatingUserID))
-
 			# Set our spectating user to 0
 			self.spectating = None
 			self.spectatingUserID = 0
+		finally:
+			self._spectLock.release()
 
 	def updatePingTime(self):
 		"""
@@ -280,6 +321,13 @@ class token:
 		chat.joinChannel(token=self, channel="#multi_{}".format(self.matchID))
 		self.enqueue(serverPackets.matchJoinSuccess(matchID))
 
+		if match.isTourney:
+			# Alert the user if we have just joined a tourney match
+			self.enqueue(serverPackets.notification("You are now in a tournament match."))
+			# If an user joins, then the ready status of the match changes and
+			# maybe not all users are ready.
+			match.sendReadyStatus()
+
 	def leaveMatch(self):
 		"""
 		Leave joined match, match stream and match channel
@@ -295,18 +343,24 @@ class token:
 		self.leaveStream("multi/{}".format(self.matchID))
 		self.leaveStream("multi/{}/playing".format(self.matchID))	# optional
 
+		# Set usertoken match to -1
+		leavingMatchID = self.matchID
+		self.matchID = -1
+
 		# Make sure the match exists
-		if self.matchID not in glob.matches.matches:
+		if leavingMatchID not in glob.matches.matches:
 			return
 
 		# The match exists, get object
-		match = glob.matches.matches[self.matchID]
+		match = glob.matches.matches[leavingMatchID]
 
 		# Set slot to free
 		match.userLeft(self)
 
-		# Set usertoken match to -1
-		self.matchID = -1
+		if match.isTourney:
+			# If an user leaves, then the ready status of the match changes and
+			# maybe all users are ready. Or maybe nobody is in the match anymore
+			match.sendReadyStatus()
 
 	def kick(self, message="You have been kicked from the server. Please login again.", reason="kick"):
 		"""
@@ -324,7 +378,7 @@ class token:
 		self.enqueue(serverPackets.loginFailed())
 
 		# Logout event
-		logoutEvent.handle(self, deleteToken=False)
+		logoutEvent.handle(self, deleteToken=self.irc)
 
 	def silence(self, seconds = None, reason = "", author = 999):
 		"""
@@ -433,7 +487,7 @@ class token:
 		:return:
 		"""
 		self.restricted = True
-		chat.sendMessage("FokaBot", self.username, "Your account is currently in restricted mode. Please visit ripple's website for more information.")
+		chat.sendMessage(glob.BOT_NAME, self.username, "Your account is currently in restricted mode. Please visit ripple's website for more information.")
 
 	def resetRestricted(self):
 		"""
@@ -442,7 +496,7 @@ class token:
 
 		:return:
 		"""
-		chat.sendMessage("FokaBot", self.username, "Your account has been unrestricted! Please log in again.")
+		chat.sendMessage(glob.BOT_NAME, self.username, "Your account has been unrestricted! Please log in again.")
 
 	def joinStream(self, name):
 		"""
@@ -487,3 +541,24 @@ class token:
 			return False
 		self.sentAway.append(userID)
 		return True
+
+	def addMessageInBuffer(self, chan, message):
+		"""
+		Add a message in messages buffer (10 messages, truncated at 50 chars).
+		Used as proof when the user gets reported.
+
+		:param chan: channel
+		:param message: message content
+		:return:
+		"""
+		if len(self.messagesBuffer) > 9:
+			self.messagesBuffer = self.messagesBuffer[1:]
+		self.messagesBuffer.append("{time} - {user}@{channel}: {message}".format(time=time.strftime("%H:%M", time.localtime()), user=self.username, channel=chan, message=message[:50]))
+
+	def getMessagesBufferString(self):
+		"""
+		Get the content of the messages buffer as a string
+
+		:return: messages buffer content as a string
+		"""
+		return "\n".join(x for x in self.messagesBuffer)

objects/stream.py

@@ -43,15 +43,29 @@ class stream:
 			log.info("{} has left stream {}".format(token, self.name))
 			self.clients.remove(token)
 
-	def broadcast(self, data):
+	def broadcast(self, data, but=None):
 		"""
-		Send some data to all clients connected to this stream
+		Send some data to all (or some) clients connected to this stream
 
 		:param data: data to send
+		:param but: array of tokens to ignore. Default: None (send to everyone)
+		:return:
+		"""
+		if but is None:
+			but = []
+		for i in self.clients:
+			if i in glob.tokens.tokens:
+				if i not in but:
+					glob.tokens.tokens[i].enqueue(data)
+			else:
+				self.removeClient(token=i)
+
+	def dispose(self):
+		"""
+		Tell every client in this stream to leave the stream
+
 		:return:
 		"""
 		for i in self.clients:
 			if i in glob.tokens.tokens:
-				glob.tokens.tokens[i].enqueue(data)
-			else:
-				self.removeClient(token=i)
+				glob.tokens.tokens[i].leaveStream(self.name)

objects/streamList.py

@@ -1,6 +1,7 @@
 from objects import stream
 from objects import glob
 
+# TODO: use *args and **kwargs
 class streamList:
 	def __init__(self):
 		self.streams = {}
@@ -55,25 +56,39 @@ class streamList:
 			return
 		self.streams[streamName].removeClient(client=client, token=token)
 
-	def broadcast(self, streamName, data):
+	def broadcast(self, streamName, data, but=None):
 		"""
 		Send some data to all clients in a stream
 
 		:param streamName: stream name
 		:param data: data to send
+		:param but: array of tokens to ignore. Default: None (send to everyone)
 		:return:
 		"""
 		if streamName not in self.streams:
 			return
-		self.streams[streamName].broadcast(data)
+		self.streams[streamName].broadcast(data, but)
 
-	'''def getClients(self, streamName):
+	def dispose(self, streamName, *args, **kwargs):
 		"""
-		Get all clients in a stream
+		Call `dispose` on `streamName`
 
 		:param streamName: name of the stream
+		:param args:
+		:param kwargs:
 		:return:
 		"""
 		if streamName not in self.streams:
 			return
-		return self.streams[streamName].clients'''
+		self.streams[streamName].dispose(*args, **kwargs)
+
+	def getStream(self, streamName):
+		"""
+		Returns streamName's stream object or None if it doesn't exist
+
+		:param streamName:
+		:return:
+		"""
+		if streamName in self.streams:
+			return self.streams[streamName]
+		return None

objects/tokenList.py

@@ -1,6 +1,8 @@
 import threading
 import time
 
+import redis
+
 from common.ripple import userUtils
 from common.log import logUtils as log
 from constants import serverPackets
@@ -11,12 +13,20 @@ from objects import osuToken
 class tokenList:
 	def __init__(self):
 		self.tokens = {}
+		self._lock = threading.Lock()
+
+	def __enter__(self):
+		self._lock.acquire()
+
+	def __exit__(self, exc_type, exc_val, exc_tb):
+		self._lock.release()
 
 	def addToken(self, userID, ip = "", irc = False, timeOffset=0, tournament=False):
 		"""
 		Add a token object to tokens list
 
 		:param userID: user id associated to that token
+		:param ip: ip address of the client
 		:param irc: if True, set this token as IRC client
 		:param timeOffset: the time offset from UTC for this user. Default: 0.
 		:param tournament: if True, flag this client as a tournement client. Default: True.
@@ -37,7 +47,8 @@ class tokenList:
 		if token in self.tokens:
 			if self.tokens[token].ip != "":
 				userUtils.deleteBanchoSessions(self.tokens[token].userID, self.tokens[token].ip)
-			self.tokens.pop(token)
+			t = self.tokens.pop(token)
+			del t
 			glob.redis.decr("ripple:online_users")
 
 	def getUserIDFromToken(self, token):
@@ -54,25 +65,34 @@ class tokenList:
 		# Get userID associated to that token
 		return self.tokens[token].userID
 
-	def getTokenFromUserID(self, userID, ignoreIRC=False):
+	def getTokenFromUserID(self, userID, ignoreIRC=False, _all=False):
 		"""
 		Get token from a user ID
 
 		:param userID: user ID to find
 		:param ignoreIRC: if True, consider bancho clients only and skip IRC clients
+		:param _all: if True, return a list with all clients that match given username, otherwise return
+					only the first occurrence.
 		:return: False if not found, token object if found
 		"""
 		# Make sure the token exists
+		ret = []
 		for _, value in self.tokens.items():
 			if value.userID == userID:
 				if ignoreIRC and value.irc:
 					continue
+				if _all:
+					ret.append(value)
+				else:
 					return value
 
-		# Return none if not found
+		# Return full list or None if not found
+		if _all:
+			return ret
+		else:
 			return None
 
-	def getTokenFromUsername(self, username, ignoreIRC=False, safe=False):
+	def getTokenFromUsername(self, username, ignoreIRC=False, safe=False, _all=False):
 		"""
 		Get an osuToken object from an username
 
@@ -80,19 +100,28 @@ class tokenList:
 		:param ignoreIRC: if True, consider bancho clients only and skip IRC clients
 		:param safe: 	if True, username is a safe username,
 						compare it with token's safe username rather than normal username
+		:param _all: if True, return a list with all clients that match given username, otherwise return
+					only the first occurrence.
 		:return: osuToken object or None
 		"""
 		# lowercase
 		who = username.lower() if not safe else username
 
 		# Make sure the token exists
+		ret = []
 		for _, value in self.tokens.items():
 			if (not safe and value.username.lower() == who) or (safe and value.safeUsername == who):
 				if ignoreIRC and value.irc:
 					continue
+				if _all:
+					ret.append(value)
+				else:
 					return value
 
-		# Return none if not found
+		# Return full list or None if not found
+		if _all:
+			return ret
+		else:
 			return None
 
 	def deleteOldTokens(self, userID):
@@ -142,19 +171,16 @@ class tokenList:
 		for _, value in self.tokens.items():
 			value.enqueue(packet)
 
-	def usersTimeoutCheckLoop(self, timeoutTime = 100, checkTime = 100):
+	def usersTimeoutCheckLoop(self):
 		"""
 		Start timed out users disconnect loop.
 		This function will be called every `checkTime` seconds and so on, forever.
 		CALL THIS FUNCTION ONLY ONCE!
-
-		:param timeoutTime: seconds of inactivity required to disconnect someone. Default: 100
-		:param checkTime: seconds between loops. Default: 100
 		:return:
 		"""
 		log.debug("Checking timed out clients")
 		timedOutTokens = []		# timed out users
-		timeoutLimit = int(time.time())-timeoutTime
+		timeoutLimit = int(time.time()) - 100
 		for key, value in self.tokens.items():
 			# Check timeout (fokabot is ignored)
 			if value.pingTime < timeoutLimit and value.userID != 999 and value.irc == False and value.tournament == False:
@@ -168,9 +194,10 @@ class tokenList:
 			log.debug("{} timed out!!".format(self.tokens[i].username))
 			self.tokens[i].enqueue(serverPackets.notification("Your connection to the server timed out."))
 			logoutEvent.handle(self.tokens[i], None)
+		del timedOutTokens
 
 		# Schedule a new check (endless loop)
-		threading.Timer(checkTime, self.usersTimeoutCheckLoop, [timeoutTime, checkTime]).start()
+		threading.Timer(100, self.usersTimeoutCheckLoop).start()
 
 	def spamProtectionResetLoop(self):
 		"""
@@ -197,7 +224,7 @@ class tokenList:
 		try:
 			# TODO: Make function or some redis meme
 			glob.redis.eval("return redis.call('del', unpack(redis.call('keys', ARGV[1])))", 0, "peppy:sessions:*")
-		except:
+		except redis.RedisError:
 			pass
 
 

pep.py

@@ -1,9 +1,8 @@
-"""Hello, pep.py here, ex-owner of ripple and prime minister of Ripwot."""
 import os
 import sys
 import threading
+import json
 from multiprocessing.pool import ThreadPool
-
 import tornado.gen
 import tornado.httpserver
 import tornado.ioloop
@@ -38,10 +37,10 @@ from pubSubHandlers import changeUsernameHandler
 
 from pubSubHandlers import disconnectHandler
 from pubSubHandlers import banHandler
+from pubSubHandlers import notificationHandler
 from pubSubHandlers import updateSilenceHandler
 from pubSubHandlers import updateStatsHandler
 
-
 def make_app():
 	return tornado.web.Application([
 		(r"/", mainHandler.handler),
@@ -63,6 +62,11 @@ if __name__ == "__main__":
 		consoleHelper.printNoNl("> Loading config file... ")
 		glob.conf = configHelper.config("config.ini")
 
+		# Read additional config file
+		consoleHelper.printNoNl("> Loading additional config file... ")
+		with open("config.json", "r") as f:
+			glob.conf.extra = json.load(f)
+
 		if glob.conf.default:
 			# We have generated a default config.ini, quit server
 			consoleHelper.printWarning()
@@ -144,7 +148,7 @@ if __name__ == "__main__":
 			consoleHelper.printNoNl("> Creating threads pool... ")
 			glob.pool = ThreadPool(int(glob.conf.config["server"]["threads"]))
 			consoleHelper.printDone()
-		except:
+		except ValueError:
 			consoleHelper.printError()
 			consoleHelper.printColored("[!] Error while creating threads pool. Please check your config.ini and run the server again", bcolors.RED)
 
@@ -157,6 +161,11 @@ if __name__ == "__main__":
 			consoleHelper.printColored("[!] Error while loading chat filters. Make sure there is a filters.txt file present", bcolors.RED)
 			raise
 
+		# Start fokabot
+		consoleHelper.printNoNl("> Connecting bot... ")
+		fokabot.connect()
+		consoleHelper.printDone()
+
 		# Initialize chat channels
 		print("> Initializing chat channels... ")
 		glob.channels.loadChannels()
@@ -168,11 +177,6 @@ if __name__ == "__main__":
 		glob.streams.add("lobby")
 		consoleHelper.printDone()
 
-		# Start fokabot
-		consoleHelper.printNoNl("> Connecting FokaBot... ")
-		fokabot.connect()
-		consoleHelper.printDone()
-
 		# Initialize user timeout check loop
 		consoleHelper.printNoNl("> Initializing user timeout check loop... ")
 		glob.tokens.usersTimeoutCheckLoop()
@@ -183,6 +187,11 @@ if __name__ == "__main__":
 		glob.tokens.spamProtectionResetLoop()
 		consoleHelper.printDone()
 
+		# Initialize multiplayer cleanup loop
+		consoleHelper.printNoNl("> Initializing multiplayer cleanup loop... ")
+		glob.matches.cleanupLoop()
+		consoleHelper.printDone()
+
 		# Localize warning
 		glob.localize = generalUtils.stringToBool(glob.conf.config["localize"]["enable"])
 		if not glob.localize:
@@ -190,7 +199,7 @@ if __name__ == "__main__":
 
 		# Discord
 		if generalUtils.stringToBool(glob.conf.config["discord"]["enable"]):
-			glob.schiavo = schiavo.schiavo(glob.conf.config["discord"]["boturl"])
+			glob.schiavo = schiavo.schiavo(glob.conf.config["discord"]["boturl"], "**pep.py**")
 		else:
 			consoleHelper.printColored("[!] Warning! Discord logging is disabled!", bcolors.YELLOW)
 
@@ -214,7 +223,7 @@ if __name__ == "__main__":
 		try:
 			glob.sentry = generalUtils.stringToBool(glob.conf.config["sentry"]["enable"])
 			if glob.sentry:
-				glob.application.sentry_client = AsyncSentryClient(glob.conf.config["sentry"]["banchodns"], release=glob.VERSION)
+				glob.application.sentry_client = AsyncSentryClient(glob.conf.config["sentry"]["banchodsn"], release=glob.VERSION)
 			else:
 				consoleHelper.printColored("[!] Warning! Sentry logging is disabled!", bcolors.YELLOW)
 		except:
@@ -250,24 +259,26 @@ if __name__ == "__main__":
 		glob.irc = generalUtils.stringToBool(glob.conf.config["irc"]["enable"])
 		if glob.irc:
 			# IRC port
+			ircPort = 0
 			try:
 				ircPort = int(glob.conf.config["irc"]["port"])
-			except:
+			except ValueError:
 				consoleHelper.printColored("[!] Invalid IRC port! Please check your config.ini and run the server again", bcolors.RED)
-			log.logMessage("**pep.py** IRC server started!", discord="bunker", of="info.txt", stdout=False)
+			log.logMessage("IRC server started!", discord="bunker", of="info.txt", stdout=False)
 			consoleHelper.printColored("> IRC server listening on 127.0.0.1:{}...".format(ircPort), bcolors.GREEN)
 			threading.Thread(target=lambda: ircserver.main(port=ircPort)).start()
 		else:
 			consoleHelper.printColored("[!] Warning! IRC server is disabled!", bcolors.YELLOW)
 
 		# Server port
+		serverPort = 0
 		try:
 			serverPort = int(glob.conf.config["server"]["port"])
-		except:
+		except ValueError:
 			consoleHelper.printColored("[!] Invalid server port! Please check your config.ini and run the server again", bcolors.RED)
 
 		# Server start message and console output
-		log.logMessage("**pep.py** Server started!", discord="bunker", of="info.txt", stdout=False)
+		log.logMessage("Server started!", discord="bunker", of="info.txt", stdout=False)
 		consoleHelper.printColored("> Tornado listening for HTTP(s) clients on 127.0.0.1:{}...".format(serverPort), bcolors.GREEN)
 
 		# Connect to pubsub channels
@@ -278,6 +289,7 @@ if __name__ == "__main__":
 			"peppy:update_cached_stats": updateStatsHandler.handler(),
 			"peppy:silence": updateSilenceHandler.handler(),
 			"peppy:ban": banHandler.handler(),
+			"peppy:notification": notificationHandler.handler(),
 		}).start()
 
 		# Start tornado

pubSubHandlers/changeUsernameHandler.py

@@ -6,6 +6,7 @@ from objects import glob
 
 def handleUsernameChange(userID, newUsername, targetToken=None):
 	try:
+		userUtils.appendNotes(userID, "Username change: '{}' -> '{}'".format(userUtils.getUsername(userID), newUsername))
 		userUtils.changeUsername(userID, newUsername=newUsername)
 		if targetToken is not None:
 			targetToken.kick("Your username has been changed to {}. Please log in again.".format(newUsername), "username_change")

pubSubHandlers/notificationHandler.py

@@ -0,0 +1,19 @@
+from common.redis import generalPubSubHandler
+from objects import glob
+from constants import serverPackets
+
+class handler(generalPubSubHandler.generalPubSubHandler):
+	def __init__(self):
+		super().__init__()
+		self.structure = {
+			"userID": 0,
+			"message": ""
+		}
+
+	def handle(self, data):
+		data = super().parseData(data)
+		if data is None:
+			return
+		targetToken = glob.tokens.getTokenFromUserID(data["userID"])
+		if targetToken is not None:
+			targetToken.enqueue(serverPackets.notification(data["message"]))

requirements.txt

@@ -1,9 +1,10 @@
-requests
-tornado
-mysqlclient
-psutil
-raven
-bcrypt>=3.1.1
-dill
-redis
-cython
+requests==2.18.1
+tornado==4.4.2
+mysqlclient==1.3.9
+psutil==5.2.2
+raven==5.32.0
+bcrypt==3.1.1
+dill==0.2.7.1
+redis==2.10.5
+cython==0.27.3
+datadog==0.14.0

version

@@ -1 +1 @@
-1.11.0
+1.13.3