219 lines
7.7 KiB
Python
219 lines
7.7 KiB
Python
import json
|
|
import os
|
|
import logging
|
|
import typing
|
|
import multiprocessing
|
|
import threading
|
|
import zlib
|
|
import collections
|
|
|
|
from pony.flask import Pony
|
|
from flask import Flask, request, redirect, url_for, render_template, Response, session, abort, flash
|
|
from flask_caching import Cache
|
|
from pony.orm import commit
|
|
|
|
from .models import *
|
|
|
|
UPLOAD_FOLDER = os.path.relpath('uploads')
|
|
LOGS_FOLDER = os.path.relpath('logs')
|
|
os.makedirs(LOGS_FOLDER, exist_ok=True)
|
|
|
|
|
|
def allowed_file(filename):
|
|
return filename.endswith('multidata')
|
|
|
|
app = Flask(__name__)
|
|
Pony(app)
|
|
|
|
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
|
|
app.config['MAX_CONTENT_LENGTH'] = 1 * 1024 * 1024 # 1 megabyte limit
|
|
# if you want persistent sessions on your server, make sure you make this a constant in your config.yaml
|
|
app.config["SECRET_KEY"] = os.urandom(32)
|
|
app.config['SESSION_PERMANENT'] = True
|
|
app.config["PONY"] = {
|
|
'provider': 'sqlite',
|
|
'filename': os.path.abspath('db.db3'),
|
|
'create_db': True
|
|
}
|
|
app.config["CACHE_TYPE"] = "simple"
|
|
|
|
cache = Cache(app)
|
|
|
|
multiworlds = {}
|
|
|
|
|
|
@app.before_request
|
|
def register_session():
|
|
session.permanent = True # technically 31 days after the last visit
|
|
if not session.get("_id", None):
|
|
session["_id"] = uuid4() # uniquely identify each session without needing a login
|
|
|
|
|
|
class MultiworldInstance():
|
|
def __init__(self, room: Room):
|
|
self.room_id = room.id
|
|
self.process: typing.Optional[multiprocessing.Process] = None
|
|
multiworlds[self.room_id] = self
|
|
|
|
def start(self):
|
|
if self.process and self.process.is_alive():
|
|
return False
|
|
|
|
logging.info(f"Spinning up {self.room_id}")
|
|
with db_session:
|
|
self.process = multiprocessing.Process(group=None, target=run_server_process,
|
|
args=(self.room_id, app.config["PONY"]),
|
|
name="MultiHost")
|
|
self.process.start()
|
|
|
|
def stop(self):
|
|
if self.process:
|
|
self.process.terminate()
|
|
self.process = None
|
|
|
|
|
|
@app.route('/seed/<int:seed>')
|
|
def view_seed(seed: int):
|
|
seed = Seed.get(id=seed)
|
|
if seed:
|
|
return render_template("view_seed.html", seed=seed)
|
|
else:
|
|
abort(404)
|
|
|
|
|
|
@app.route('/new_room/<int:seed>')
|
|
def new_room(seed: int):
|
|
seed = Seed.get(id=seed)
|
|
room = Room(seed=seed, owner=session["_id"])
|
|
commit()
|
|
return redirect(url_for("host_room", room=room.id))
|
|
|
|
|
|
def _read_log(path: str):
|
|
if os.path.exists(path):
|
|
with open(path) as log:
|
|
yield from log
|
|
else:
|
|
yield f"Logfile {path} does not exist. " \
|
|
f"Likely a crash during spinup of multiworld instance or it is still spinning up."
|
|
|
|
|
|
@app.route('/log/<int:room>')
|
|
def display_log(room: int):
|
|
# noinspection PyTypeChecker
|
|
return Response(_read_log(os.path.join("logs", str(room) + ".txt")), mimetype="text/plain;charset=UTF-8")
|
|
|
|
|
|
processstartlock = threading.Lock()
|
|
|
|
|
|
@app.route('/hosted/<int:room>', methods=['GET', 'POST'])
|
|
def host_room(room: int):
|
|
room = Room.get(id=room)
|
|
if request.method == "POST":
|
|
if room.owner == session["_id"]:
|
|
cmd = request.form["cmd"]
|
|
Command(room=room, commandtext=cmd)
|
|
commit()
|
|
with db_session:
|
|
multiworld = multiworlds.get(room.id, None)
|
|
if not multiworld:
|
|
multiworld = MultiworldInstance(room)
|
|
|
|
with processstartlock:
|
|
multiworld.start()
|
|
|
|
return render_template("host_room.html", room=room)
|
|
|
|
|
|
@app.route('/tracker/<int:room>')
|
|
@cache.memoize(timeout=60 * 5) # update every 5 minutes
|
|
def get_tracker(room: int):
|
|
# This more WIP than the rest
|
|
import Items
|
|
def get_id(item_name):
|
|
return Items.item_table[item_name][3]
|
|
|
|
room = Room.get(id=room)
|
|
if not room:
|
|
abort(404)
|
|
if room.allow_tracker:
|
|
multidata = room.seed.multidata
|
|
locations = {tuple(k): tuple(v) for k, v in multidata['locations']}
|
|
|
|
links = {"Bow": "Progressive Bow",
|
|
"Silver Arrows": "Progressive Bow",
|
|
"Bottle (Red Potion)": "Bottle",
|
|
"Bottle (Green Potion)": "Bottle",
|
|
"Bottle (Blue Potion)": "Bottle",
|
|
"Bottle (Fairy)": "Bottle",
|
|
"Bottle (Bee)": "Bottle",
|
|
"Bottle (Good Bee)": "Bottle",
|
|
"Fighter Sword": "Progressive Sword",
|
|
"Master Sword": "Progressive Sword",
|
|
"Tempered Sword": "Progressive Sword",
|
|
"Golden Sword": "Progressive Sword",
|
|
"Power Glove": "Progressive Glove",
|
|
"Titans Mitts": "Progressive Glove"
|
|
}
|
|
links = {get_id(key): get_id(value) for key, value in links.items()}
|
|
inventory = {teamnumber: {playernumber: collections.Counter() for playernumber in range(len(team))}
|
|
for teamnumber, team in enumerate(multidata["names"])}
|
|
for (team, player), locations_checked in room.multisave.get("location_checks", {}):
|
|
for location in locations_checked:
|
|
item, recipient = locations[location, player]
|
|
inventory[team][recipient][links.get(item, item)] += 1
|
|
|
|
from MultiServer import get_item_name_from_id
|
|
from Items import lookup_id_to_name
|
|
player_names = {}
|
|
for team, names in enumerate(multidata['names']):
|
|
for player, name in enumerate(names, 1):
|
|
player_names[(team, player)] = name
|
|
tracking_names = ["Progressive Sword", "Progressive Bow", "Progressive Bow (Alt)", "Book of Mudora", "Hammer",
|
|
"Hookshot", "Magic Mirror", "Flute",
|
|
"Pegasus Boots", "Progressive Glove", "Flippers", "Moon Pearl", "Blue Boomerang",
|
|
"Red Boomerang", "Bug Catching Net", "Cane of Byrna", "Cape", "Mushroom", "Shovel", "Lamp",
|
|
"Magic Powder",
|
|
"Cane of Somaria", "Fire Rod", "Ice Rod", "Bombos", "Ether", "Quake",
|
|
"Bottle", "Triforce"] # TODO make sure this list has what we need and sort it better
|
|
tracking_ids = []
|
|
|
|
for item in tracking_names:
|
|
tracking_ids.append(get_id(item))
|
|
|
|
return render_template("tracker.html", inventory=inventory, get_item_name_from_id=get_item_name_from_id,
|
|
lookup_id_to_name=lookup_id_to_name, player_names=player_names,
|
|
tracking_names=tracking_names, tracking_ids=tracking_ids)
|
|
else:
|
|
return "Tracker disabled for this room."
|
|
|
|
|
|
from WebHost.customserver import run_server_process
|
|
|
|
|
|
@app.route('/', methods=['GET', 'POST'])
|
|
def upload_multidata():
|
|
if request.method == 'POST':
|
|
# check if the post request has the file part
|
|
if 'file' not in request.files:
|
|
flash('No file part')
|
|
else:
|
|
file = request.files['file']
|
|
# if user does not select file, browser also
|
|
# submit an empty part without filename
|
|
if file.filename == '':
|
|
flash('No selected file')
|
|
elif file and allowed_file(file.filename):
|
|
try:
|
|
multidata = json.loads(zlib.decompress(file.read()).decode("utf-8-sig"))
|
|
except:
|
|
flash("Could not load multidata. File may be corrupted or incompatible.")
|
|
else:
|
|
seed = Seed(multidata=multidata)
|
|
commit() # place into DB and generate ids
|
|
return redirect(url_for("view_seed", seed=seed.id))
|
|
else:
|
|
flash("Not recognized file format. Awaiting a .multidata file.")
|
|
return render_template("upload_multidata.html")
|