112 lines
5.0 KiB
Python
112 lines
5.0 KiB
Python
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import time
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from pathlib import Path
|
|
|
|
from crypto_compat import decode, encode
|
|
from store import Store
|
|
|
|
|
|
# Matches the supplied DYD client. Resource game_setting.xyz1 can override it.
|
|
DEFAULT_KEY = "O/UT+WpvDymb26pF485QOA=="
|
|
|
|
|
|
class GameHandler(BaseHTTPRequestHandler):
|
|
server_version = "MyrLocalPrototype/0.1"
|
|
|
|
def do_GET(self) -> None:
|
|
if self.path == "/health":
|
|
self.write_json({"status": "ok", "prototype": True})
|
|
else:
|
|
self.write_json({"error": "not found"}, 404)
|
|
|
|
def do_POST(self) -> None:
|
|
try:
|
|
body = self.rfile.read(int(self.headers.get("Content-Length", "0"))).decode("utf-8")
|
|
request = json.loads(decode(body, self.server.crypto_key)) if self.server.crypto else json.loads(body)
|
|
with self.server.store.lock:
|
|
result = self.dispatch(self.path.lstrip("/"), request)
|
|
status = 200
|
|
except (ValueError, UnicodeError, json.JSONDecodeError) as error:
|
|
result, status = {"resCode": 400, "resMsg": str(error)}, 400
|
|
payload = json.dumps(result, ensure_ascii=False, separators=(",", ":"))
|
|
encoded = encode(payload, self.server.crypto_key) if self.server.crypto else payload
|
|
data = encoded.encode("ascii")
|
|
self.send_response(status)
|
|
self.send_header("Content-Type", "text/plain; charset=utf-8")
|
|
self.send_header("Content-Length", str(len(data)))
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
|
|
def dispatch(self, path: str, request: dict) -> dict:
|
|
store: Store = self.server.store
|
|
if path == "userInfoService/userRegister":
|
|
return store.register(str(request.get("userName", "")), str(request.get("passWord", "")))
|
|
if path == "userServerService/loginUser":
|
|
password = request.get("password", "")
|
|
return store.login(str(request.get("sdkUid", "")), str(password))
|
|
user = store.user(str(request.get("token", "")))
|
|
if not user:
|
|
return {"resCode": 408, "resMsg": "local login required"}
|
|
if path == "userServerService/enterGame":
|
|
return {"resCode": 0, "resMsg": "ok"} if request.get("serverId") == 1 else {"resCode": 404, "resMsg": "unknown server"}
|
|
if path == "userServerService/createMaster":
|
|
return store.create_master(user["id"], str(request.get("roleName", "")), int(request.get("avatar", 1)))
|
|
if path == "userServerService/firstOpenGame":
|
|
return {"resCode": 0, "resMsg": "ok"}
|
|
if path == "masterService/masterQuery":
|
|
return {"resCode": 0, "resMsg": "ok", "masterInfo": store.master_info(user["id"])}
|
|
if path == "masterService/masterQueryDetail":
|
|
return store.detail(user["id"])
|
|
if path == "masterService/queryMasterSecondDetail":
|
|
return {"resCode": 997, "resMsg": "optional second detail is not implemented"}
|
|
if path == "getSysCurTime/execute":
|
|
return {"resCode": 0, "resMsg": "ok", "time": int(time.time() * 1000)}
|
|
if path == "gameService/queryGameNotice":
|
|
return {"resCode": 0, "resMsg": "ok", "gameNotice": "[]"}
|
|
if path == "gameService/queryGameConfig":
|
|
return {"resCode": 0, "resMsg": "ok", "config": "{}"}
|
|
if path in ("heartBeatService/keepAlive", "guideService/guideUpdate"):
|
|
return {"resCode": 0, "resMsg": "ok"}
|
|
return {"resCode": 997, "resMsg": f"local prototype has not implemented: {path}"}
|
|
|
|
def write_json(self, value: dict, status: int = 200) -> None:
|
|
data = json.dumps(value).encode()
|
|
self.send_response(status)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Content-Length", str(len(data)))
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
|
|
def log_message(self, fmt: str, *args: object) -> None:
|
|
print(f"{self.address_string()} {fmt % args}")
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser(description="Local protocol prototype; not the original game server")
|
|
parser.add_argument("--host", default="127.0.0.1")
|
|
parser.add_argument("--port", type=int, default=9099)
|
|
parser.add_argument("--database", default=str(Path(__file__).with_name("local.db")))
|
|
parser.add_argument("--plaintext", action="store_true", help="development only: disable compatible AES codec")
|
|
args = parser.parse_args()
|
|
server = ThreadingHTTPServer((args.host, args.port), GameHandler)
|
|
server.store = Store(args.database)
|
|
server.crypto = not args.plaintext
|
|
server.crypto_key = os.environ.get("MYR_NET_KEY", DEFAULT_KEY)
|
|
print(f"Local prototype listening on http://{args.host}:{args.port}/ (AES={server.crypto})")
|
|
try:
|
|
server.serve_forever()
|
|
except KeyboardInterrupt:
|
|
pass
|
|
finally:
|
|
server.server_close()
|
|
server.store.db.close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|