RLGWebD: rlgwebd.js comparison

comparison rlgwebd.js @ 55:96815eae4ebe

RLG-Web: make multiple watchers possible. Split the TermSession class into the new TermSession, which handles the PTY, and client classes, which handle HTTP sessions. These are Player and Watcher. This allows multiple watchers per game, and other improvements.

author	John "Elwin" Edwards <elwin@sdf.org>
date	Mon, 18 Jun 2012 13:43:51 -0700
parents	423ef87ddc9b
children	31bb3cf4f25f

comparison

equal deleted inserted replaced

-:de01aafd4dd6
+:96815eae4ebe
 var http = require('http');
 var net = require('net');
 var url = require('url');
 var path = require('path');
 var fs = require('fs');
+var events = require('events');
 var child_process = require('child_process');
 var daemon = require(path.join(localModules, "daemon"));
 /* Configuration variables */
 // These first two files are NOT in the chroot.
 };
 /* Global state */
 var logins = {};
 var sessions = {};
+var clients = {};
 var allowlogin = true;
+var nextsession = 0;
-/* Constructor for TermSessions.  Note that it opens the terminal and
-* adds itself to the sessions dict. It currently assumes the user has
+/* Constructor.  A TermSession handles a pty and the game running on it.
-* been authenticated.
+*   game: (String) Name of the game to launch.
+*   lkey: (String, key) The user's id, a key into logins.
+*   dims: (Array [Number, Number]) Height and width of the pty.
+*   handlers: (Object) Key-value pairs, event names and functions to
+*           install to handle them.
+*  Events:
+*   "open": Emitted on startup.  Parameters: success (Boolean)
+*   "data": Data generated by child. Parameters: buf (Buffer)
+*   "exit": Child terminated. Parameters: exitcode, signal
 */
-/* TODO take a callback, or emit success/err events. */
+function TermSession(game, lkey, dims, handlers) {
-function TermSession(game, user, dims, lkey) {
+var ss = this;
-/* First make sure starting the game will work. */
+/* Subclass EventEmitter to do the hard work. */
+events.EventEmitter.call(this);
+for (var evname in handlers)
+this.on(evname, handlers[evname]);
+/* Don't launch anything that's not a real game. */
 if (game in games) {
 this.game = games[game];
 }
 else {
-// TODO: throw an exception instead
+this.emit('open', false);
-return null;
+return;
 }
-this.player = String(user);
+if (lkey in logins) {
 this.key = lkey;
-/* This order seems to best avoid race conditions... */
+this.pname = logins[lkey].name;
-this.alive = false;
+}
-// A kludge until TermSession is rewritten to handle real watching.
+else {
-this.sendq = false;
+this.emit('open', false);
-this.sessid = randkey(2);
+return;
-while (this.sessid in sessions) {
-this.sessid = randkey(2);
 }
 /* Grab a spot in the sessions table. */
+this.sessid = nextsession++;
 sessions[this.sessid] = this;
-/* State for messaging. */
-this.nsend = 0;
-this.nrecv = 0;
-this.msgQ = []
-this.Qtimeout = null;
 /* Set up the sizes. */
 this.w = Math.floor(Number(dims[1]));
 if (!(this.w > 0 && this.w < 256))
 this.w = 80;
 this.h = Math.floor(Number(dims[0]));
 var childenv = {};
 for (var key in process.env) {
 childenv[key] = process.env[key];
 }
 childenv["PTYHELPER"] = String(this.h) + "x" + String(this.w);
-/* TODO handle tty-opening errors */
+args = [this.game.path, "-n", this.pname];
-/* TODO make argument-finding into a method */
-args = [this.game.path, "-n", user.toString()];
 this.child = child_process.spawn("/bin/ptyhelper", args, {"env": childenv});
-var ss = this;
+this.emit('open', true);
-this.alive = true;
-this.data = [];
 /* Set up the lockfile and ttyrec */
 var ts = timestamp();
 var progressdir = "/dgldir/inprogress-" + this.game.uname;
-this.lock = path.join(progressdir, this.player + ":node:" + ts + ".ttyrec");
+this.lock = path.join(progressdir, this.pname + ":node:" + ts + ".ttyrec");
 var lmsg = this.child.pid.toString() + '\n' + this.w + '\n' + this.h + '\n';
 fs.writeFile(this.lock, lmsg, "utf8");
-var ttyrec = path.join("/dgldir/ttyrec", this.player, this.game.uname,
+var ttyrec = path.join("/dgldir/ttyrec", this.pname, this.game.uname,
 ts + ".ttyrec");
 this.record = fs.createWriteStream(ttyrec, { mode: 0664 });
+logins[lkey].sessions.push(this.sessid);
+tslog("%s playing %s (index %d, pid %d)", this.pname, this.game.uname,
+this.sessid, this.child.pid);
 /* END setup */
 function ttyrec_chunk(buf) {
 var ts = new Date();
 var chunk = new Buffer(buf.length + 12);
 /* TTYREC headers */
 chunk.writeUInt32LE(Math.floor(ts.getTime() / 1000), 0);
 chunk.writeUInt32LE(1000 * (ts.getTime() % 1000), 4);
 chunk.writeUInt32LE(buf.length, 8);
 buf.copy(chunk, 12);
-ss.data.push(chunk);
 ss.record.write(chunk);
+ss.emit('data', buf);
 }
 this.child.stdout.on("data", ttyrec_chunk);
 this.child.stderr.on("data", ttyrec_chunk);
+this.write = function(data) {
+this.child.stdin.write(data);
+};
 this.child.on("exit", function (code, signal) {
-ss.exitcode = (code != null ? code : 255);
+fs.unlink(ss.lock);
+ss.record.end();
+ss.emit('exit', code, signal);
+var id = ss.sessid;
+delete sessions[id];
+tslog("Session %s ended.", id);
+});
+this.close = function () {
+this.child.kill('SIGHUP');
+};
+}
+TermSession.prototype = new events.EventEmitter();
+function Watcher(session) {
+var ss = this; // that
+this.session = session;
+this.alive = true;
+/* State for messaging. */
+this.nsend = 0;
+this.sendQ = [];
+/* Get a place in the table. */
+this.id = randkey(2);
+while (this.id in clients) {
+this.id = randkey(2);
+}
+clients[this.id] = this;
+function dataH(buf) {
+var reply = {};
+reply.t = "d";
+reply.n = ss.nsend++;
+reply.d = buf.toString("hex");
+ss.sendQ.push(reply);
+}
+function exitH(code, signal) {
 ss.alive = false;
-fs.unlink(ss.lock);
+ss.sendQ.push({"t": "q"});
-/* Wait for all the data to get collected */
+}
-setTimeout(ss.cleanup, 1000);
+session.on('data', dataH);
-});
+session.on('exit', exitH);
+this.read = function() {
+/* Returns an array of all outstanding messages, empty if none. */
+var temp = this.sendQ;
+this.sendQ = [];
+/* Clean up if finished. */
+if (!this.alive) {
+delete clients[this.id];
+}
+return temp;
+};
+this.quit = function() {
+this.session.removeListener('data', dataH);
+this.session.removeListener('exit', exitH);
+delete clients[this.id];
+};
+}
+function Player(gamename, lkey, dims, callback) {
+var ss = this;
+this.alive = false;
+/* State for messaging. */
+this.nsend = 0;
+this.nrecv = 0;
+this.sendQ = [];
+this.recvQ = []
+this.Qtimeout = null;
+/* Get a place in the table. */
+this.id = randkey(2);
+while (this.id in clients) {
+this.id = randkey(2);
+}
+clients[this.id] = this;
+this.read = function() {
+var temp = this.sendQ;
+this.sendQ = [];
+/* Clean up if finished. */
+if (!this.alive) {
+clearTimeout(this.Qtimeout);
+delete clients[this.id];
+}
+return temp;
+};
 this.write = function (data, n) {
 if (!this.alive || typeof (n) != "number") {
 return;
 }
-//console.log("Got message " + n);
 var oindex = n - this.nrecv;
 if (oindex === 0) {
-//console.log("Writing message " + n);
+this.session.write(data);
-this.child.stdin.write(data);
 this.nrecv++;
 var next;
-while ((next = this.msgQ.shift()) !== undefined) {
+while ((next = this.recvQ.shift()) !== undefined) {
-//console.log("Writing message " + this.nrecv);
+this.session.write(next);
-this.child.stdin.write(next);
 this.nrecv++;
 }
-if (this.msgQ.length == 0 && this.Qtimeout) {
+if (this.recvQ.length == 0 && this.Qtimeout) {
 clearTimeout(this.Qtimeout);
 this.Qtimeout = null;
 }
 }
 else if (oindex > 0 && oindex <= 1024) {
-tslog("Stashing message %d at %d", n, oindex - 1);
+tslog("Client %s: Stashing message %d at %d", this.id,  n, oindex - 1);
-this.msgQ[oindex - 1] = data;
+this.recvQ[oindex - 1] = data;
 if (!this.Qtimeout) {
-var nextn = this.nrecv + this.msgQ.length + 1;
+var nextn = this.nrecv + this.recvQ.length + 1;
 this.Qtimeout = setTimeout(this.flushQ, 30000, this, nextn);
 }
 }
 /* Otherwise, discard it */
 return;
 };
-this.flushQ = function (session, n) {
+this.flushQ = function (client, n) {
 /* Callback for when an unreceived message times out.
 * n is the first empty space that will not be given up on. */
-if (!session.alive)
+if (!client.alive || client.nrecv >= n)
 return;
-session.nrecv++;
+client.nrecv++;
 var next;
 /* Clear the queue up to n */
-while (session.nrecv < n) {
+while (client.nrecv < n) {
-next = session.msgQ.shift();
+next = client.recvQ.shift();
 if (next !== undefined)
-session.child.stdin.write(next);
+client.session.write(next);
-session.nrecv++;
+client.nrecv++;
 }
 /* Clear out anything that's ready. */
-while ((next = session.msgQ.shift()) !== undefined) {
+while ((next = client.recvQ.shift()) !== undefined) {
-session.child.stdin.write(next);
+client.session.write(next);
-session.nrecv++;
+client.nrecv++;
 }
 /* Now set another timeout if necessary. */
-if (session.msgQ.length != 0) {
+if (client.recvQ.length != 0) {
-var nextn = session.nrecv + session.msgQ.length + 1;
+var nextn = client.nrecv + client.recvQ.length + 1;
-session.Qtimeout = setTimeout(session.flushQ, 30000, session, nextn);
+client.Qtimeout = setTimeout(client.flushQ, 30000, client, nextn);
 }
-tslog("Flushing queue for session %s", session.sessid);
+tslog("Flushing queue for player %s", player.id);
 };
-this.read = function () {
+this.quit = function() {
-if (this.data.length == 0)
+if (this.alive)
-return null;
+this.session.close();
-var pos = 0;
-var i = 0;
-for (i = 0; i < this.data.length; i++)
-pos += this.data[i].length - 12;
-var nbuf = new Buffer(pos);
-var tptr;
-pos = 0;
-while (this.data.length > 0) {
-tptr = this.data.shift();
-tptr.copy(nbuf, pos, 12);
-pos += tptr.length - 12;
-}
-return nbuf;
 };
-this.close = function () {
+function openH(success) {
-if (this.alive)
+if (success) {
-this.child.kill('SIGHUP');
+ss.alive = true;
-};
+}
-this.cleanup = function () {
+callback(ss, success);
-/* Call this when the child is dead. */
+}
-if (ss.alive)
+function dataH(chunk) {
-return;
+var reply = {};
-ss.record.end();
+reply.t = "d";
-/* Give the client a chance to read any leftover data. */
+reply.n = ss.nsend++;
-if (ss.data.length > 0 || !ss.sendq)
+reply.d = chunk.toString("hex");
-setTimeout(ss.remove, 8000);
+ss.sendQ.push(reply);
-else
+}
-ss.remove();
+function exitH(code, signal) {
-};
+ss.alive = false;
-this.remove = function () {
+ss.sendQ.push({"t": "q"});
-var id = ss.sessid;
+}
-delete sessions[id];
+var handlers = {'open': openH, 'data': dataH, 'exit': exitH};
-tslog("Session %s removed.", id);
+this.session = new TermSession(gamename, lkey, dims, handlers);
-};
+}
-}
+/* Some functions which check whether a player is currently playing or
+* has a saved game.  Maybe someday they will provide information on
+* the game. */
 function checkprogress(user, game, callback, args) {
 var progressdir = "/dgldir/inprogress-" + game.uname;
 fs.readdir(progressdir, function(err, files) {
 if (err) {
 args.unshift(err, null);
 }
 function reaper() {
 var now = new Date();
 function reapcheck(session) {
-if (!session.alive)
-return;
 fs.fstat(session.record.fd, function (err, stats) {
 if (!err && now - stats.mtime > playtimeout) {
-tslog("Reaping %s", session.sessid);
+tslog("Reaping session %s", session.sessid);
 /* Dissociate it with its login name. */
 var sn = logins[session.key].sessions.indexOf(session.sessid);
 if (sn >= 0) {
 logins[session.key].sessions.splice(sn, 1);
 if (now - logins[session.key].ts > playtimeout)
 expired.push(targarray[i]);
 }
 if (expired.length > 0) {
 logins[lkey].ts = new Date(now);
 for (var j = 0; j < expired.length; j++) {
-targarray.splice(targarray.indexOf(expired[j], 1));
+targarray.splice(targarray.indexOf(expired[j]), 1);
 }
 }
 }
 }
 }
 function login(req, res, formdata) {
 if (!allowlogin) {
-sendError(res, 6, null);
+sendError(res, 6, null, false);
 return;
 }
 if (!("name" in formdata)) {
-sendError(res, 2, "Username not given.");
+sendError(res, 2, "Username not given.", false);
 return;
 }
 else if (!("pw" in formdata)) {
-sendError(res, 2, "Password not given.");
+sendError(res, 2, "Password not given.", false);
 return;
 }
 var username = String(formdata["name"]);
 var password = String(formdata["pw"]);
 function checkit(code, signal) {
 else {
 logins[lkey].ts = new Date();
 }
 var username = logins[lkey].name;
 var gname = formdata["game"];
+// If dims are not given or invalid, the constructor will handle it.
 var dims = [formdata["h"], formdata["w"]];
 if (!(gname in games)) {
 sendError(res, 2, "No such game: " + gname);
 tslog("Request for nonexistant game \"%s\"", gname);
 return;
 sendError(res, 4, null);
 tslog("%s is already playing %s", username, gname);
 return;
 }
 // Game starting has been approved.
-var nsession = new TermSession(gname, username, dims, lkey);
+var respondlaunch = function(nclient, success) {
-if (nsession) {
+if (success) {
 res.writeHead(200, {'Content-Type': 'application/json'});
-var reply = {"t": "l", "id": nsession.sessid, "w": nsession.w, "h":
+var reply = {"t": "s", "id": nclient.id, "w": nclient.w, "h":
-nsession.h};
+nclient.h};
 res.write(JSON.stringify(reply));
 res.end();
-tslog("%s playing %s (key %s, pid %d)", username, gname,
+}
-nsession.sessid, nsession.child.pid);
+else {
-logins[lkey].sessions.push(nsession.sessid);
+sendError(res, 5, "Failed to open TTY");
-}
+tslog("Unable to allocate TTY for %s", gname);
-else {
+}
-sendError(res, 5, "Failed to open TTY");
+};
-tslog("Unable to allocate TTY for %s", gname);
+new Player(gname, lkey, dims, respondlaunch);
-}
+};
-}
 checkprogress(username, games[gname], launch, []);
+}
+function watch(req, res, formdata) {
+if (!("n" in formdata)) {
+sendError(res, 2, "Game number not given");
+return;
+}
+var gamenumber = Number(formdata["n"]);
+if (!(gamenumber in sessions)) {
+sendError(res, 7);
+return;
+}
+var session = sessions[gamenumber];
+var watch = new Watcher(session);
+var reply = {"t": "w", "id": watch.id, "w": session.w, "h": session.h};
+res.writeHead(200, {'Content-Type': 'application/json'});
+res.write(JSON.stringify(reply));
+res.end();
+tslog("Game %d is being watched (key %s)", gamenumber, watch.id);
 }
 /* Sets things up for a new user, like dgamelaunch's commands[register] */
 function regsetup(username) {
 function regsetup_l2(err) {
 child_adder.on("exit", checkreg);
 child_adder.stdin.end(uname + '\n' + passwd + '\n' + email + '\n', "utf8");
 return;
 }
-function endgame(term, res) {
+/* Ends the game, obviously.  Less obviously, stops watching the game if
-if (!term.alive) {
+* the client is a Watcher instead of a Player. */
-sendError(res, 7, null);
+function endgame(client, res) {
-return;
+if (!client.alive) {
-}
+sendError(res, 7, null, true);
-term.close();
+return;
-var resheaders = {'Content-Type': 'application/json'};
+}
-res.writeHead(200, resheaders);
+client.quit();
-res.write(JSON.stringify({"t": "q"}));
+// Give things some time to happen.
-res.end();
+if (client instanceof Player)
-term.sendq = true;
+setTimeout(readFeed, 200, client, res);
 return;
 }
-function findTermSession(formdata) {
+function findClient(formdata, playersOnly) {
 if (typeof(formdata) != "object")
 return null;
 if ("id" in formdata) {
-var sessid = formdata["id"];
+var id = formdata["id"];
-if (sessid in sessions) {
+if (id in clients && (!playersOnly || clients[id] instanceof Player)) {
-return sessions[sessid];
+return clients[id];
 }
 }
 return null;
 }
 }
 });
 return;
 }
-function readFeed(res, term) {
+function readFeed(client, res) {
-if (term) {
+if (!client) {
-var reply = {};
+sendError(res, 7, null, true);
-var result = term.read();
+return;
-if (result == null) {
+}
-if (term.alive)
+var msgs = client.read();
-reply.t = "n";
+if (!allowlogin && !msgs.length) {
-else {
+sendError(res, 6, null, true);
-if (allowlogin) {
+return;
-reply.t = "q";
+}
-term.sendq = true;
+res.writeHead(200, { "Content-Type": "application/json" });
-}
+res.write(JSON.stringify(msgs));
-else {
+res.end();
-sendError(res, 6, null);
-return;
-}
-}
-}
-else {
-reply.t = "d";
-reply.n = term.nsend++;
-reply.d = result.toString("hex");
-}
-res.writeHead(200, { "Content-Type": "application/json" });
-res.write(JSON.stringify(reply));
-res.end();
-}
-else {
-sendError(res, 7, null);
-}
 }
 function statusmsg(req, res) {
 var reply = {"s": allowlogin, "g": []};
 for (var sessid in sessions) {
-if (sessions[sessid].alive) {
+var gamedesc = {};
-var gamedesc = {};
+gamedesc["n"] = sessid;
-gamedesc["p"] = sessions[sessid].player;
+gamedesc["p"] = sessions[sessid].pname;
 gamedesc["g"] = sessions[sessid].game.name;
 reply["g"].push(gamedesc);
-}
 }
 res.writeHead(200, { "Content-Type": "application/json" });
 if (req.method != 'HEAD')
 res.write(JSON.stringify(reply));
 res.end();
 var errorcodes = [ "Generic Error", "Not logged in", "Invalid data",
 "Login failed", "Already playing", "Game launch failed",
 "Server shutting down", "Game not in progress" ];
-function sendError(res, ecode, msg) {
+function sendError(res, ecode, msg, box) {
 res.writeHead(200, { "Content-Type": "application/json" });
 var edict = {"t": "E"};
 if (!(ecode < errorcodes.length && ecode > 0))
 ecode = 0;
 edict["c"] = ecode;
 edict["s"] = errorcodes[ecode];
 if (msg)
 edict["s"] += ": " + msg;
-res.write(JSON.stringify(edict));
+if (box)
+res.write(JSON.stringify([edict]));
+else
+res.write(JSON.stringify(edict));
 res.end();
 }
+// TODO new-objects done to here
 function webHandler(req, res) {
 /* default headers for the response */
 var resheaders = {'Content-Type': 'text/html'};
 /* The request body will be added to this as it arrives. */
 var reqbody = "";
 /* This will send the response once the whole request is here. */
 function respond() {
 formdata = getMsg(reqbody);
 var target = url.parse(req.url).pathname;
-var cterm = findTermSession(formdata);
 /* First figure out if the client is POSTing to a command interface. */
 if (req.method == 'POST') {
 if (target == '/feed') {
-if (!cterm) {
+var client = findClient(formdata, false);
-sendError(res, 7, null);
+if (!client) {
+sendError(res, 7, null, true);
 return;
 }
 if (formdata.t == "q") {
 /* The client wants to terminate the process. */
-endgame(cterm, res);
+endgame(client, res);
 }
 else if (formdata.t == "d" && typeof(formdata.d) == "string") {
+if (!(client instanceof Player)) {
+sendError(res, 7, "Watching", true);
+return;
+}
 /* process the keys */
 hexstr = formdata.d.replace(/[^0-9a-f]/gi, "");
 if (hexstr.length % 2 != 0) {
-sendError(res, 2, "incomplete byte");
+sendError(res, 2, "incomplete byte", true);
 return;
 }
 keybuf = new Buffer(hexstr, "hex");
-/* TODO OoO correction */
+client.write(keybuf, formdata.n);
-cterm.write(keybuf, formdata.n);
 }
-readFeed(res, cterm);
+readFeed(client, res);
 }
 else if (target == "/login") {
 login(req, res, formdata);
 }
 else if (target == "/addacct") {
 register(req, res, formdata);
 }
 else if (target == "/play") {
 startgame(req, res, formdata);
+}
+else if (target == "/watch") {
+watch(req, res, formdata);
 }
 else {
 res.writeHead(405, resheaders);
 res.end();
 }
 else if (req.method == 'GET' || req.method == 'HEAD') {
 if (target == '/feed') {
 if (req.method == 'HEAD') {
 res.writeHead(200, {"Content-Type": "application/json"});
 res.end();
-return;
 }
-if (!cterm) {
+else
-sendError(res, 7, null);
+sendError(res, 7, null, true);
 return;
-}
-readFeed(res, cterm);
 }
 else if (target == '/status') {
 statusmsg(req, res);
 }
 else if (target.match(/^\/pstatus\//)) {
 allowlogin = false;
 tslog("Disconnecting...");
 for (var sessid in sessions) {
 sessions[sessid].close();
 }
-setTimeout(shutdown, 10000);
+setTimeout(shutdown, 2000);
 }
 }
 process.on("exit", function () {
 for (var sessid in sessions) {
-if (sessions[sessid].alive)
+sessions[sessid].child.kill('SIGHUP');
-sessions[sessid].child.kill('SIGHUP');
 }
 tslog("Quitting...");
 return;
 });