@andersbakken/fisk 3.5.6 → 3.6.0

package/daemon/client.js

@@ -1,100 +0,0 @@
-const EventEmitter = require("events");
-const WebSocket = require("ws");
-const os = require('os');
-const path = require('path');
-const fs = require('fs');
-
-class Client extends EventEmitter {
-    constructor(option, configVersion) {
-        super();
-
-        this.configVersion = configVersion;
-        this.scheduler = option("scheduler", "ws://localhost:8097");
-        if (this.scheduler.indexOf('://') == -1)
-            this.scheduler = "ws://" + this.scheduler;
-        if (!/:[0-9]+$/.exec(this.scheduler))
-            this.scheduler += ":8097";
-        this.hostname = option("hostname");
-        this.name = option("name");
-        try {
-            this.npmVersion = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"))).version;
-        } catch (err) {
-        }
-        console.log("this is our npm version", this.npmVersion);
-        if (!this.name) {
-            if (this.hostname) {
-                this.name = this.hostname;
-            } else  {
-                this.name = os.hostname();
-            }
-        }
-    }
-
-    connect() {
-        const url = `${this.scheduler}/daemon`;
-        console.log("connecting to", url);
-
-        let headers = {
-            "x-fisk-port": this.serverPort,
-            "x-fisk-config-version": this.configVersion,
-            "x-fisk-daemon-name": this.name,
-            "x-fisk-npm-version": this.npmVersion
-        };
-        if (this.hostname)
-            headers["x-fisk-builder-hostname"] = this.hostname;
-
-        this.ws = new WebSocket(url, { headers: headers });
-        this.ws.on("open", () => {
-            this.emit("connect");
-        });
-        this.ws.on("error", err => {
-            console.error("client websocket error", err.message);
-        });
-        this.ws.on("message", msg => {
-            const error = msg => {
-                this.ws.send(`{"error": "${msg}"}`);
-                this.ws.close();
-                this.emit("error", msg);
-            };
-            console.log("Got message from scheduler", msg);
-        });
-        this.ws.on("close", () => {
-            this.emit("close");
-            if (this.ws)
-                this.ws.removeAllListeners();
-            this.ws = undefined;
-        });
-    }
-
-    sendBinary(blob) {
-        try {
-            this.ws.send(blob);
-        } catch (err) {
-            this.emit("err", err.toString());
-        }
-    }
-    send(type, msg) {
-        if (!this.ws) {
-            this.emit("error", "No connected websocket");
-            return;
-        }
-        try {
-            if (msg === undefined) {
-                this.ws.send(JSON.stringify(type));
-            } else {
-                let tosend;
-                if (typeof msg === "object") {
-                    tosend = msg;
-                    tosend.type = type;
-                } else {
-                    tosend = { type: type, message: msg };
-                }
-                this.ws.send(JSON.stringify(tosend));
-            }
-        } catch (err) {
-            this.emit("err", err.toString());
-        }
-    }
-}
-
-module.exports = Client;

package/daemon/clientbuffer.js

@@ -1,73 +0,0 @@
-class ClientBuffer
-{
-    constructor()
-    {
-        this.buffers = [];
-        this.offset = 0;
-    }
-
-    write(buffer)
-    {
-        this.buffers.push(buffer);
-        // console.log("write", buffer.length, this.buffers.length, this.available);
-    }
-
-    peek()
-    {
-        if (!this.available)
-            throw new Error("No data available");
-        return this.buffers[0][this.offset];
-    }
-
-    read(len)
-    {
-        if (!len)
-            throw new Error("Don't be a tool");
-        if (len > this.available)
-            throw new Error("We don't have this many bytes available " + len + ">" + this.available);
-
-        // console.log("read", len, this.available);
-        let ret;
-
-        if (this.buffers[0].length - this.offset >= len) { // buffers[0] is enough
-            let buf = this.buffers[0];
-            if (buf.length - this.offset == len) {
-                ret = this.offset ? buf.slice(this.offset) : buf;
-                this.offset = 0;
-                this.buffers.splice(0, 1);
-                return ret;
-            }
-            ret = buf.slice(this.offset, this.offset + len);
-            this.offset += len;
-            return ret;
-        }
-
-        ret = Buffer.allocUnsafe(len);
-        let retOffset = 0;
-        this.buffers[0].copy(ret, 0, this.offset);
-        retOffset += this.buffers[0].length - this.offset;
-        this.offset = 0;
-        this.buffers.splice(0, 1);
-        while (retOffset < len) {
-            const needed = len - retOffset;
-            let buf = this.buffers[0];
-            if (buf.length <= needed) {
-                this.buffers[0].copy(ret, retOffset);
-                retOffset += this.buffers[0].length;
-                this.buffers.splice(0, 1);
-            } else {
-                this.buffers[0].copy(ret, retOffset, 0, needed);
-                retOffset += needed;
-                this.offset = needed;
-            }
-        }
-        return ret;
-    }
-
-    get available()
-    {
-        return this.buffers.reduce((total, buf) => total + buf.length, 0) - this.offset;
-    }
-};
-
-module.exports = ClientBuffer;

package/daemon/compile.js

@@ -1,140 +0,0 @@
-const EventEmitter = require('events');
-const ClientBuffer = require('./clientbuffer');
-const Constants = require('./constants');
-
-class Compile extends EventEmitter
-{
-    constructor(conn, id, option)
-    {
-        super();
-        this.debug = option("debug");
-        this.id = id;
-        this.connection = conn;
-        this.buffer = new ClientBuffer;
-        this.messageLength =  0;
-        this.pid = undefined;
-
-        this.connection.on('data', this._onData.bind(this));
-        this.connection.on('end', () => {
-            // console.log("connection ended", id);
-            this.emit('end');
-        });
-        this.connection.on('error', err => {
-            // console.log("connection error", id, err);
-            this.emit('error', err);
-        });
-    }
-
-    send(message)
-    {
-        if (this.debug)
-            console.log("Compile::send", message);
-
-        try {
-            if (typeof message === 'number') {
-                this.connection.write(Buffer.from([message]));
-            } else {
-                let msg = Buffer.from(JSON.stringify(message), "utf8");
-                let header = Buffer.allocUnsafe(5);
-                header.writeUInt8(Constants.JSONResponse, 0);
-                header.writeUInt32BE(msg.length, 1);
-                if (this.debug) {
-                    console.log("Compile::send header", header, Constants.JSONResponse);
-                }
-                this.connection.write(header);
-                this.connection.write(msg);
-            }
-        } catch (err) {
-            console.error("Got error sending message", err);
-        }
-    }
-
-    _onData(data)
-    {
-
-        // console.log("got data", data.length);
-        this.buffer.write(data);
-        let available = this.buffer.available;
-        if (this.debug)
-            console.log("Compile::_onData", "id", this.id, "pid", this.pid,
-                        data, "available", available, this.messageLength);
-
-        if (!this.pid) {
-            if (available < 4)
-                return;
-
-            let pidBuffer = this.buffer.read(4);
-            available -= 4;
-            this.pid = pidBuffer.readUInt32BE();
-            if (this.debug)
-                console.log("Compile::_onData got pid", "id", this.id, "pid", this.pid);
-        }
-
-        let emit = type => {
-            if (this.debug)
-                console.log("Compile::_onData::emit", type, available);
-
-            let read = this.buffer.read(1);
-            if (this.debug) {
-                console.log("Discarded", read);
-            }
-            --available;
-            this.emit(type);
-        };
-
-        while (available) {
-            if (!this.messageLength) {
-                if (this.debug)
-                    console.log("peeking", this.buffer.peek());
-
-                switch (this.buffer.peek()) {
-                case Constants.AcquireCppSlot:
-                    emit('acquireCppSlot');
-                    continue;
-                case Constants.AcquireCompileSlot:
-                    emit('acquireCompileSlot');
-                    continue;
-                case Constants.ReleaseCppSlot:
-                    emit('releaseCppSlot');
-                    continue;
-                case Constants.ReleaseCompileSlot:
-                    emit('releaseCompileSlot');
-                    continue;
-                case Constants.JSON:
-                    if (available < 5)
-                        break;
-                    this.buffer.read(1);
-                    this.messageLength = this.buffer.read(4).readUInt32BE();
-                    available -= 5;
-                    break;
-                default:
-                    console.error("Bad data", this.buffer.peek(), "available", available);
-                    throw new Error("Got unexpected type " + this.buffer.peek());
-                }
-            }
-
-            if (!this.messageLength || this.messageLength > available) {
-                // console.log("Still waiting on data", this.messageLength, this.buffer.available);
-                break;
-            }
-
-            let raw = this.buffer.read(this.messageLength);
-            available -= this.messageLength;
-            this.messageLength = 0;
-
-            try {
-                let msg = JSON.parse(raw.toString('utf8'));
-                if (this.debug)
-                    console.log("Got json message", msg);
-                // console.log("Got message", msg);
-                this.emit(msg.type, msg);
-            } catch (err) {
-                console.error("Bad JSON received", err);
-                this.connection.destroy();
-                break;
-            }
-        }
-    }
-}
-
-module.exports = Compile;

package/daemon/constants.js

@@ -1,13 +0,0 @@
-module.exports = {
-    // client codes
-    get AcquireCppSlot() {  return 1; },
-    get AcquireCompileSlot() { return 2; },
-    get ReleaseCppSlot() { return 3; },
-    get ReleaseCompileSlot() { return 4; },
-    get JSON() { return 5; },
-
-    // daemon codes
-    get CppSlotAcquired() { return 10; },
-    get CompileSlotAcquired() { return 11; },
-    get JSONResponse() { return 12; }
-};

package/daemon/fisk-daemon.js

@@ -1,166 +0,0 @@
-#!/usr/bin/env node
-
-const option = require('@jhanssen/options')({ prefix: 'fisk/daemon',
-                                              applicationPath: false,
-                                              additionalFiles: [ "fisk/daemon.conf.override" ] });
-const ws = require('ws');
-const os = require('os');
-const assert = require('assert');
-const common = require('../common')(option);
-const Server = require('./server');
-const Slots = require('./slots');
-const Constants = require('./constants');
-
-const debug = option('debug');
-
-process.on('unhandledRejection', (reason, p) => {
-    console.log('Unhandled Rejection at: Promise', p, 'reason:', reason.stack);
-    process.exit();
-    // if (client)
-    //     client.send('log', { message: `Unhandled Rejection at: Promise ${p}, reason: ${reason.stack}` });
-
-});
-
-process.on('uncaughtException', err => {
-    console.error('Uncaught exception', err);
-    process.exit();
-    // if (client)
-    //     client.send('log', { message: `Uncaught exception ${err.toString()} ${err.stack}` });
-});
-
-const server = new Server(option, common);
-server.listen().then(() => {
-    console.log('listening on', server.file);
-});
-
-// server.on("message
-
-server.on('error', (err) => {
-    console.error('server error', err);
-});
-
-const cppSlots = new Slots(option.int('cpp-slots', Math.max(os.cpus().length * 2, 1)), 'cpp', debug);
-const compileSlots = new Slots(option.int('slots', Math.max(os.cpus().length, 1)), 'compile', debug);
-
-server.on('compile', compile => {
-    compile.on("dumpSlots", () => {
-        let ret = { cpp: cppSlots.dump(), compile: compileSlots.dump() };
-        if (debug)
-            console.log("sending dump", ret);
-
-        compile.send(ret);
-    });
-    let requestedCppSlot = false;
-    compile.on('acquireCppSlot', () => {
-        if (debug)
-            console.log('acquireCppSlot');
-
-        assert(!requestedCppSlot);
-        requestedCppSlot = true;
-        cppSlots.acquire(compile.id, {pid: compile.pid}, () => {
-            // compile.send({ type: 'cppSlotAcquired' });
-            compile.send(Constants.CppSlotAcquired);
-        });
-    });
-
-    compile.on('releaseCppSlot', () => {
-        if (debug)
-            console.log('releaseCppSlot');
-
-        assert(requestedCppSlot);
-        if (requestedCppSlot) {
-            requestedCppSlot = false;
-            cppSlots.release(compile.id);
-        }
-    });
-
-    let requestedCompileSlot = false;
-    compile.on('acquireCompileSlot', () => {
-        if (debug)
-            console.log('acquireCompileSlot');
-
-        assert(!requestedCompileSlot);
-        requestedCompileSlot = true;
-        compileSlots.acquire(compile.id, {pid: compile.pid}, () => {
-            // compile.send({ type: 'compileSlotAcquired' });
-            compile.send(Constants.CompileSlotAcquired);
-        });
-    });
-
-    compile.on('releaseCompileSlot', () => {
-        if (debug)
-            console.log('releaseCompileSlot');
-
-        assert(requestedCompileSlot);
-        if (requestedCompileSlot) {
-            requestedCompileSlot = false;
-            compileSlots.release(compile.id);
-        }
-    });
-
-    compile.on('error', err => {
-        if (debug)
-            console.error('Got error from fiskc', compile.id, compile.pid, err);
-        if (requestedCppSlot) {
-            requestedCppSlot = false;
-            cppSlots.release(compile.id);
-        }
-        if (requestedCompileSlot) {
-            requestedCompileSlot = false;
-            compileSlots.release(compile.id);
-        }
-    });
-
-    compile.on('end', () => {
-        if (debug)
-            console.log("got end from", compile.id, compile.pid);
-        if (requestedCppSlot) {
-            requestedCppSlot = false;
-            cppSlots.release(compile.id);
-        }
-        if (requestedCompileSlot) {
-            requestedCompileSlot = false;
-            compileSlots.release(compile.id);
-        }
-    });
-});
-
-process.on('exit', () => {
-    server.close();
-});
-
-process.on('SIGINT', sig => {
-    server.close();
-    process.exit();
-});
-
-/*
-  const client = new Client(option, common.Version);
-
-let connectInterval;
-client.on('quit', message => {
-    process.exit(message.code);
-});
-
-client.on('connect', () => {
-    console.log('connected');
-    if (connectInterval) {
-        clearInterval(connectInterval);
-        connectInterval = undefined;
-    }
-});
-
-client.on('error', err => {
-    console.error('client error', err);
-});
-
-client.on('close', () => {
-    console.log('client closed');
-    if (!connectInterval) {
-        connectInterval = setInterval(() => {
-            console.log('Reconnecting...');
-            client.connect();
-        }, 1000);
-    }
-});
-*/

package/daemon/server.js

@@ -1,81 +0,0 @@
-const net = require('net');
-const path = require('path');
-const EventEmitter = require('events');
-const fs = require('fs-extra');
-const ClientBuffer = require('./clientbuffer');
-const Compile = require('./compile');
-
-class Server extends EventEmitter
-{
-    constructor(option, common)
-    {
-        super();
-        this.debug = option("debug");
-        this.file = option("socket", path.join(common.cacheDir(option), "socket"));
-        this.server = undefined;
-        this.option = option;
-        this._connections = {};
-        this._connectionId = 0;
-    }
-
-    close()
-    {
-        if (this.debug)
-            console.log("Server::close");
-        if (this.server)
-            this.server.close();
-        try {
-            fs.unlinkSync(this.file);
-        } catch (err) {
-        }
-    }
-
-    listen()
-    {
-        try {
-            fs.unlinkSync(this.file); // this should be more
-                                      // complicated with attempts to
-                                      // cleanly shut down and whatnot
-        } catch (err) {
-        }
-        return new Promise((resolve, reject) => {
-            let connected = false;
-            this.server = net.createServer(this._onConnection.bind(this)).listen(this.file, () => {
-                fs.chmodSync(this.file, '777');
-                connected = true;
-                resolve();
-            });
-            this.server.on('error', err => {
-                if (!connected) {
-                    console.error("Got server error", err);
-                    setTimeout(this.listen.bind(this), 1000);
-                }
-            });
-
-            this.server.on('close', () => {
-                if (!connected) {
-                    console.error("Got server error", err);
-                    setTimeout(this.listen.bind(this), 1000);
-                }
-            });
-        });
-    }
-    _onConnection(conn)
-    {
-        let compile = new Compile(conn, ++this._connectionId, this.option);
-        if (this.debug)
-            console.log("Server::_onConnection", compile.id);
-        if (this._connectionId == Math.pow(2, 31) - 1)
-            this._connectionId = 0;
-        this._connections[compile.id] = conn;
-        compile.on('end', () => {
-            if (this.debug)
-                console.log("Compile::end");
-
-            delete this._connections[compile.id];
-        });
-        this.emit('compile', compile);
-    }
-}
-
-module.exports = Server;

package/daemon/slots.js

@@ -1,69 +0,0 @@
-const EventEmitter = require('events');
-const assert = require('assert');
-
-class Slots extends EventEmitter
-{
-    constructor(count, name, debug)
-    {
-        super();
-        this.count = count;
-        this.name = name;
-        this.used = new Map();
-        this.debug = debug;
-        this.pending = new Map();
-        if (this.debug)
-            console.log("Slots created", this.toString());
-    }
-
-    acquire(id, data, cb)
-    {
-        if (this.used.size < this.count) {
-            this.used.set(id, data);
-            if (this.debug)
-                console.log("acquired slot", id, data, this.toString());
-            cb();
-        } else {
-            if (this.debug)
-                console.log("pending slot", id, this.toString());
-            this.pending.set(id, {data: data, cb: cb});
-        }
-    }
-
-    release(id)
-    {
-        this.pending.delete(id);
-        if (this.used.has(id)) {
-            let data = this.used.get(id);
-            this.used.delete(id);
-            assert(this.used.size < this.count);
-            assert(this.used.size + 1 == this.count || this.pending.size == 0);
-            if (this.debug)
-                console.log("released", id, data, this.toString());
-            for (let p of this.pending) {
-                this.used.set(p[0], p[1].data);
-                this.pending.delete(p[0]);
-                p[1].cb();
-                break;
-            }
-       }
-    }
-    toString()
-    {
-        return `${this.name} ${this.used.size}/${this.count}`;
-    }
-
-    dump()
-    {
-        let pending = {}, used = {};
-        for (let p of this.pending) {
-            pending[p[0]] = p[1].data;
-        }
-
-        for (let p of this.used) {
-            used[p[0]] = p[1];
-        }
-        return { used: used, pending: pending, capacity: this.count, used: this.used.size };
-    }
-}
-
-module.exports = Slots;