j7/app.js

const express = require('express');
const mysql = require("mysql");
const bodyParse = require('body-parser');
const utils = require('./utils');
const event = require('./event');
const config = require('./config');
const db = require('./db');
const error = require('./error');

const app = express();
const handlers = {};
const middlewares = {};
const dbPools = {};
const lockHash = {};
let sessionClass = null;
let useMiddlewares = [];

function listen(port) {
  app.listen(port);
}

function get() {

}

function init() {
  event.emitEvent(event.APP_INITIALIZED_EVENT);
}

function registerHandler(c, a, cb) {
  handlers[a + '@' + c] = {
    'cb': cb,
    'middlewares': useMiddlewares
  };
}

function injectionSession(sessionCls) {
  sessionClass = sessionCls;
}

function addMiddleware(name, cb) {
  middlewares[name] = cb;
}

function useMiddleware(list, cb) {
  try {
    useMiddlewares = [];
    list.forEach((name) => {
      useMiddlewares.push(middlewares[name]);
    });
    cb();
  } finally {
    useMiddlewares = [];
  }
}

function registerDb(name, options) {
  dbPools[name] = {
    'options': options,
    'pool': mysql.createPool({
      host     : options['host'],
      user     : options['user'],
      password : options['passwd'],
      database : options['database'],
      stringifyObjects : true
    })
  };
}

function getDbConn(name) {
  /*try {
    throw new Error(1111);
  } catch (err) {
    console.log(err.stack);
  }*/
  console.log('getDbConn', name);
  const ret = {
    err: null,
    conn: null,
  };
  return new Promise((resolve) => {
    if (!(name in dbPools)) {
      ret.err = 'dbname not exists ' + name;
      resolve(ret);
      return;
    }
    const pool = dbPools[name]['pool'];
    pool.getConnection(function(err, conn) {
      ret.err = err;
      ret.conn = new db(conn);
      resolve(ret);
    });
  });
}

app.use(bodyParse.json({ limit: '50mb'}));
app.use(bodyParse.urlencoded({ limit: '50mb', extended: true}));

process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
  throw reason;
});

app.post('/webapp/index.php', async (req, rsp) => {
  const c = req.query.c;
  const a = req.query.a;
  const handler = handlers[a + '@' + c];
  try {
    if (handler) {
      const cb = handler['cb'];
      const middlewares = handler['middlewares'];
      if (sessionClass) {
        const session = new sessionClass(req, rsp);
        try {
          await Promise.all(middlewares.map(async (m) => {
            await m(session);
          }));
          await cb(session);
        } finally {
          await session.destory();
        }
      } else {
        await Promise.all(middlewares.map(async (m) => {
          await m(req, rsp);
        }));
        await cb(req, rsp);
      }
    } else {
      utils.rspErr(rsp, 100, 'not found');
    }
  } catch (err) {
    if (err instanceof error.InternalError) {
      utils.rspErr(rsp, err.errCode, err.errMsg);
    } else {
      throw err;
    }
  }
});

app.get('/webapp/index.php', async (req, rsp) => {
  const c = req.query.c;
  const a = req.query.a;
  const handler = handlers[a + '@' + c];
  try {
    if (handler) {
      const cb = handler['cb'];
      const middlewares = handler['middlewares'];
      if (sessionClass) {
        const session = new sessionClass(req, rsp);
        try {
          await Promise.all(middlewares.map(async (m) => {
            await m(session);
          }));
          await cb(session);
        } finally {
          await session.destory();
        }
      } else {
        await Promise.all(middlewares.map(async (m) => {
          await m(req, rsp);
        }));
        await cb(req, rsp);
      }
    } else {
      utils.rspErr(rsp, 100, 'not found');
    }
  } catch (err) {
    if (err instanceof error.InternalError) {
      utils.rspErr(rsp, err.errCode, err.errMsg);
    } else {
      throw err;
    }
  }
});

function post(...args) {
  app.post(...args);
}

function addStaticDirectory(path, dir) {
  app.use(path, express.static(dir));
}

function getPid() {
  return process.pid;
}

function getNodeId() {
  return Number(utils.getArgv('n'));
}

function getInstanceId() {
  return Number(utils.getArgv('i'));
}

async function sleep(timeout) {
  return utils.sleep(timeout);
}

registerHandler('Ops', 'selfChecking', async (req, rsp) => {
  if (rsp) {
    utils.rspOk(rsp);
  } else {
    req.rspOk();
  }
});

async function lock(key) {
  if (key in lockHash) {
    lockHash[key] += 1;
  } else {
    lockHash[key] = 1;
  }
  const oldTimes = lockHash[key];
  while (lockHash[key] > oldTimes) {
    await sleep(0.01);
  }
}

function unLock(key) {
  if (key in lockHash) {
    lockHash[key] -= 1;
  }
}

exports.init = init;
exports.listen = listen;
exports.get = get;
exports.post = post;
exports.registerHandler = registerHandler;
exports.injectionSession = injectionSession;
exports.addMiddleware = addMiddleware;
exports.useMiddleware = useMiddleware;
exports.registerDb = registerDb;
exports.getDbConn = getDbConn;
exports.addStaticDirectory = addStaticDirectory;
exports.getPid = getPid;
exports.getNodeId = getNodeId;
exports.getInstanceId = getInstanceId;
exports.sleep = sleep;
exports.lock = lock;
exports.unLock = unLock;