NodeJS-MVC/system/core.js

/**
 * @Author  HonorLee (dev@honorlee.me)
 * @Version 1.0 (2018-05-04)
 * @License MIT
 */
'use strict';
const EventEmitter = require('events').EventEmitter;
global.Core  = {};
global.CACHE = {};
global.System = new EventEmitter();
//Global Path
global.Core.Path = {
    System      : ROOTPATH + '/system',
    CoreLib     : ROOTPATH + '/system/lib/core',
    ExtraLib    : ROOTPATH + '/system/lib/extra',
    Helper      : ROOTPATH + '/system/lib/helper',
    Work        : ROOTPATH + '/app',
    Module      : ROOTPATH + '/app/modules',
    Handler     : ROOTPATH + '/app/handlers',
    View        : ROOTPATH + '/app/view',
    Temp        : ROOTPATH + '/temp',
    Session     : ROOTPATH + '/temp/session',
    Log         : ROOTPATH + '/log',
    Asset       : ROOTPATH + '/' + Config.Asset.asset_path,
    Upload      : ROOTPATH + '/' + Config.Asset.upload_path
};

//Global Extension Require
global.serverUID    = (Math.ceil(Math.random()*61439+4096)).toString(16).toUpperCase();
global.Moment       = require('moment-range').extendMoment(require('moment'));
global.URL          = require('url');
global.Querystring  = require('querystring');
global.FILE         = require('fs-extra');
global.EJS          = require('ejs');
global.ASYNC        = require('async');
global.Base64       = require('js-base64');
global.MD5          = require('md5');
global.Formidable   = require('formidable');
global.MIME         = require('mime-types');
global.Path         = require('path');
global.Tracer       = require('tracer').dailyfile({root:Core.Path.Log,format : "{{timestamp}} <{{title}}> {{file}}:{{line}} {{message}}", dateformat : "HH:MM:ss.L"});

String.random       = require('string-random');
Core.Request        = require('request');
FILE.walkSync       = require('klaw-sync');

//System Library load
let CoreLibFiles = FILE.readdirSync(Core.Path.CoreLib);
CoreLibFiles.forEach(function(filename){
    let nameWithOutMimeType = (filename.split('.')[0]).toUpperCase();
    let coreClass;
    try {
        coreClass = require(Core.Path.CoreLib + '/' + filename);

    }catch(e){
        console.log('[Core] Core library file ['+filename+'] load error!');
        console.log(e);
        Tracer.error('[Core] Core library file ['+filename+'] load error!');
    }
    if(coreClass.hasOwnProperty('_name') && coreClass['_name']){
        global[coreClass['_name']] = coreClass;
    }else{
        global[nameWithOutMimeType] = coreClass;
    }
    if(typeof coreClass == 'object' && coreClass.hasOwnProperty('__construct')) coreClass['__construct']();
});
CoreLibFiles = null;
//System Library load end


//Core Setting,just change it if necessary!
global.Core.Setting = {};
ASYNC.series([(callback)=>{
    //If Mysql on,load Mysql Extension
    if(Config && Config.Database.Mysql.on){
        let MysqlPool    = require(Core.Path.ExtraLib + '/mysql-pool.js').instance(Config.Database.Mysql);
        let testMysqlCon = MysqlPool.getConnection(function(err,connection){
            if(!err){
                connection.release();
                connection.query('SELECT VERSION() as version',function(err,result,fields){
                    if(err){
                        LOGGER.error('Mysql Connect error,please recheck your config');
                        LOGGER.error(err);
                        callback(err);
                    }else{
                        LOGGER.info('Mysql Connect success');
                        LOGGER.info('Mysql Version: ' + result[0]['version'] + ' | User: ' + Config.Database.Mysql.user + ' | Database: ' + Config.Database.Mysql.database);
                        global.MysqlPool = MysqlPool;
                        global.MysqlDB   = require(Core.Path.Helper + '/mysqldb.js');
                        callback();
                    }
                });
            }else{
                LOGGER.error('Mysql Connect error,please recheck your config');
                LOGGER.error(err);
                callback(err);
            }
        });
    }else{
        callback();
    }
},(callback)=>{
    //If Mongodb on,load Mongodb Extension
    if(Config && Config.Database.Mongodb.on && Config.Database.Mongodb.database){
        let verify = Config.Database.Mongodb.user?Config.Database.Mongodb.user+':'+Config.Database.Mongodb.password+'@':'';
        let mongoConnect = 'mongodb://' + verify + Config.Database.Mongodb.host+':'+Config.Database.Mongodb.port+'/'+Config.Database.Mongodb.database;
        require('mongodb').MongoClient.connect(mongoConnect,function(err,db){
            if(err) {
                LOGGER.error('MongoDB connect error!',true);
                LOGGER.error('Server start failed. Log has been saved!');
                // Logger.out(err);
                callback(err);
                return;
            }
            LOGGER.info('Mongodb Connect success');
            global.MongoDB = {db:db};
            global.MG = function(collection){
                if(!collection) return null;
                return MongoDB.db.collection(Config.Database.Mongodb.prefix+collection);
            };
            callback();
        });
    }else{
        callback();
    }
},(callback)=>{
    //If Memcache on,load Memcache Extension
    if(Config && Config.Database.Memcache.on){
        let Memclass  = require('memcached');
        let Memcache  = new Memclass(Config.Database.Memcache.host+':'+Config.Database.Memcache.port);
        Memcache.version(function(err,data){
            if(err){
                LOGGER.error('Memcache Connect error,please recheck your config');
                LOGGER.error(err);
                callback(err);
            }else{
                LOGGER.info('Memcache Connect success');
                LOGGER.info('Memcache Version: ' + data[0]['version']);
                global.Memcache = Memcache;
                callback();
            }
        });
    }else{
        callback();
    }
},(callback)=>{
    //If Redis on,Create Redis Client
    if(Config && Config.Database.Redis.on){
        let redis = require('redis').createClient({port:Config.Database.Redis.port,host:Config.Database.Redis.host,retry_strategy: function (options) {
            if (options.error && options.error.code === 'ECONNREFUSED') {
                LOGGER.error('Redis connect has been refused,please recheck your config,and make sure redis server is running!');
            }
            if (options.total_retry_time > 1000 * 10) {
                LOGGER.error('Redis retry connect time exhausted');
            }
            if (options.attempt > 10) {
                LOGGER.error('Redis unknow error');
            }
            if(options.error) callback(options.error);
            // reconnect after
            return Math.min(options.attempt * 100, 3000);
        },prefix:Config.Database.Redis.prefix});
        redis.on('ready',function(e){
            LOGGER.info('Redis Connect success');
            LOGGER.info('Redis Version: ' + redis.server_info.redis_version);
            global.Redis = redis;
            callback();
        });
        redis.on('reconnecting',function(e){
            LOGGER.warn('Redis lost connect,reconnecting!');
        });
    }else{
        callback();
    }
}],(err)=>{
    if(err){
        System.emit('error',err);
    }else{
        System.emit('ready');
    }
});

//Check File Paths
for(let path in global.Core.Path){
    try{
        FILE.statSync(global.Core.Path[path]);
    }catch(e){
        FILE.mkdirsSync(global.Core.Path[path]);
    }
}

if(Config && Config.Wechat.on){
    global.Wechat = require(Core.Path.ExtraLib + '/wechat/wechat.js');
    try{
        FILE.statSync(Core.Path.Handler + Config.Wechat.handler_path +'/index.js');
    }catch(e){
        FILE.copy(Core.Path.ExtraLib + '/wechat/handler/wechat.js',Core.Path.Handler + Config.Wechat.handler_path +'/index.js')
    }
}

// let HandlerFiles = FILE.walkSync(Core.Path.Handler, {nodir: true});
// CACHE.Handlers = [];
// for(let i in HandlerFiles){
//     let path = HandlerFiles[i]['path'];
//     CACHE.Handlers.push(path.replace(Core.Path.Handler,''));
// }
// CACHE.HandlersString = CACHE.Handlers.join('|');

global.RouterRule = null;
try{
    global.RouterRule = require(ROOTPATH+'/rule.js');
}catch(e){}

module.exports = System;