enigma-bbs/core/bbs.js

222 lines
5.7 KiB
JavaScript

/* jslint node: true */
'use strict';
// ENiGMA½
var conf = require('./config.js');
var logger = require('./logger.js');
var miscUtil = require('./misc_util.js');
var database = require('./database.js');
var iconv = require('iconv-lite');
var paths = require('path');
var async = require('async');
var util = require('util');
var _ = require('lodash');
exports.bbsMain = bbsMain;
function bbsMain() {
async.waterfall(
[
function processArgs(callback) {
var args = parseArgs();
var configPath;
if(args.indexOf('--help') > 0) {
// :TODO: display help
} else {
var argCount = args.length;
for(var i = 0; i < argCount; ++i) {
var arg = args[i];
if('--config' == arg) {
configPath = args[i + 1];
}
}
}
var configPathSupplied = _.isString(configPath);
callback(null, configPath || conf.getDefaultPath(), configPathSupplied);
},
function initConfig(configPath, configPathSupplied, callback) {
conf.init(configPath, function configInit(err) {
//
// If the user supplied a path and we can't read/parse it
// then it's a fatal error
//
if(configPathSupplied && err) {
if('ENOENT' === err.code) {
console.error('Configuration file does not existing: ' + configPath);
} else {
console.error('Failed parsing configuration: ' + configPath);
}
callback(err);
} else {
callback(null);
}
});
},
function initSystem(callback) {
initialize(function init(err) {
if(err) {
console.error('Error initializing: ' + util.inspect(err));
}
callback(err);
});
}
],
function complete(err) {
if(!err) {
startListening();
}
}
);
}
function parseArgs() {
var args = [];
process.argv.slice(2).forEach(function(val, index, array) {
args.push(val);
});
return args;
}
function initialize(cb) {
async.series(
[
function basicInit(callback) {
logger.init();
process.on('SIGINT', function onSigInt() {
// :TODO: for any client in |clientConnections|, if 'ready', send a "Server Disconnecting" + semi-gracefull hangup
// e.g. client.disconnectNow()
logger.log.info('Process interrupted, shutting down');
process.exit();
});
iconv.extendNodeEncodings();
callback(null);
},
function initDatabases(callback) {
database.initializeDatabases();
callback(null);
},
function initThemes(callback) {
// Have to pull in here so it's after Config init
var theme = require('./theme.js');
theme.initAvailableThemes(function onThemesInit(err, themeCount) {
logger.log.info({ themeCount : themeCount }, 'Themes initialized');
callback(err);
});
}
],
function onComplete(err) {
cb(err);
}
);
}
var clientConnections = [];
function startListening() {
if(!conf.config.servers) {
// :TODO: Log error ... output to stderr as well. We can do it all with the logger
logger.log.error('No servers configured');
return [];
}
var moduleUtil = require('./module_util.js'); // late load so we get Config
moduleUtil.loadModulesForCategory('servers', function onServerModule(err, module) {
if(err) {
logger.log.info(err);
return;
}
var port = parseInt(module.runtime.config.port);
if(isNaN(port)) {
logger.log.error({ port : module.runtime.config.port, server : module.moduleInfo.name }, 'Cannot load server (Invalid port)');
return;
}
var moduleInst = new module.getModule();
var server = moduleInst.createServer();
// :TODO: handle maxConnections, e.g. conf.maxConnections
server.on('client', function onClient(client) {
//
// Start tracking the client. We'll assign it an ID which is
// just the index in our connections array.
//
if(typeof client.runtime === 'undefined') {
client.runtime = {};
}
addNewClient(client);
//logger.log.info({ clientId : client.runtime.id, from : client.address(), server : module.moduleInfo.name }, 'Client connected');
client.on('ready', function onClientReady() {
// Go to module -- use default error handler
prepareClient(client, function onPrepared() {
require('./connect.js').connectEntry(client);
});
});
client.on('end', function onClientEnd() {
logger.log.info({ clientId : client.runtime.id }, 'Client disconnected');
removeClient(client);
});
client.on('error', function onClientError(err) {
logger.log.info({ clientId : client.runtime.id }, 'Connection error: %s' % err.message);
});
client.on('close', function onClientClose(hadError) {
var l = hadError ? logger.log.info : logger.log.debug;
l({ clientId : client.runtime.id }, 'Connection closed');
removeClient(client);
});
});
server.listen(port);
logger.log.info({ server : module.moduleInfo.name, port : port }, 'Listening for connections');
});
}
function addNewClient(client) {
var id = client.runtime.id = clientConnections.push(client) - 1;
logger.log.debug('Connection count is now %d', clientConnections.length);
return id;
}
function removeClient(client) {
var i = clientConnections.indexOf(client);
if(i > -1) {
clientConnections.splice(i, 1);
logger.log.debug('Connection count is now %d', clientConnections.length);
}
}
function prepareClient(client, cb) {
// :TODO: it feels like this should go somewhere else... and be a bit more elegant.
if('*' === conf.config.preLoginTheme) {
var theme = require('./theme.js');
client.user.properties.theme_id = theme.getRandomTheme() || '';
theme.loadTheme(client.user.properties.theme_id, function themeLoaded(err, theme) {
client.currentTheme = theme;
cb(null);
});
} else {
client.user.properties.theme_id = conf.config.preLoginTheme;
cb(null);
}
}