my huge pull request

.gitignore

@@ -9,3 +9,6 @@ frontend/scoreboard/bundle.js
 */stage
 results
 emails
+kvmstuff/config.py
+kvmstuff/config.pyc
+kvmstuff/wheezy.img

README.md

@@ -1,3 +1,5 @@
 ## TODO
-[ ] Ease configuration, change problem, etc.  
-[ ] Tighten security, chroot jail
+* [ ] frontend code must get the problem from the server instead of static configuration
+* [ ] scoreboard must only allow improvements per username
+* [ ] more accurate timing: a good algorithm was able to get 0 microseconds :3
+* [ ] probably tons more

backend/EvaluationClient.js

@@ -4,6 +4,9 @@ function EvaluationClient(id, socket) {
 
     this.idle = false;
     this.ready = false;
+    this.cur = 0;
+    this.max = 0;
+    this.name = "unknown";
 }
 
 module.exports = EvaluationClient;

backend/EvaluationServer.js

@@ -2,12 +2,16 @@ var EventEmitter = require('events').EventEmitter;
 var inherits = require('inherits');
 var Q = require('q');
 var WebSocketServer = require('ws').Server;
+var _ = require('underscore');
+var ObjDist = require('objdist');
 
 var EvaluationClient = require('./EvaluationClient');
 
-function EvaluationServer(problem, opts) {
+function EvaluationServer(problem, opts, transport, path) {
     this.problem = problem;
     this.opts = opts || {};
+    this.evalstatus = new ObjDist(transport, {prefix:path});
+    this.setStatus();
 
     this.setup();
 }
@@ -32,17 +36,19 @@ EvaluationServer.prototype.evaluate = function (language, src) {
     var self = this;
 
     function send() {
-        self.sendSubmission(submission.data, self.getClient()).fail(function (err) {
+        var client = self.getClient();
+        if(!client) {
+            console.error('failed to get a client');
+            return false;
+        }
+        self.sendSubmission(submission.data, client).fail(function (err) {
             console.error('failed sending submission to client');
             console.error(err);
-
-            console.error('retrying...');
-            send();
         });
+        return true;
     }
-    send();
-
-    return submission.promise;
+    if(send()) return submission.promise;
+    return undefined;
 };
 
 // --- interal API ---
@@ -74,21 +80,24 @@ EvaluationServer.prototype.handleConnection = function (socket) {
     });
 
     socket.on('error', function (err) {
-        client.deferred.reject(err);
+        client.deferred.reject({event:'error', status:err});
     });
 
     socket.on('close', function () {
-        client.deferred.reject('connection closed');
+        client.deferred.reject({event:'error', status:'connection closed'});
         delete self.clients[clientId];
         delete self.idleClients[clientId];
+        self.setStatus();
     });
 };
 
 EvaluationServer.prototype.handleReceivedEvent = function (payload, client) {
-    console.dir(payload);
+    // Debugs everything received from the server
+    //console.dir(payload);
     switch (payload.event) {
         case 'ready':
             client.ready = true;
+            client.name = payload.data.name;
 
             if (client.idle) {
                 this.idleClients[client.id] = client;
@@ -98,43 +107,47 @@ EvaluationServer.prototype.handleReceivedEvent = function (payload, client) {
             this.sendProblem(this.problem, client);
             break;
         case 'freeslots':
-            client.idle = payload.data.cur > 0;
+            client.cur = payload.data.cur;
+            client.max = payload.data.max;
+            client.idle = client.cur > 0;
 
             if (client.ready) {
                 if (client.idle) {
                     this.idleClients[client.id] = client;
                 } else {
                     delete this.idleClients[client.id];
                 }
+                this.setStatus();
             }
             break;
         case 'compile':
             var submission = this.submissions[payload.data.submissionId];
 
             if (payload.data.success !== 0) {
-                submission.reject('compile', payload);
+                // event, status
+                submission.reject({event:'compile', status:payload.data});
             } else {
-                submission.notify('compile', payload);
+                submission.notify({event:'compile', status:payload.data});
             }
             break;
         case 'eval':
             var submission = this.submissions[payload.data.submissionId];
             submission.evalTime += payload.data.walltime;
 
             if (payload.data.success !== 0) {
-                submission.reject('eval', payload);
+                submission.reject({event:'eval', status:payload.data.success});
             } else {
                 ++submission.numAccepted;
-                submission.notify('eval', submission.numAccepted);
+                submission.notify({event:'eval', status:submission.numAccepted});
             }
             break;
         case 'endsub':
             var submission = this.submissions[payload.data.submissionId];
 
             if (payload.data.errstr) {
-                submission.reject('error', payload.data.errstr);
+                submission.reject({event:'error', status:payload.data.errstr});
             } else {
-                submission.resolve(submission.evalTime, payload);
+                submission.resolve(submission.evalTime);
             }
 
             break;
@@ -185,3 +198,8 @@ EvaluationServer.prototype.sendProblem = function (problem, client) {
 
     return deferred.promise;
 };
+EvaluationServer.prototype.setStatus = function () {
+    this.evalstatus.setObject(_.map(this.clients, function(client) {
+        return _.pick(client, ['id', 'name', 'max', 'cur']);
+    }));
+};

backend/Results.js

@@ -0,0 +1,155 @@
+var EventEmitter = require('events').EventEmitter;
+var inherits = require('inherits');
+var ObjDist = require('objdist');
+var Datastore = require('nedb');
+var _ = require('underscore');
+
+function Results(transport, prefix, filename) {
+    this.dist = new ObjDist(transport, {prefix:prefix});
+    this.store = new Datastore({filename: filename, autoload: true});
+    this.publishResults();
+}
+
+module.exports = Results;
+inherits(Results, EventEmitter);
+
+Results.prototype.sendResult = function(result, socket) {
+    var self = this;
+    this.once('publish', function(){
+        var results = self.dist.getObject();
+
+        for (var idx in results) {
+            var rankedResult = results[idx];
+
+            if (rankedResult.name == result.name && rankedResult.problemID == result.problemID) {
+                var sendResult = _.clone(result);
+
+                sendResult.rank = rankedResult.rank;
+                sendResult.impTime = self.formatTime(result.impTime);
+                sendResult.runTime = self.formatTime(result.runTime);
+                sendResult = _.pick(sendResult, ['problemID', 'rank', 'language', 'name', 'impTime', 'runTime', 'codeSize', 'accepted']);
+
+                socket.emit('result', sendResult);
+                console.dir(result);
+                return;
+            }
+        }
+        console.err("Results.prototype.sendResult: We are asked to send the result for "+result.name+" at problem "+result.problemID+" but no such result exists!");
+    });
+};
+
+// We are forced to call self.publishResults() at some point.
+Results.prototype.addResult = function(result) {
+    // TODO: Q
+    var query = {
+        'problemID': result.problemID,
+        'name':      result.name
+    };
+    var self = this;
+
+    // We need to get the results before we formatted them and added them to the public object
+    // Only interested in this users results
+    this.store.find(query, function(err, results) {
+        if (err) {
+            console.dir(err);
+            return;
+        }
+
+        var update = true;
+        for (var idx in results) {
+            var rankedResult = results[idx];
+
+            // This one is worse (Is my operator pointing the right way?)
+            if (result_cmp(rankedResult, result) < 0) {
+                console.log("Old result is better, not updating: (old, new):");
+                console.log(rankedResult);
+                console.log(result);
+                update = false;
+            } else {
+                console.log("New result is better, updating");
+            }
+            break;
+        }
+
+        if (update) {
+            self.store.update(query, result, {upsert:true}, function (err) {
+                if (err) {
+                    console.dir(err);
+                    return;
+                }
+
+                self.publishResults();
+            });
+        } else {
+            self.publishResults();
+        }
+    });
+};
+
+Results.prototype.formatTime = function(time) {
+    var formattedTime = '';
+
+    if (time < 1/1000) {
+        formattedTime = Math.round(time*1000000) + '&mu;s';
+    } else if (time < 1/10) {
+        formattedTime = Math.round(time*1000) + 'ms';
+    } else {
+        time = Math.round(time*100)/100;
+
+        if (time == Math.round(time)) {
+            formattedTime = time + '.00s';
+        } else if (time == Math.round(time*10)/10) {
+            formattedTime = time + '0s';
+        } else {
+            formattedTime = time + 's';
+        }
+    }
+
+    return formattedTime;
+};
+
+Results.prototype.getRankedResults = function(results) {
+    // TODO: Why copy?
+    var results = results.slice(0); // copy
+
+    results.sort(result_cmp);
+
+    for (var rank in results) {
+        results[rank].rank = parseInt(rank) + 1;
+    }
+
+    return results;
+};
+
+Results.prototype.publishResults = function() {
+    var self = this;
+    this.store.find({}, function(err, results) {
+        if (err) {
+            console.dir(err);
+            return;
+        }
+
+        results = self.getRankedResults(results);
+
+        for (var idx in results) {
+            var result = results[idx];
+
+            result.impTime = self.formatTime(result.impTime);
+            result.runTime = self.formatTime(result.runTime);
+            results[idx] = _.pick(result, ['problemID', 'rank', 'language', 'name', 'impTime', 'runTime', 'codeSize', 'accepted']);
+        }
+
+        self.dist.setObject(results);
+        self.emit('publish');
+    });
+};
+
+function result_cmp(lhs, rhs) {
+    // var lhsBadness = (1e-7 + lhs.impTime) * (1e-7 + lhs.runTime) * (1 + lhs.codeSize);
+    // var rhsBadness = (1e-7 + rhs.impTime) * (1e-7 + rhs.runTime) * (1 + rhs.codeSize);
+    // hack: ignore impTime
+    var lhsBadness = (1e-7 + lhs.runTime) * (1 + lhs.codeSize);
+    var rhsBadness = (1e-7 + rhs.runTime) * (1 + rhs.codeSize);
+
+    return lhsBadness/rhsBadness - 1;
+}