Server with Glue

server.js

'use strict';

// Load modules
var Hapi    = require('hapi');
var Glue    = require('glue');
var Config  = require('./config');

// Declare internals

var internals = {};

Config.api.server.uri = (Config.api.settings.tls ? 'https://' : 'http://') + Config.api.server.host + ':' + Config.api.server.port;
Config.web.server.uri = (Config.web.settings.tls ? 'https://' : 'http://') + Config.web.server.host + ':' + Config.web.server.port;

var manifest = {
  server: {
    app: {
      config: Config
    },
    cache: Config.cache
  },
  connections: [
    {
      host: Config.api.server.host,
      port: Config.api.server.port,
      uri: Config.api.server.uri,
      labels: Config.api.server.labels
    },
    {
      host: Config.web.server.host,
      port: Config.web.server.port,
      uri: Config.web.server.uri,
      labels: Config.web.server.labels
    }
  ],
  plugins: [
    {'./api': [
      {
        select: 'api',
        routes: { prefix: '/api/v1'}
      }
    ]},
    {'./web': [
      {
        select: 'web'
      }
    ]}
  ]
};


Glue.compose(manifest, { relativeTo: __dirname }, function (err, server) {
  if(err) {
    throw err;
  }
  server.start(function () {
    // server running on port 80
  });
});

web index.js

'use strict';

var Path        = require('path');
var Hoek        = require('hoek');
var Handlebars  = require('handlebars');
var Log         = require('./lib/logger');
var Client      = require('./lib/client');
var Cache       = require ('./lib/cache');
var Cryptish    = require ('cryptish');

exports.register = function (server, options, next) {

  var config  = server.settings.app.config.web.settings;

  Cryptish.init(config.crypto);
  Log.init(server, config.logger);
  Client.init(config.api);

  // Setup our cache segment, using the session segment settings from config.
  // Note: This separates the Web cache segment from the API cache segment while
  // they are running on the same machine.
  var cache = server.cache({
    segment: config.session.cacheSegment,
    expiresIn: config.session.cacheExpiresIn
  });

  Cache.init(cache);

  server.register([
    {
      register: require('good'),
      options: config.logger.options
    },
    require('vision'),
    require('inert'),
    require('crumb'),
    require('hapi-auth-cookie')

  ], function (err) {
    Hoek.assert(!err, 'Failed loading plugin: ' + err);

    server.auth.strategy('session', 'cookie', false, {
      cookie: config.session.cookie,
      password: config.session.password,
      redirectTo: '/signin',
      isSecure: false,
      clearInvalid: true,
      appendNext: true,
      validateFunc: require('./lib/credentials')(config, cache)
    });

    // Load view engine settings
    server.views({
      engines: {
        hbs: require('handlebars')
      },
      relativeTo: './web',
      path: './views',
      partialsPath: './views',
      helpersPath: './views/helpers',
      layoutPath: './views/layouts',
      layout: config.viewOptions.layout,
      isCached: config.viewOptions.isCached
    });

    // Expose some convenience properties available via 'this' on the handlers
    // and extension methods
    server.bind({
      config: config,
      cache: cache
    });

    //Note - routes must be required 'after' Logger.init
    server.route(require('./routes').endpoints);

    next();
  });

  // On startup
  server.after(function (server, next) {
    server.log(['web', 'info'], 'Web server running on ' + server.settings.app.config.web.server.uri);
    next();
  });

  // Logging internal request events
  server.on('request-internal', function (request, event, tags) {
    var keys = Object.keys(tags);
    if (Hoek.intersect(config.logger.level, keys).length > 0) {
      server.log(tags, event);
    }
  });

  // Unhandled errors, including 404 not found
  server.ext('onPreResponse', function (request, reply) {
    var response = request.response;
    if (response.isBoom) {
      var getError = require('./handlers/helpers/getError')(request, reply);
      return getError(response, response.output.statusCode, "An unhandled exception occurred.", null);
    } else {
      return reply.continue();
    }
  });
};

exports.register.attributes = {
  pkg: require('./package.json')
};