Add status debugging HTTP server

Author: pauldraper

README.md

@@ -83,20 +83,33 @@ The-Fast-and-the-Furious
 ## Server options
 
 ```
-usage: nodegun [-h] [-v] [--tcp [TCP] | --local [LOCAL]] [--workers [WORKERS]]
+usage: main.js [-h] [-v] [--tcp [TCP] | --local [LOCAL]]
+               [--status-tcp TCP | --status-local LOCAL] [--workers [WORKERS]]
+               
 
-Start Node.js server that supports the Nailgun protocol.
+Node.js server that supports the Nailgun protocol.
 
 Optional arguments:
-  -h, --help           Show this help message and exit.
-  -v, --version        Show program's version number and exit.
-  --tcp [TCP]          TCP address to listen to, given as ip, port, or 
-                       ip:port. IP defaults to 0.0.0.0, and port defaults to 
-                       2113. If no other transport is specified, TCP is used.
-  --local [LOCAL]      Local address to listen to. Defaults to /tmp/nodegun.
-                       sock.
-  --workers [WORKERS]  If present, number of worker processes to start. A 
-                       flag with no argument starts one per CPU.
+  -h, --help            Show this help message and exit.
+  -v, --version         Show program's version number and exit.
+  --workers [WORKERS]   If present, number of worker processes to start. A 
+                        flag with no argument starts one per CPU.
+
+Transport:
+  Transport and address. TCP is used by default.
+
+  --tcp [TCP]           TCP address to listen to, given as ip, port, or 
+                        ip:port. IP defaults to 0.0.0.0, and port defaults to 
+                        2113.
+  --local [LOCAL]       Local address to listen to. Defaults to /tmp/nodegun.
+                        sock.
+
+Status:
+  Optionally expose internal status information via HTTP server.
+
+  --status-tcp TCP      TCP address to listen to for status, given as ip, 
+                        port, or ip:port. IP defaults to 0.0.0.0.
+  --status-local LOCAL  Local address to listen to for status.
 ```
 
 ## Nails

cluster.ts

@@ -1,6 +1,7 @@
 import {BaseServer} from './server';
 import {CommandFactory} from './commandfactory';
 import * as childProcess from 'child_process';
+import * as events from 'events';
 import * as net from 'net';
 
 export class MasterServer {
@@ -27,6 +28,20 @@ export class MasterServer {
             worker.child.send('connection', tcp);
         });
     }
+
+    status() {
+        return Promise.all(this.workers.map(({child, connections}) => {
+            return new Promise<string>(resolve => {
+                child.send('status', error => error && resolve(error.toString()));
+                child.on('message', function listener(this: events.EventEmitter, message) {
+                    if (message && message.type === 'status') {
+                        resolve(message.value);
+                        this.removeListener('message', listener);
+                    }
+                });
+            }).then(process => ({process, connections}));
+        })).then(workers => ({workers}));
+    }
 }
 
 export class WorkerServer extends BaseServer {
@@ -38,6 +53,8 @@ export class WorkerServer extends BaseServer {
                     handle.push(message.data);
                 }
                 this.connection(socket);
+            } else if (message === 'status') {
+                this.status().then(value => process.send!({type:'status', value}));
             }
         });
         super(commandFactory, (process as any).channel || (process as any)._channel);

handler.ts

@@ -4,10 +4,33 @@ import {CommandFactory} from './commandfactory';
 import {Lock} from './lock';
 import {Readable, Writable} from 'stream';
 
+export class TrackingRef {
+    private value = true;
+
+    constructor(readonly delegate: Ref) {
+    }
+
+    getValue() {
+        return this.value;
+    }
+
+    ref() {
+        this.value = true;
+        this.delegate.ref();
+    }
+
+    unref() {
+        this.value = false;
+        this.delegate.unref();
+    }
+}
+
 export class Handler {
     private readonly lock = new Lock();
+    private readonly ref: TrackingRef
 
-    constructor(private readonly commandFactory: CommandFactory, private readonly ref: Ref) {   
+    constructor(private readonly commandFactory: CommandFactory, ref: Ref) {
+        this.ref = new TrackingRef(ref);
     }
 
     handle(reader: Readable, writer: Writable) {
@@ -61,6 +84,13 @@ export class Handler {
             }
         });
     }
+
+    status() {
+        return {
+            lock: this.lock.status(),
+            waitingOnInput: this.ref.getValue(),
+        }
+    }
 }
 
 class MissingWorkingDirectory extends Error {

lock.ts

@@ -9,6 +9,13 @@ export class Lock {
         return Promise.resolve(() => this.next());
     }
 
+    status() {
+        return {
+            'available': !this.queue,
+            'queue': this.queue ? this.queue.length : 0,
+        };
+    }
+
     private next() {
         if (this.queue) {
             const current = this.queue.shift();

main.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {ArgumentParser} from 'argparse';
 import * as fs from 'fs';
+import * as http from 'http';
 import * as net from 'net';
 import * as os from 'os';
 import {CommandFactory} from './commandfactory';
@@ -13,24 +14,43 @@ if (fs.existsSync(__filename.replace(/\.js$/, '.ts'))) {
 
 const npmPackage = require('./package.json');
 
-const parser = new ArgumentParser({description: 'Start Node.js server that supports the Nailgun protocol.', version: npmPackage.version});
-const transport = parser.addMutuallyExclusiveGroup();
-transport.addArgument(['--tcp'], {
-    constant: '127.0.0.1:2113',
-    help: 'TCP address to listen to, given as ip, port, or ip:port. IP defaults to 0.0.0.0, and port defaults to 2113. If no other transport is specified, TCP is used.',
-    nargs: '?',
-});
-transport.addArgument(['--local'], {
-    constant:'/tmp/nodegun.sock',
-    help: 'Local address to listen to. Defaults to /tmp/nodegun.sock.',
-    nargs:'?',
-});
-parser.addArgument(['--workers'], {
-    constant:os.cpus().length,
-    help: 'If present, number of worker processes to start. A flag with no argument starts one per CPU.',
-    nargs:'?',
-});
-const args: {tcp:string|undefined, local:string|undefined, workers:number|undefined} = parser.parseArgs();
+const parser = new ArgumentParser({description: 'Node.js server that supports the Nailgun protocol.', version: npmPackage.version});
+{
+    const transportGroup = parser.addArgumentGroup({
+        description: 'Transport and address. TCP is used by default.',
+        title:'Transport',
+    });
+    const transport = transportGroup.addMutuallyExclusiveGroup();
+    transport.addArgument(['--tcp'], {
+        constant: '127.0.0.1:2113',
+        help: 'TCP address to listen to, given as ip, port, or ip:port. IP defaults to 0.0.0.0, and port defaults to 2113.',
+        nargs: '?',
+    });
+    transport.addArgument(['--local'], {
+        constant:'/tmp/nodegun.sock',
+        help: 'Local address to listen to. Defaults to /tmp/nodegun.sock.',
+        nargs:'?',
+    });
+    const debugGroup = parser.addArgumentGroup({
+        description: 'Optionally expose internal status information via HTTP server.',
+        title: 'Status',
+    });
+    const debugTransport = debugGroup.addMutuallyExclusiveGroup();
+    debugTransport.addArgument(['--status-tcp'], {
+        help: 'TCP address to listen to for status, given as ip, port, or ip:port. IP defaults to 0.0.0.0.',
+        metavar: 'TCP',
+    });
+    debugTransport.addArgument(['--status-local'], {
+        help: 'Local address to listen to for status.',
+        metavar: 'LOCAL',
+    });
+    parser.addArgument(['--workers'], {
+        constant:os.cpus().length,
+        help: 'If present, number of worker processes to start. A flag with no argument starts one per CPU.',
+        nargs:'?',
+    });
+}
+const args: {status_local:string|undefined, status_tcp:string|undefined, tcp:string|undefined, local:string|undefined, workers:number|undefined} = parser.parseArgs();
 
 function listen(server: net.Server) {
     if (args.local) {
@@ -62,10 +82,34 @@ if (args.local) {
     }
 }
 
-let server;
+let server: {server: net.Server, status():Promise<any>};
 if (!args.workers || args.workers <= 0) {
     server = new Server(new CommandFactory());
 } else {
     server = new MasterServer(require.resolve('./worker.js'), args.workers);
 }
 listen(server.server);
+
+
+{
+    const statusServer = http.createServer((request, response) => {
+        response.writeHead(200, {'Content-Type': 'application/json'});
+        server.status().then(status => {
+            response.write(JSON.stringify(status, undefined, 4));
+            response.write('\n');
+            response.end();
+        });
+    });
+    statusServer.unref();
+    if (args.status_local) {
+        fs.unlinkSync(args.status_local);
+        statusServer.listen(args.status_local);
+    } else if (args.status_tcp) {
+        const [first, second] = args.status_tcp.split(':', 2) as [string, string|undefined];
+        if (second == null) {
+            statusServer.listen(+first);
+        } else {
+            statusServer.listen(+first, second);
+        }
+    }
+}

server.ts

@@ -26,6 +26,10 @@ export abstract class BaseServer {
 
         socket.on('timeout', () => socket.destroy(new Error('timeout')));
     }
+
+    status() {
+        return Promise.resolve(this.handler.status());
+    }
 }
 
 export class Server extends BaseServer {
@@ -35,6 +39,5 @@ export class Server extends BaseServer {
         const server = net.createServer(socket => this.connection(socket));
         super(commandFactory, server);
         this.server = server;
-        
     }
 }