docs: function start(callback) {
          var serverDeferred = Q.defer();
  
          if (typeof callback !== 'function') {
              callback = function () {
              };
          }
  
          if (self.isRunning) {
              // FIXME: should this be an error?
              callback();
              return;
          }
  
          sockets = {};
  
          __httpServer = Http.createServer(__app);
  
          if (gmeConfig.server.timeout > -1) {
              __httpServer.timeout = gmeConfig.server.timeout;
          }
  
          function handleNewConnection(socket) {
              var socketId = socket.remoteAddress + ':' + socket.remotePort;
  
              if (socket.encrypted) { // https://nodejs.org/api/tls.html#tls_tlssocket_encrypted
                  socketId += ':encrypted';
              }
  
              sockets[socketId] = socket;
              logger.debug('socket connected (added to list) ' + socketId);
  
              socket.on('close', function () {
                  if (sockets.hasOwnProperty(socketId)) {
                      logger.debug('socket closed (removed from list) ' + socketId);
                      delete sockets[socketId];
                  }
              });
          }
  
          __httpServer.on('connection', handleNewConnection);
          __httpServer.on('secureConnection', handleNewConnection);
  
          __httpServer.on('clientError', function (err/*, socket*/) {
              logger.debug('clientError', err);
          });
  
          __httpServer.on('error', function (err) {
              if (err.code === 'EADDRINUSE') {
                  logger.error('Failed to start server', {metadata: {port: gmeConfig.server.port, error: err}});
                  serverDeferred.reject(err);
              } else {
                  logger.error('Server raised an error', {metadata: {port: gmeConfig.server.port, error: err}});
              }
          });
  
          logger.debug('starting server');
  
          __gmeAuth.connect()
              .then(function (db) {
                  var promises = [];
  
                  logger.debug('gmeAuth connected');
  
                  promises.push(Q.ninvoke(__workerManager, 'start'));
                  promises.push(__storage.openDatabase());
  
                  if (__executorServer) {
                      promises.push(__executorServer.start({mongoClient: db}));
                  }
  
                  return Q.all(promises);
              })
              .then(function () {
                  var promises = [];
                  __webSocket.start(__httpServer);
  
                  promises.push(apiReady);
  
                  routeComponents.forEach(function (component) {
                      promises.push(Q.ninvoke(component, 'start'));
                  });
  
                  return Q.all(promises);
              })
              .then(function () {
                  // Finally start listening to the server port.
                  __httpServer.listen(gmeConfig.server.handle || gmeConfig.server.port, function () {
                      logger.info('Server is listening ...');
                      serverDeferred.resolve();
                  });
  
                  return serverDeferred.promise;
              })
              .then(function () {
                  return webgmeUtils.createStartUpProjects(gmeConfig, __gmeAuth, __storage, logger, getUrl());
              })
              .nodeify(function (err) {
                  self.isRunning = true;
                  if (err) {
                      logger.error('Error at server start', err);
                  }
  
                  callback(err);
              });
      }