cleanup

-/**
- * Module dependencies.
- */
-var config = require('./index');
-
-
-/**
- * Initialize settings.
- */
-exports = module.exports = function(lib, app) {
-  var settings = new Settings(config);
-  return settings;
-}
-
-
-/**
- * Component annotations.
- */
-exports['@singleton'] = true;
-
-
-/**
- * Settings component
- */
-
-function Settings(initial) {
-  if(initial)
-  	this._hash = initial;
-  else
-  	this._hash = {};
-}
-
-Settings.prototype.get = function(key) {
-  return this._hash[key];
-}
-
-Settings.prototype.set = function(key, val) {
-  this._hash[key] = val;
-}
\ No newline at end of file

 
 // # Igloo
 
-var async = require('async')
-var config = require('./config')
-var schemas = require('./schemas')
-var lib = require('./lib')(config)
-var app = require('./config/app')
-
-module.exports = igloo
-
-function igloo(callback) {
-
-  async.parallel({
-    db: lib.mongo,
-    sessions: lib.redis
-  }, loadConnections)
-
-  function loadConnections(err, connections) {
-    if (err) return callback(err)
-    lib.db = connections.db
-    lib.config.session.store = lib.sessions = connections.sessions
-    schemas(lib, loadSchemas)
-  }
+var path = require('path')
+var IoC = require('electrolyte')
+var os = require('os')
+var cluster = require('cluster')
+
+IoC.loader(IoC.node(path.join(__dirname, 'lib')))
+
+//
+// Inspired by `bixby-express` and Jared Hanson
+//
+
+var logger = IoC.create('logger')
+var settings = IoC.create('settings')
+var app = IoC.create('app')
+
+exports = module.exports = app
+
+if (cluster.isMaster && settings.server.clusterEnabled) {
+
+  var clusterSize = settings.server.clusterSize || os.cpus().length
 
-  function loadSchemas(err, lib) {
-    if (err) return callback(err)
-    app(lib, callback)
+  logger.info('creating cluster with %d workers', clusterSize)
+
+  for (var i=0; i<clusterSize; i++) {
+    logger.info('spawning worker #%d', i + 1)
+    cluster.fork()
   }
 
-}
+  cluster.on('fork', function(worker) {
+    logger.info('worker #%s with pid %d spawned', worker.id, worker.process.pid)
+  })
 
-if (!module.parent)
-  igloo(function(err, app) {
-    if (err) return lib.logger.error(err)
-    app.listen(config.port, function() {
-      lib.logger.info('igloo started at %s://%s:%d', config.protocol, config.host, config.port)
+  cluster.on('online', function(worker) {
+    logger.info('worker #%s with pid %d online', worker.id, worker.process.pid)
+  })
+
+  cluster.on('listening', function(worker, addr) {
+    logger.info('worker #%s with pid %d listening on %s:%d', worker.id, worker.process.pid, addr.address, addr.port)
+  })
+
+  cluster.on('disconnect', function(worker) {
+    logger.info('worker #%s with pid %d disconnected', worker.id, worker.process.pid)
+  })
+
+  cluster.on('exit', function(worker, code, signal) {
+    logger.error('worker #%s with pid %d exited with code/signal', worker.id, worker.process.pid, signal || code)
+    if (worker.suicide) return
+    logger.info('worker #%s restarting', worker.id)
+    cluster.fork()
+  })
+
+} else {
+
+  app.boot(function(err) {
+
+    if (err) {
+      logger.error(err)
+      process.exit(0)
+      return
+    }
+
+    logger.info('app booted')
+
+    app.listen(settings.server.port, settings.server.host, function() {
+      var addr = this.address()
+      logger.info('app listening on %s:%d', addr.address, addr.port)
     })
+
   })
+
+}

+
+// # app
+
+var express = require('express')
+var bootable = require('bootable')
+var IoC = require('electrolyte')
+var bootableEnvironment = require('bootable-environment')
+
+exports = module.exports = function(logger, settings) {
+
+  var app = bootable(express())
+  app.phase(bootableEnvironment())
+  app.phase(bootable.initializers())
+  app.phase(bootable.routes())
+
+  return app
+
+}
+
+exports['@singleton'] = true
+exports['@require'] = [ 'logger', 'settings' ]

+
+// # config
+
+exports = module.exports = function() {
+
+  return {
+    defaults: {
+      server: {
+        host: 'localhost',
+        clusterEnabled: true
+      },
+      cookieParser: '',
+      mongo: {
+        host: 'localhost',
+        port: '27017',
+        opts: {}
+      },
+      redis: {
+        host: 'localhost',
+        port: 6379,
+        maxAge: 24 * 60 * 60 * 1000
+      }
+    },
+    development: {
+      server: {
+        env: 'development',
+        port: 3000,
+      },
+      mongo: {
+        dbname: 'igloo-development',
+      },
+      redis: {
+        prefix: 'igloo-development'
+      }
+    },
+    production: {
+      server: {
+        env: 'production',
+        port: 80,
+      },
+      mongo: {
+        dbname: 'igloo-production',
+      },
+      redis: {
+        prefix: 'igloo-production'
+      }
+    }
+  }
+
+}
+
+exports['@singleton'] = true

-
-//
-// # data node
-//
-// This is the missing data injection functionality in
-// electrolyte. Based on electrolyte/loaders/node.js, the
-// default script loader.
-//
-
-var _ = require('underscore')
-
-module.exports = function(data, options) {
-
-  if (_.isString(options))
-    options = {
-      dirname: options
-    }
-
-  return function(id) {
-
-    var newId = null
-
-    if (id) {
-      var dir = options.dirname + '/'
-      if (id.indexOf(dir) === 0)
-        newId = id.substr(dir.length)
-    }
-
-    if (newId)
-      return data[newId]
-
-    return data
-
-  }
-
-}

-
-// # lib
-
-module.exports = function(config) {
-  var lib = {
-    config: config,
-    logger: require('./logger')
-  }
-  lib.mongo = require('./mongo')(lib)
-  lib.redis = require('./redis')(lib)
-  return lib
-}

@@ -3,11 +3,19 @@
 
 var winston = require('winston')
 
-var logger = module.exports = new (winston.Logger)({
-  transports: [
-    new (winston.transports.Console)({
-      colorize: true
-    })
-  ]
-})
+exports = module.exports = function(settings) {
 
+  var logger = module.exports = new (winston.Logger)({
+    transports: [
+      new (winston.transports.Console)({
+        colorize: true
+      })
+    ]
+  })
+
+  return logger
+
+}
+
+exports['@singleton'] = true
+exports['@require'] = [ 'settings' ]

+
+// # settings
+
+var _ = require('underscore')
+
+exports = module.exports = function(config) {
+
+  var settings = {}
+
+  _.defaults(settings, config.defaults)
+
+  var env = process.env.NODE_ENV || 'development'
+
+  _.defaults(settings, config[env])
+
+  return settings
+
+}
+
+exports['@singleton'] = true
+exports['@require'] = [ 'config' ]

@@ -19,6 +19,8 @@
   "dependencies": {
     "async": "~0.2.10",
     "body-parser": "~1.2.0",
+    "bootable": "^0.2.3",
+    "bootable-environment": "^0.2.0",
     "chalk": "^0.4.0",
     "commander": "^2.2.0",
     "connect-flash": "~0.1.1",