host.js

var servers = {}
var routes = []

var host = {}

host.route = ({path, host, to}) => { routes.push({path, host, to}) }

host.server = (name, file='server.js') => {
    var fork = require('child_process').fork
    var port = 2000 + Math.floor(Math.random() * 7999) + ''

    // Span a child process
    var child = fork(
        file,
        {                       // Options
            env: {port: port},
            cwd: name,
            stdio: 'pipe',
            execArgv: [...process.execArgv,
                       // This makes it kill itself when we die
                       '--require', __dirname + '/die-when-parent-dies.js']
        }
    )
    var server = {process: child, output: '', port, name}
    servers[port] = server
    
    console.log('Spawned', name)//, 'to make', servers[port].stdout)

    child.stdout.on('data', (x) => {
        server.output += x
        console.log((`> ${name}: ` + x).slice(0, -1))
    })
    child.stderr.on('data', (x) => {
        server.output += x
        console.log((`> ${name}-err: ` + x).slice(0, -1))
    })
    child.on('close', async (code) => {
        console.log('process', name, 'exited with code', code)
        delete servers[port]

        // check if the process is really dead
        // (because it seems like there are some ghost processes looming about sometimes)
        if ((await get_running_process_set())[child.pid]) {
            require('fs').appendFileSync('host-ghost-processes.log', `process = ${child.pid}\n`)
        }

        // Restart in 3 seconds
        setTimeout( () => module.exports.server(name, file), 3000)
    })
    return server
}

host.listen = (port) => {
    var http2 = require('http2')
    var read = require('fs').readFileSync
    var server = http2.createSecureServer({
        key: read('private-key'),
        cert: read('certificate'),
        allowHTTP1: true,
        settings: {
            maxConcurrentStreams: 10000
        }
    })
    var proxy = require('http2-proxy')

    server.on('request', (req, res) => {
        var host = req.headers.host || req.headers[':authority']
        console.log('Host:', req.method, host, req.url)

        for (var i=0; i<routes.length; i++) {
            var route = routes[i]

            //var new_req = {...req, path: '/foo'}
            // console.log('old/new request is', req, new_req)
            
            if (route_match(req, route)) {
                // if (route.path) {
                //     console.log('Changing url for', route.path,
                //                 'from', req.url, 'to',
                //                 '/' + req.url.substr(route.path.length))
                //     req.url = '/' + req.url.substr(route.path.length)
                // }
                console.log('Host: sending route to', route.to.name)

                proxy.web(req, res, {
                    hostname: host,
                    port: route.to.port,
                    onReq: route.to.new_req,
                    proxyTimeout: 0         // Keep subscriptions open
                }, on_web_error)
                return
            }
        }

    })
    server.on('upgrade', (req, socket, head) => {
        var host = req.headers.host || req.headers[':authority']
        console.log('Host websocket:', req.method, host, req.url)

        for (var i=0; i<routes.length; i++) {
            var route = routes[i]
            if (route_match(req, route)) {
                console.log('forwarding websocket to', route.to.name)
                proxy.ws(req, socket, head, {
                    hostname: host,
                    port: route.to.port,
                    onReq: route.to.new_req,
                    proxyTimeout: 0         // Keep subscriptions open
                }, on_ws_error)
                return
            }
        }
    })

    server.listen(port)
}

function route_match (req, route) {
    var regexify = (str) => typeof str === 'string'
        ? new RegExp('^' + str.replace('*', '.*'))
        : str
        
    // console.log('Testing', route.path, route.name, route.host, req.headers.host,
    //             req.headers.host?.match(regexify(route.host)))

    // If host is specified, then make sure it matches
    if (route.host && req.headers.host
        && !req.headers.host.match(regexify(route.host)))
        return false

    // Now if path is specified, make sure it matches
    if (route.path
        && !req.url.match(regexify(route.path)))
        return false
    
    // Otherwise, we're good.
    return true
}

// When proxying a request fails, tell the client
function on_web_error (err, req, res) {
    if (!err) return
    console.error('proxy error', err)

    // If we haven't responded yet, we can say what went wrong
    if (!res.headersSent)
        res.writeHead(err.statusCode || 502).end()

    // Otherwise the client already has its status and headers, so it's too
    // late to send an error.  Hang up instead, so the client sees the stream
    // die, and reconnects.
    else if (!res.destroyed)
        res.destroy()
}

// When proxying a websocket fails, hang up on the client
function on_ws_error (err, req, socket) {
    if (!err) return
    console.error('proxy error', err)
    socket.destroy()
}

async function get_running_process_set() {
    let ps = require('child_process').spawn('ps', ['axo', 'pid'], {stdio: 'pipe'})
    let ps_stdout = []
    ps.stdout.on('data', x => ps_stdout.push(x))
    ps.stderr.on('data', x => ps_stdout.push(x))
    await new Promise(done => ps.stdout.on('end', done))
    let x = Buffer.concat(ps_stdout).toString()
    return Object.fromEntries(x.match(/\d+/g).map(x => [x, true]))
}

module.exports = host