def asyncGet(self):
try:
# Get request ip
ip = self.getRequestIP()
# Check arguments
if not requestsManager.checkArguments(self.request.arguments,
["c", "u", "h"]):
raise exceptions.invalidArgumentsException(MODULE_NAME)
# Get arguments
username = self.get_argument("u")
password = self.get_argument("h")
replayID = self.get_argument("c")
# Login check
userID = userUtils.getID(username)
if userID == 0:
raise exceptions.loginFailedException(MODULE_NAME, userID)
if not userUtils.checkLogin(userID, password, ip):
raise exceptions.loginFailedException(MODULE_NAME, username)
if userUtils.check2FA(userID, ip):
raise exceptions.need2FAException(MODULE_NAME, username, ip)
# Get user ID
replayData = glob.db.fetch(
"SELECT scores.*, users.username AS uname FROM scores LEFT JOIN users ON scores.userid = users.id WHERE scores.id = %s",
[replayID])
if replayData == None:
replayData = glob.db.fetch(
"SELECT scores_relax.*, users.username AS uname FROM scores_relax LEFT JOIN users ON scores_relax.userid = users.id WHERE scores_relax.id = %s",
[replayID])
fileName = "{}_relax/replay_{}.osr".format(
glob.conf.config["server"]["replayspath"], replayID)
else:
fileName = "{}/replay_{}.osr".format(
glob.conf.config["server"]["replayspath"], replayID)
# Increment 'replays watched by others' if needed
if replayData is not None:
if username != replayData["uname"]:
userUtils.incrementReplaysWatched(replayData["userid"],
replayData["play_mode"])
# Serve replay
log.info("Serving replay_{}.osr".format(replayID))
if os.path.isfile(fileName):
with open(fileName, "rb") as f:
fileContent = f.read()
self.write(fileContent)
else:
log.warning("Replay {} doesn't exist".format(replayID))
self.write("")
except exceptions.invalidArgumentsException:
pass
except exceptions.need2FAException:
pass
except exceptions.loginFailedException:
pass
def asyncGet(self):
try:
# Get request ip
ip = self.getRequestIP()
# Check arguments
if not requestsManager.checkArguments(self.request.arguments, ["c", "u", "h"]):
raise exceptions.invalidArgumentsException(MODULE_NAME)
# Get arguments
username = self.get_argument("u")
password = self.get_argument("h")
replayID = self.get_argument("c")
isRelaxing = False
if int(replayID) < 500000000:
isRelaxing = True
# Login check
userID = userUtils.getID(username)
if userID == 0:
raise exceptions.loginFailedException(MODULE_NAME, userID)
if not userUtils.checkLogin(userID, password, ip):
raise exceptions.loginFailedException(MODULE_NAME, username)
if userUtils.check2FA(userID, ip):
raise exceptions.need2FAException(MODULE_NAME, username, ip)
replayData = glob.db.fetch("SELECT scores{relax}.*, users.username AS uname FROM scores{relax} LEFT JOIN users ON scores{relax}.userid = users.id WHERE scores{relax}.id = %s".format(relax="_relax" if isRelaxing else ""), [replayID])
# Increment 'replays watched by others' if needed
if replayData is not None:
if username != replayData["uname"]:
userUtils.incrementReplaysWatched(replayData["userid"], replayData["play_mode"], replayData["mods"])
log.info("Serving replay_{}.osr".format(replayID))
fileName = ".data/replays/replay_{}.osr".format(replayID)
if os.path.isfile(fileName):
with open(fileName, "rb") as f:
fileContent = f.read()
self.write(fileContent)
else:
self.write("")
log.warning("Replay {} doesn't exist.".format(replayID))
except exceptions.invalidArgumentsException:
pass
except exceptions.need2FAException:
pass
except exceptions.loginFailedException:
pass
def asyncGet(self):
"""The actual handler."""
# Argument Verification.
if not requestsManager.checkArguments(self.request.arguments, ("u", "h", "c")):
return self.write("no")
# Set variables.
username = self.get_argument("u")
#p_hash = self.get_argument("h")
replay_id = int(self.get_argument("c"))
# Work out scores table from ID.
suffix = ""
# Relax replay
if RELAX_OFFSET < replay_id < AP_OFFSET: suffix = "_relax"
elif replay_id > AP_OFFSET: suffix = "_ap"
# Grab data on the gamer that did this.
play_db = glob.db.fetch(
BASE_QUERY.format(suffix),
(replay_id,)
)
if play_db: userUtils.incrementReplaysWatched(
play_db["userid"], play_db["play_mode"]
)
rp_path = REPLAY_PATH_BASE.format(suffix, replay_id)
if not os.path.exists(rp_path):
log.warning(f"Attempted to serve non-existant replay ({rp_path}) to {username}")
return self.write("no")
# We send them le replay.
log.info(f"Served {rp_path} to {username}.")
with open(rp_path, "rb") as f: return self.write(f.read())
def asyncGet(self):
try:
# insert ripple unfunny roblox word here. very unfunny
# Get request ip
ip = self.getRequestIP()
# Check arguments
if not requestsManager.checkArguments(self.request.arguments, ["c", "u", "h"]):
raise exceptions.invalidArgumentsException(MODULE_NAME)
# Get arguments
username = self.get_argument("u")
password = self.get_argument("h")
replayID = self.get_argument("c")
# Login check
userID = userUtils.getID(username)
if userID == 0:
raise exceptions.loginFailedException(MODULE_NAME, userID)
if not userUtils.checkLogin(userID, password, ip):
raise exceptions.loginFailedException(MODULE_NAME, username)
if userUtils.check2FA(userID, ip):
raise exceptions.need2FAException(MODULE_NAME, username, ip)
# Get user ID
replayMode = 'NM'
modeData = {
'NM': (modeSwitches.rp_folder[0], 'VANILLA', modeSwitches.score[0]),
'RL': (modeSwitches.rp_folder[1], 'RELAX', modeSwitches.score[1]),
'V2': (modeSwitches.rp_folder[2], 'SCOREv2', modeSwitches.score[2])
}
if features.MASTER_SCORE_TABLE:
replayData = glob.db.fetch("SELECT s.*, users.username AS uname FROM {} as s LEFT JOIN users ON s.userid = users.id WHERE s.id = %s".format('scores_master'), [replayID])
if replayData is not None:
replayMode = list(modeData.keys())[replayData['special_mode']]
else:
userStat = glob.db.fetch('select current_status as c from user_config where id = %s', [userID])
if userStat['c'].endswith('on V2'):
replayMode = 'V2'
elif userStat['c'].endswith('on Relax'):
replayMode = 'RL'
pass
else:
userStat = glob.db.fetch('select current_status as c from user_config where id = %s', [userID])
if userStat['c'].endswith('on V2'):
replayMode = 'V2'
elif userStat['c'].endswith('on Relax'):
replayMode = 'RL'
replayData = glob.db.fetch("SELECT s.*, users.username AS uname FROM {} as s LEFT JOIN users ON s.userid = users.id WHERE s.id = %s".format(modeData[replayMode][2]), [replayID])
if replayData is not None:
fileName = "{}{}/replay_{}.osr".format(glob.conf.config["server"]["replayspath"], modeData[replayMode][0], replayID)
Play = modeData[replayMode][1]
else:
log.warning("Replay {} ({}) doesn't exist".format(replayID, replayMode))
self.write("")
return
# Increment 'replays watched by others' if needed
if replayData is not None:
if username != replayData["uname"]:
userUtils.incrementReplaysWatched(replayData["userid"], replayData["play_mode"])
# Serve replay
log.info("[{}] Serving replay_{}.osr".format(Play, replayID))
if os.path.isfile(fileName):
with open(fileName, "rb") as f:
fileContent = f.read()
self.write(fileContent)
else:
log.warning("Replay {} doesn't exist".format(replayID))
self.write("")
except exceptions.invalidArgumentsException:
pass
except exceptions.need2FAException:
pass
except exceptions.loginFailedException:
pass
def asyncGet(self):
try:
# Get request ip
ip = self.getRequestIP()
# Check arguments
if not requestsManager.checkArguments(self.request.arguments,
["c", "u", "h"]):
raise exceptions.invalidArgumentsException(self.MODULE_NAME)
# Get arguments
username = self.get_argument("u")
password = self.get_argument("h")
replayID = self.get_argument("c")
# Login check
userID = userUtils.getID(username)
if userID == 0:
raise exceptions.loginFailedException(self.MODULE_NAME, userID)
if not userUtils.checkLogin(userID, password, ip):
raise exceptions.loginFailedException(self.MODULE_NAME,
username)
if userUtils.check2FA(userID, ip):
raise exceptions.need2FAException(self.MODULE_NAME, username,
ip)
# Get user ID
replayData = glob.db.fetch(
"SELECT scores.*, users.username AS uname FROM scores LEFT JOIN users ON scores.userid = users.id WHERE scores.id = %s",
[replayID])
# Increment 'replays watched by others' if needed
if replayData is not None:
if username != replayData["uname"]:
userUtils.incrementReplaysWatched(replayData["userid"],
replayData["play_mode"])
# Serve replay
log.info("Serving replay_{}.osr".format(replayID))
r = ""
replayID = int(replayID)
try:
r = replayHelper.getRawReplayS3(replayID)
except timeout_decorator.TimeoutError:
log.warning("S3 timed out")
sentry.captureMessage("S3 timeout while fetching replay.")
glob.stats["replay_download_failures"].labels(
type="raw_s3_timeout").inc()
except FileNotFoundError:
log.warning("Replay {} doesn't exist".format(replayID))
except:
glob.stats["replay_download_failures"].labels(
type="raw_other").inc()
raise
finally:
self.write(r)
except exceptions.invalidArgumentsException:
pass
except exceptions.need2FAException:
pass
except exceptions.loginFailedException:
pass
def asyncGet(self):
try:
# OOF
UsingRelax = False
UsingAuto = False
# Get request ip
ip = self.getRequestIP()
# Check arguments
if not requestsManager.checkArguments(self.request.arguments,
["c", "u", "h"]):
raise exceptions.invalidArgumentsException(MODULE_NAME)
# Get arguments
username = self.get_argument("u")
password = self.get_argument("h")
replayID = self.get_argument("c")
# Login check
userID = userUtils.getID(username)
if userID == 0:
raise exceptions.loginFailedException(MODULE_NAME, userID)
if not userUtils.checkLogin(userID, password, ip):
raise exceptions.loginFailedException(MODULE_NAME, username)
if userUtils.check2FA(userID, ip):
raise exceptions.need2FAException(MODULE_NAME, username, ip)
# Get user ID
current_gamemode_redis = "lets:user_current_gamemode:{}".format(
userID)
cgamemode = int(glob.redis.get(current_gamemode_redis))
replayData = glob.db.fetch(
"SELECT scores.*, users.username AS uname FROM scores LEFT JOIN users ON scores.userid = users.id WHERE scores.id = %s",
[replayID])
if cgamemode == 3:
log.debug("autopilot")
UsingRelax = False
usingAuto = True
fileName = "{}_ap/replay_{}.osr".format(
glob.conf.config["server"]["replayspath"], replayID)
if cgamemode == 2:
log.debug("relax")
fileName = "{}_relax/replay_{}.osr".format(
glob.conf.config["server"]["replayspath"], replayID)
UsingRelax = True
UsingAuto = False
if cgamemode == 1:
log.debug("std")
UsingRelax = False
UsingAuto = False
fileName = "{}/replay_{}.osr".format(
glob.conf.config["server"]["replayspath"], replayID)
# Increment 'replays watched by others' if needed
if replayData is not None:
if username != replayData["uname"]:
userUtils.incrementReplaysWatched(replayData["userid"],
replayData["play_mode"])
Play = "VANILLA"
if UsingRelax:
Play = "RELAX"
if UsingAuto:
Play = "AUTOPILOT"
# Serve replay
log.info("[{}] Serving replay_{}.osr".format(Play, replayID))
if os.path.isfile(fileName):
with open(fileName, "rb") as f:
fileContent = f.read()
self.write(fileContent)
else:
log.info("Replay {} doesn't exist".format(replayID))
self.write("")
except exceptions.invalidArgumentsException:
pass
except exceptions.need2FAException:
pass
except exceptions.loginFailedException:
pass
