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) {