apracjs/lib/aprac.js

/*!
 * apracjs
 * Copyright(c) 2017 by wssf
 * 2017-04-26
 * 对外公开的包、及方法接口信息等
 * 内部主要是使用包装后的connect创建server
 * 初始化config配置信息
 * 定义路由请求顺序
 */

'use strict';
var config = require('./config.js').apracConfig;
var http = require('http');
var path = require('path');
var debug = require('debug')('aprac:app');
var Router = require('./handlers/router.js');
var staticHandler = require('./handlers/static.js');
var gspxHandler = require('./handlers/gspx/gspx.js');
var ajaxHandler = require('./handlers/ajax/ajax.js');
var axdHandler = require('./handlers/axd.js');
var connect = require('./handlers/connect.js')();
var utils = require('./common/utils.js');
var finalhandler = require('finalhandler');
var compression = require('compression');
var cookieParser = require('cookie-parser');
var session = require('express-session');
var bodyParser = require('body-parser');
var CoreDistributor = require('./distributor/coreDistributor.js');
var url = require("url");
var RedisStore = require('connect-redis')(session);

class Aprac {
  constructor() {
    this.settings = config;
    this.defaultConfiguration();
  }

  defaultConfiguration() {
    debug('booting in %s mode', this.get('env'));

    this.set('staticTag', '*');
    this.set('ajaxTag', '.ajax'); // 数据服务引擎
    this.set('webPath', path.join(process.cwd(), this.get('webFolder')));

    this._initRouter();

  }

  _initRouter() {
    if (this._router) return;
    this._router = new Router(this);
    this.registerRouter();

    connect.use(utils.createDelegate(this, this.checkMethod));
    connect.use(compression()); // 不管是页面还是资源，都需要压缩，因此放最前面
    connect.use(utils.createDelegate(this, this.startHandler)); // 必须放其它层的前面，接收请求前先判断类型

    connect.use(cookieParser(config.cookieSecret));

    let sessionConfig = {
      secret: config.cookieSecret, // 与cookieParser中的一致
      name: config.sessionIdKey,
      cookie: {
        maxAge: config.sessionTimeout * 60 * 1000 // 20分钟过期
      },
      resave: config.SessionResave,
      saveUninitialized: config.SessionSaveUninitialized
    };

    if (config.sessionConn) {
      let sessionConnUrlInfo = url.parse(config.sessionConn);
      //选择缓存数据库
      if (sessionConnUrlInfo.protocol === "redis:") {
        let dbName = parseInt(sessionConnUrlInfo.pathname.substr(1, sessionConnUrlInfo.pathname.length - 1));
        let port = parseInt(sessionConnUrlInfo.port);
        sessionConfig.store = new RedisStore({
          host: sessionConnUrlInfo.hostname,
          port: port,
          db: dbName,
          pass: sessionConnUrlInfo.auth
        });
      }
    }
    connect.use(session(sessionConfig));

    connect.use(bodyParser.json(this._getJsonDefaultOptions({ reviver: this.dateReviver })));
    connect.use(bodyParser.raw(this._getJsonDefaultOptions({})));
    connect.use(bodyParser.text(this._getJsonDefaultOptions({})));//接收外部传过来的文本数据，如c#中通过webclient的upload数据，需要指定webclient的content-type:text/plain
    connect.use(bodyParser.urlencoded(this._getJsonDefaultOptions({ extended: false }))); // 用于打印管理器没安装时，点击导出Excel

    connect.use(utils.createDelegate(this, this.endHandle)); // 平台中间件

    connect.use(this.errorHandler); // 中间件发生异常拦截器
    debug('router add finish');
  }

  registerRouter() {
    this.registerDistributor();

    //注册分发器的handler
    var apracConfigDistributor = config.Distributor;
    if (apracConfigDistributor) {
      for (var i in apracConfigDistributor) {
        var item = apracConfigDistributor[i];
        this.registerDistributor(item);
      }
    }
  }

  registerDistributor(appConfig) {//根据appName区分处理器
    var core = undefined;
    if (appConfig) {
      core = new CoreDistributor(appConfig);
    }
    // this._router.addHandler(new staticHandler(this, this.get('staticTag'))); // 解析静态文件请求
    this._router.addHandler(new staticHandler(this, core)); // 解析静态文件请求
    this._router.addHandler(new gspxHandler(this, core)); // 解析gspx请求
    this._router.addHandler(new ajaxHandler(this, core)); // 解析ajax请求
    this._router.addHandler(new axdHandler(this, core)); // 解析带版本号的资源请求
  }

  _getJsonDefaultOptions(options) {
    options.limit = config.jsonLimit;
    return options;
  }

  dateReviver(key, value) { // carpa3前端js序列化日志格式为时间戳ticks，需要服务端单独做转换为Date
    if (typeof value === 'string') {
      var a = /^\/Date\((-?[\d.]+?)\)\/$/.exec(value);
      if (a) {
        return new Date(Number(a[1]));
      }
    }
    return value;
  }

  checkMethod(req, res, next) {
    res.req = req;
    var isOPTIONS = req.method == "OPTIONS";
    var allowHeaders = config.defaultAllowHeaders; // 平台默认请求头
    if (config.allowHeaders) allowHeaders += ',' + config.allowHeaders; // 产品自定义请求头

    utils.setCORSHeader(res, config.allowOrigins, allowHeaders, config.withCredentials, isOPTIONS); // 预先检查并统一输出跨域请求头

    if (isOPTIONS) { // 跨域请求预检查
      res.end('ok'); // 预检查不继续处理业务逻辑，直接返回
      return;
    }
    next(); // 继续处理
  }

  startHandler(req, res, next) {
    var handler = this._router.handle(req, res);
    handler.init(req, res);

    if (handler.enableSession(req)) { // handler自行判断，减少验证
      req._apracHandler = handler; // 注入，存起来
      next();
      return;
    }

    handler.processRequest(req, res, this.getDone(req, res)); // 请求类型分发处理，如果是资源类请求，直接跳过session、cookie、Parser等（按情况）
  }

  endHandle(req, res, done) {
    req._apracHandler.processRequest(req, res, this.getDone(req, res));
  }

  getDone(req, res) {
    var done = finalhandler(req, res, {
      env: this.get('env'),
      onerror: this.logerror.bind(this)
    });
    return done;
  }

  errorHandler(ex, req, res, next) {
    res.writeHead(res.statusCode, { 'Content-Type': "application/json; charset=utf-8" });
    if (ex.type === 'entity.too.large') {
      const msg = "请求数据过大，请联系管理员调整数据大小";
      res.end(JSON.stringify({ Message: msg, msg }));
      return;
    }
    if (ex.notFound) {
      res.statusCode = 404;
    } else {
      res.statusCode = 500;
    }
    var errorObj = { "Message": utils.makeExceptionHtml(ex, false) };
    res.end(JSON.stringify(errorObj));
  }

  set(name, val) {
    if (arguments.length === 1) {
      return this.get[name];
    }
    this.settings[name] = val;
    return this;
  }

  get(setting) {
    return this.settings[setting];
  }

  listen(port, hostname, callback) {
    var server = connect.listen(port, hostname, callback);
    return server;
  }

  logerror(err) {
    if (this.get('env') !== 'test') {
      var msg = '';
      if (err.message) {
        msg = err.message;
      } else {
        msg = err.stack || err.toString();
      }
      console.error(msg);
    }
  }
}

exports = module.exports = Aprac;