pytron-web/server.js

// Requires
const fs = require('fs');
const process = require('process');
const pathtools = require('path');
const express = require('express');
const fileUpload = require('express-fileupload');
const { spawn } = require('child_process');
const pug = require('pug');
const unzip = require('unzip');
const touch = require('touch');
const bcrypt = require('bcryptjs');

// Consts
const port = 8000;
const pythonPath = '/usr/bin/python3'
const aisPath = 'pytron_run/ai_manager/'
const aisPathOld = 'pytron_run/ai_manager_old'
const hashPath = "__bcrypt__hash.txt"

// Create the directories to store the files
try { fs.mkdirSync(aisPath); } catch { }
try { fs.mkdirSync(aisPathOld); } catch { }

let pythonRunning = false;
let pythonShouldRun = false;

function runPython() {
    process.stdout.write('Requested to run python');
    if (pythonRunning) {
        process.stdout.write(' buy python is already running');
        pythonShouldRun = true;
    } else {
        pythonRunning = true;
    }
    process.stdout.write('\n');

    let p = spawn(pythonPath, ['run.py'], {cwd: 'pytron_run'});
    p.stdout.on('data', (data) => {
        let content = data.toString().split('\n');
        for (let line of content) {
            console.log('run.py: ' + line);
        }
    });

    p.stderr.on('data', (data) => {
        let content = data.toString().split('\n');
        for (let line of content) {
            console.log('run.py: ' + line);
        }
    });

    p.on('close', (code) => {
        process.stdout.write('Python finished executing');
        if (pythonShouldRun) {
            process.stdout.write(' but another request arrive, so we will relaunch it\n');
            pythonShouldRun = false;
            pythonRunning = false;
            runPython();
        } else {
            process.stdout.write('\n');
            pythonRunning = false;
        }
    });
}

function parse(data) {
    let content = JSON.parse(data);
    let parsed = {ais: [], battles: {}};
    for (let ai of content.ais) {
        parsed.ais.push({
            name: ai,
            victories: 0,
            defeats: 0,
            nulls: 0,
            score: 0,
        });
    }

    for (let key in content.battles) {
        let battlers = key.split('/');
        let ai1 = battlers[0];
        let ai2 = battlers[1];
        parsed.battles[ai1 + '/' + ai2] = content.battles[key][0];
        parsed.battles[ai2 + '/' + ai1] = content.battles[key][1];

        let realAi1 = parsed.ais.find((x) => x.name == ai1);
        let realAi2 = parsed.ais.find((x) => x.name == ai2);
        realAi1.victories += content.battles[key][0];
        realAi1.defeats += content.battles[key][1];
        realAi2.victories += content.battles[key][1];
        realAi2.defeats += content.battles[key][0];
        realAi1.nulls += content.battles[key][2];
        realAi2.nulls += content.battles[key][2];
    }

    parsed.sortedAis = parsed.ais.slice(0);

    for (let ai of parsed.sortedAis) {
        ai.score = ai.victories * 3 + ai.nulls;
    }

    parsed.sortedAis.sort((a, b) => b.score - a.score);
    if (parsed.sortedAis.length > 0) parsed.sortedAis[0].rank = 1;
    if (parsed.sortedAis.length > 1) parsed.sortedAis[1].rank = 2;
    if (parsed.sortedAis.length > 2) parsed.sortedAis[2].rank = 3;

    return parsed;
}

function saveArchiveAndRun(req, res) {

    let path = pathtools.join(aisPath, req.body.name);
    try { fs.mkdirSync(path); } catch { }

    let zipfile = pathtools.join(path, 'archive.zip');
    req.files.archive.mv(zipfile, (err) => {
        if (err != null) {
            console.log(err);
            res.render('error', {message: 'Unable to save the ZIP archive to the server'});
            return;
        }
        fs.createReadStream(zipfile)
            .pipe(unzip.Extract({path}))
            .on('close', () => {
                // Touch __init__.py
                touch(pathtools.join(path, '__init__.py'), () => {
                    // Trigger python_run
                    runPython();
                    res.redirect('/');
                });
            })
            .on('error', () => {
                res.render('error', {message: 'Failed to unzip the archive'});
            });
    });
}

function startServer() {
    const app = express();
    app.set('view engine', 'pug');
    app.use(fileUpload());

    app.get('/', (req, res) => {
        fs.readFile('pytron_run/assets/data.json', 'utf-8', (err, data) => {
            if (err != null) {
                console.log(err);
            }
            let parsed = parse(data);
            res.render('index', {
                data: parsed,
                running: pythonRunning,
            });
        });
    });

    app.get('/upload', (req, res) => {
        res.render('upload', {});
    });

    app.post('/upload-target', (req, res) => {

        if (!req.body.name) {
            res.render('error', {message: "You have to enter a name in the form"});
            return;
        }

        if (!req.body.password) {
            res.render('error', {message: "You have to enter a password in the form"});
        }

        if (req.body.name.indexOf('.') !== -1) {
            res.render('error', {message: "The name of your AI can't contain dots"});
        }

        if (!req.files.archive) {
            res.render('error', {message: "You have to send a ZIP archive"});
            return;
        }

        let path = pathtools.join(aisPath, req.body.name);
        let aiExisted;
        try {
            fs.statSync(path).isDirectory();
            aiExisted = true;
        } catch (e) {
            aiExisted = false;
            fs.mkdirSync(path);
        }


        if (aiExisted) {
            fs.readFile(pathtools.join(path, hashPath), 'utf-8', function(err, data) {

                if (err != null) {
                    res.render('error', {message: "Couldn't read hashed password"});
                    console.log(err);
                    return;
                }

                // If the AI already existed, verify the password
                bcrypt.compare(req.body.password, data, function(err, success) {
                    if (err != null) {
                        res.render('error', {message: "Couldn't compare password"});
                        return;
                    }

                    if (!success) {
                        res.render('error', {message: "Authentication failed"});
                        return;
                    }

                    try {
                        if (fs.statSync(path).isDirectory()) {
                            // Move it to old
                            let version = 0;
                            for(;;) {
                                let movePath = pathtools.join(aisPathOld, req.body.name + '.' + version);
                                try {
                                    fs.statSync(movePath);
                                    // If the sync succeded, it means that the directory already exists
                                    version++;
                                } catch {
                                    // If we're here, it means that we found the right path. We
                                    // will move the old one to the old directories, and save
                                    // the new one
                                    fs.renameSync(path, movePath);
                                    break;
                                }
                            }
                        }
                    } catch {
                        // Nothing to do here
                    }

                    // Save archive and run stuff
                    saveArchiveAndRun(req, res);
                });
            });
        } else {
            bcrypt.hash(req.body.password, 10, function(err, hash) {

                if (err != null) {
                    res.render('error', {message: "Couldn't hash password"});
                    return;
                }

                // Store hash in your password DB.
                fs.writeFile(pathtools.join(path, hashPath), hash, (err) => {

                    if (err != null) {
                        res.render('error', {message: "Couldn't save hashed password"});
                        return;
                    }

                    // Save archive and run stuff
                    saveArchiveAndRun(req, res);

                });

            });
        }

    });

    app.use('/static', express.static('static'));

    app.listen(port, () => {
        console.log(`Server listening on port ${port}!`)
    })
}

function main() {
    switch (process.argv[2]) {
        case 'start':
            startServer();
            break;
        case 'python':
            runPython();
            break;
        default:
            console.log('Unknown option: ' + process.argv[2]);
            console.log('Usage: node server.js start|python')
            process.exit(1);
            break;
    }
}

main();