Node hapi app starts, but doesnt appear to bind to port

Question

I have an hapi app that is in development. Upon running my usual node-foreman with Procfile, the app loads in the command line with no errors, but upon browsing to the configured port, the page errors, no connection, or specifically, connection refused. Back to the CLI, no errors. simple message from the server.start "Server running on http://localhost:3000"

I tried directly launching with gulp (no errors). No browser access.

I tried directly launching with node (no errors). No browser access.

I tried creating a hello world app with hapi, and express, both had no errors and DID load in the browser.

I even version controlled the code back to a version I know worked. Starts server fine from CLI, but no browser loading/access.

I'm a little stuck, would love any thoughts on even a path to go down to trouble shoot.

Thank you in advance.

Here is the app JS:

var config = require('./config');
hapi = require('../lib/hapi'),
chalk = require('chalk'),

module.exports.init = function (callback) {
    //init app bserver
    server = hapi.init();

    callback(server, config );
};

module.exports.start = function (callback) {
    var _this = this;

    _this.init(function (server, config) {

        // Start the app by listening on <port>
        server.start(function () {


            // Logging initialization
            console.log('+-----------------------------------------------------------+');
            console.log(chalk.green('| ' + config.app.title+ '\t\t\t|'));
            console.log('+-----------------------------------------------------------+');
            console.log(chalk.green('| Environment:\t' + process.env.NODE_ENV));
            console.log(chalk.green('| Standard Port:\t' + config.port));
            if (config.https.ssl === true ) {
                console.log(chalk.green('| Secure Port:\t' + config.https.port));
                console.log(chalk.green('| HTTPs:\t\ton'));
            }
            console.log(chalk.green('| App version:\t' + config.version));
            console.log(chalk.green('| App url:\t\t' + ((config.https.ssl === true ? 'https' : 'http')+"://"+config.url)));
            console.log('+-----------------------------------------------------------+');
            console.log('| Database Configuration\t\t\t\t\t|');
            console.log('+-----------------------------------------------------------+');
            console.log(chalk.green(JSON.stringify(config.db, null, 4)));
            console.log('+-----------------------------------------------------------+');

            if (callback) callback(server, db, config);
        });

        return server;
  });

};

AND HERE IS THE HAPI INCLUDE:

var config = require('../general/config'),
Hapi = require('hapi'),
Good = require('good'),
Hoek = require('hoek'),
Inert = require('inert'),
Vision = require('vision'),
Path = require('path'),
Boom = require('boom'),
Bell = require('bell'),
Cookie = require('hapi-auth-cookie'),
Url = require('url'),
hapiAuthSessions = require('./sessions'),
Promise = require('bluebird'),
fs = require('fs');


/* Initialize ORM and all models */
module.exports.initDBConnections = function( server ) {
    server.register([
        {
            register: require('hapi-sequelize'),
            options: [
                {
                    sequelize: new Sequelize(process.env.DATABASE_URL),
                    name: config.db.connection.database,
                    models: config.files.server.models,
                    sync: true,
                    forceSync:false
                }
            ]
        }
    ], function(err) {

        Hoek.assert(!err, err);

    });
}

/**
 * Initialize rendering engine
 */
module.exports.initRenderingEngine = function (server) {

    var paths = [];
    var layouts = [];
    var partials = [];
    var helpers = [];

    /* add each module paths to rendering search, assume if route, there is a view fr module */
    config.files.server.routes.forEach(function (routePath) {
        var rp = Path.relative(Path.join(__dirname,'../../'),Path.resolve(Path.dirname(routePath)+'/../../'))
        if(fs.existsSync(rp+'/server/views/'+config.theme+'/content')) 
            paths.push(rp+'/server/views/'+config.theme+'/content');
        if(fs.existsSync(rp+'/server/views/'+config.theme+'/errors'))
            paths.push(rp+'/server/views/'+config.theme+'/errors');
        if(fs.existsSync(rp+'/server/views/'+config.theme+'/layouts'))
            layouts.push(rp+'/server/views/'+config.theme+'/layouts');
        if(fs.existsSync(rp+'/server/views/'+config.theme+'/partials'))
            partials.push(rp+'/server/views/'+config.theme+'/partials');
        if(fs.existsSync(rp+'/server/views/'+config.theme+'/helpers'))
            helpers.push(rp+'/server/views/'+config.theme+'/helpers');
    });

    server.views({
        engines: {
            html: require('handlebars')
        },
        path: paths,
        layoutPath: layouts,
        partialsPath: partials,
        helpersPath: helpers,
        layout: 'base.view'
    });
}


/**
 * Initialize local variables
 */
module.exports.initLocalVariables = function (server) {
    // Setting application local variables
    for (var property in config) {
        if (config.hasOwnProperty(property)) {
            if (!server.app[property]) {
                server.app[property] = config.app[property]
            }
        }
    }
};



/**
 * Initialize static routes for browser assets
 */
module.exports.initStaticRoutes = function (server) {

    server.route([{
        method: 'GET',
        path: '/{param*}',
        handler: {
            directory: {
                path: Path.join(__dirname, '../../public'),
                redirectToSlash: true,
                listing: false,
                defaultExtension: 'html'
            }
        }
    },{
        method: 'GET',
        path: '/assets/vendor/{param*}',
        handler: {
            directory: {
                path: Path.join(__dirname, '../../node_modules'),
                redirectToSlash: false,
                listing: false,
                defaultExtension: 'js'
            }
        }
    }]);
}


/**
 * Initialize server logging
 */
module.exports.initLogging = function (server) {
    return {
         ops: {
            interval: 1000
        },
        reporters: {
            myConsoleReporter: [{
                module: 'good-squeeze',
                name: 'Squeeze',
                args: [{ log: '*', response: '*' }]
            }, {
                module: 'good-console'
            }, 'stdout']
        }
    };
}

/**
 * Initialize App Tenant
 */

module.exports.initAppTenant = function (server) {
    server.ext('onRequest', function (req, res) {
        server.app['tenant'] = req.info.hostname;
        res.continue(); 
    });

};

/**
 * Initialize ensure SSL
 */
module.exports.initSSL = function(server) {
    server.select('http').route({
        method: '*',
        path: '/{p*}',
        handler: function (req, res) {

            // redirect all http traffic to https
            console.log('redirecting',config.url + req.url.path);
            return res.redirect('https://' + config.url + req.url.path).code(301);
        },
        config: {
            description: 'Http catch route. Will redirect every http call to https'
        }
    });
}

/**
 * Initialize static routes for modules in development mode browser assets
 */
 module.exports.initModulesStaticRoutes = function(server) {

    if (process.env.NODE_ENV === 'development') {
        server.route({
            method: 'GET',
            path: '/modules/{param*}',
            handler: {
                directory: {
                    path: Path.join(__dirname, '../../modules'),
                    redirectToSlash: false,
                    listing: false,
                    defaultExtension: 'html'
                }
            }
        });
    }
}

/**
 * Configure the modules server routes
 */
module.exports.initModulesServerConfigs = function (server) {
  config.files.server.configs.forEach(function (routePath) {
    require(Path.resolve(routePath))(server);
  });
};

/**
 * Configure the modules server routes
 */
module.exports.initModulesServerRoutes = function (server) {
  config.files.server.routes.forEach(function (routePath) {
    require(Path.resolve(routePath))(server);
  });
};

/**
 * Configure Socket.io
 */
module.exports.configureSocketIO = function (server) {
  // Load the Socket.io configuration
  var server = require('./socket.io')(server);

  // Return server object
  return server;
};

/**
 * Initialize hapi
 */
module.exports.init = function init() {

    var server = new Hapi.Server({
        connections: {
            routes: {
                files: {
                    relativeTo: Path.join(__dirname, 'public')
                }
            },
            state: {
                isSameSite: 'Lax'
            }
        },
        debug: { 
            'request': ['error', 'uncaught','all','request']
        },

        cache: [
            {
                name: 'cacheMem',
                engine: require('catbox-memcached'),
                host: '127.0.0.1',
                port: '8000',
                partition: 'cache'
            },{
                name      : 'cacheDisk',
                engine    : require('catbox-disk'),
                cachePath: '/var/tmp',
                partition : 'cache'
            }
        ]
    });

    server.connection({ 
        labels: 'http',
        port: config.port
    });

    if(config.https.ssl == true) {
        server.connection({ 
            labels: 'https',
            port: config.https.port,
            tls: {
                key: config.https.key,
                cert: config.https.cert
            }
        });

        /* redirect ssl */
        this.initSSL(server);
    }

    server.register([Vision,{register: Good, options: this.initLogging(server)},Cookie,Bell,Inert], function(err) {

        Hoek.assert(!err, err);

        var _this = module.exports;  
        var _thisServer = server.select((config.https.ssl == true ? 'https' : 'http'));

        /* Initialize sessions */
        hapiAuthSessions._init(_thisServer);

        /* detect app tenant */
        _this.initAppTenant(_thisServer);


        /* app local variables */
        _this.initLocalVariables(_thisServer);

        /* logging */
        _this.initLogging(_thisServer);

        /* static file serving */
        _this.initStaticRoutes(_thisServer);

        /* module config, routes, static routes */
        _this.initModulesStaticRoutes(_thisServer);
        _this.initModulesServerConfigs(_thisServer);
        _this.initModulesServerRoutes(_thisServer);


        /* rendering engine */
        _this.initRenderingEngine(_thisServer);

        // Configure Socket.io
        server = _this.configureSocketIO(_thisServer);


        //server.start located in ../general/app.js

    });
    return server;
}

HERE IS THE CLI OUTPUT:

[13:58:31] [nodemon] starting `node --inspect server.js`
[13:58:31] [nodemon] child pid: 5596
Debugger listening on ws://127.0.0.1:9229/e2f5837f-b552-4156-b004-e7adb3d30d05
For help see https://nodejs.org/en/docs/inspector
+-----------------------------------------------------------+
| APP - Development Environment         |
+-----------------------------------------------------------+
| Environment:  development
| Standard Port:    3000
| Secure Port:  3001
| HTTPs:        on
| App version:  0.3.0
| App url:      https://localhost:3001
+-----------------------------------------------------------+
| Database Configuration                    |
+-----------------------------------------------------------+
{
    "client": "postgresql",
    "connection": {
        "host": "localhost",
        "port": "5432",
        "database": "database",
        "user": "user",
        "password": "password",
        "ssl": true
    },
    "pool": {
        "min": 2,
        "max": 10
    },
    "migrations": {
        "tableName": "knex_migrations"
    },
    "debug": true
}
+-----------------------------------------------------------+

Answer 1

Ok. I found the answer (this is twice in a week over looking small detail -- Shame on me).

The smaller problem, that lead me to the larger problem, was upon server.start(callback) I didn't have any error checking, similar to:

server.start(function(err) {
    if(err) {
        throw err;
    }
});

Once I added the err logging, it exposed the reason the server was quietly failing.

My Hapi config was requiring a memcached module, and I had not started my memcached server locally.

All back to to working as designed :)