enigma-bbs/core/module_util.js

/* jslint node: true */
'use strict';

//  ENiGMA½
const Config    = require('./config.js').get;
const Log       = require('./logger.js').log;
const {
    Errors,
    ErrorReasons
}               = require('./enig_error.js');

//  deps
const fs        = require('graceful-fs');
const paths     = require('path');
const _         = require('lodash');
const assert    = require('assert');
const async     = require('async');
const glob      = require('glob');

//  exports
exports.loadModuleEx            = loadModuleEx;
exports.loadModule              = loadModule;
exports.loadModulesForCategory  = loadModulesForCategory;
exports.getModulePaths          = getModulePaths;
exports.initializeModules       = initializeModules;

function loadModuleEx(options, cb) {
    assert(_.isObject(options));
    assert(_.isString(options.name));
    assert(_.isString(options.path));

    const modConfig = _.isObject(Config[options.category]) ? Config[options.category][options.name] : null;

    if(_.isObject(modConfig) && false === modConfig.enabled) {
        return cb(Errors.AccessDenied(`Module "${options.name}" is disabled`, ErrorReasons.Disabled));
    }

    //
    //  Modules are allowed to live in /path/to/<moduleName>/<moduleName>.js or
    //  simply in /path/to/<moduleName>.js. This allows for more advanced modules
    //  to have their own containing folder, package.json & dependencies, etc.
    //
    let mod;
    let modPath = paths.join(options.path, `${options.name}.js`);   //  general case first
    try {
        mod = require(modPath);
    } catch(e) {
        if('MODULE_NOT_FOUND' === e.code) {
            modPath = paths.join(options.path, options.name, `${options.name}.js`);
            try {
                mod = require(modPath);
            } catch(e) {
                return cb(e);
            }
        } else {
            return cb(e);
        }
    }

    if(!_.isObject(mod.moduleInfo)) {
        return cb(Errors.Invalid(`No exported "moduleInfo" block for module ${modPath}!`));
    }

    if(!_.isFunction(mod.getModule)) {
        return cb(Errors.Invalid(`No exported "getModule" method for module ${modPath}!`));
    }

    return cb(null, mod);
}

function loadModule(name, category, cb) {
    const path = Config().paths[category];

    if(!_.isString(path)) {
        return cb(Errors.DoesNotExist(`Not sure where to look for module "${name}" of category "${category}"`));
    }

    loadModuleEx( { name : name, path : path, category : category }, function loaded(err, mod) {
        return cb(err, mod);
    });
}

function loadModulesForCategory(category, iterator, complete) {

    fs.readdir(Config().paths[category], (err, files) => {
        if(err) {
            return iterator(err);
        }

        const jsModules = files.filter(file => {
            return '.js' === paths.extname(file);
        });

        async.each(jsModules, (file, next) => {
            loadModule(paths.basename(file, '.js'), category, (err, mod) => {
                if(err) {
                    if(ErrorReasons.Disabled === err.reasonCode) {
                        Log.debug(err.message);
                    } else {
                        Log.info( { err : err }, 'Failed loading module');
                    }
                    return next(null);  //  continue no matter what
                }
                return iterator(mod, next);
            });
        }, err => {
            if(complete) {
                return complete(err);
            }
        });
    });
}

function getModulePaths() {
    const config = Config();
    return [
        config.paths.mods,
        config.paths.loginServers,
        config.paths.contentServers,
        config.paths.chatServers,
        config.paths.scannerTossers,
    ];
}

function initializeModules(cb) {
    const Events = require('./events.js');

    const modulePaths = getModulePaths().concat(__dirname);

    async.each(modulePaths, (modulePath, nextPath) => {
        glob('*{.js,/*.js}', { cwd : modulePath }, (err, files) => {
            if(err) {
                return nextPath(err);
            }

            const ourPath = paths.join(__dirname, __filename);

            async.each(files, (moduleName, nextModule) => {
                const fullModulePath = paths.join(modulePath, moduleName);
                if(ourPath === fullModulePath) {
                    return nextModule(null);
                }

                try {
                    const mod = require(fullModulePath);

                    if(_.isFunction(mod.moduleInitialize)) {
                        const initInfo = {
                            events : Events,
                        };

                        mod.moduleInitialize(initInfo, err => {
                            if(err) {
                                Log.warn( { error : err.message, modulePath : fullModulePath }, 'Error during "moduleInitialize"');
                            }
                            return nextModule(null);
                        });
                    } else {
                        return nextModule(null);
                    }
                } catch(e) {
                    Log.warn( { error : e.message, fullModulePath }, 'Exception during "moduleInitialize"');
                    return nextModule(null);
                }
            },
            err => {
                return nextPath(err);
            });
        });
    },
    err => {
        return cb(err);
    });
}