@bigtyphoon/melo 1.7.6

package/lib/common/service/filterService.ts

@@ -0,0 +1,118 @@
+import { getLogger } from '@bigtyphoon/melo-logger'; import { RouteRecord } from '../../util/constants';
+import { HandlerCallback } from './handlerService';
+import { BeforeHandlerFilter, AfterHandlerFilter } from '../../interfaces/IHandlerFilter';
+import { FrontendOrBackendSession } from '../../server/server';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+/**
+ * Filter service.
+ * Register and fire before and after filters.
+ */
+export class FilterService {
+
+    befores: BeforeHandlerFilter[] = [];    // before filters
+    afters: AfterHandlerFilter[] = [];     // after filters
+
+    name = 'filter';
+
+    removeBefore(filter: BeforeHandlerFilter) {
+        let index = this.befores.findIndex(v => v === filter);
+        if (index >= 0) {
+            this.befores.splice(index);
+        }
+    }
+
+    removeAfter(filter: AfterHandlerFilter) {
+        let index = this.afters.findIndex(v => v === filter);
+        if (index >= 0) {
+            this.afters.splice(index);
+        }
+    }
+
+    /**
+     * Add before filter into the filter chain.
+     *
+     * @param filter {Object|Function} filter instance or filter function.
+     */
+    before(filter: BeforeHandlerFilter) {
+        this.befores.push(filter);
+    }
+
+    /**
+     * Add after filter into the filter chain.
+     *
+     * @param filter {Object|Function} filter instance or filter function.
+     */
+    after(filter: AfterHandlerFilter) {
+        this.afters.unshift(filter);
+    }
+
+    /**
+     * TODO: other insert method for filter? such as unshift
+     */
+
+    /**
+     * Do the before filter.
+     * Fail over if any filter pass err parameter to the next function.
+     *
+     * @param msg {Object} clienet request msg
+     * @param session {Object} a session object for current request
+     * @param cb {Function} cb(err) callback function to invoke next chain node
+     */
+    beforeFilter(routeRecord: RouteRecord , msg: any, session: FrontendOrBackendSession, cb: HandlerCallback) {
+        let index = 0, self = this;
+        let next = function (err?: any, resp?: any) {
+            if (err || index >= self.befores.length) {
+                cb(err, resp);
+                return;
+            }
+
+            let handler = self.befores[index++];
+            if (typeof handler === 'function') {
+                handler(routeRecord , msg, session, next);
+            } else if (typeof handler.before === 'function') {
+                handler.before(routeRecord , msg, session, next);
+            } else {
+                logger.error('meet invalid before filter, handler or handler.before should be function.');
+                next(new Error('invalid before filter.'));
+            }
+        }; // end of next
+
+        next();
+    }
+
+    /**
+     * Do after filter chain.
+     * Give server a chance to do clean up jobs after request responsed.
+     * After filter can not change the request flow before.
+     * After filter should call the next callback to let the request pass to next after filter.
+     *
+     * @param err {Object} error object
+     * @param session {Object} session object for current request
+     * @param {Object} resp response object send to client
+     * @param cb {Function} cb(err) callback function to invoke next chain node
+     */
+    afterFilter(err: Error, routeRecord: RouteRecord , msg: any, session: FrontendOrBackendSession, resp: any, cb: HandlerCallback) {
+        let index = 0, self = this;
+        function next(err: Error) {
+            // if done
+            if (index >= self.afters.length) {
+                cb(err);
+                return;
+            }
+
+            let handler = self.afters[index++];
+            if (typeof handler === 'function') {
+                handler(err, routeRecord , msg, session, resp, next);
+            } else if (typeof handler.after === 'function') {
+                handler.after(err, routeRecord , msg, session, resp, next);
+            } else {
+                logger.error('meet invalid after filter, handler or handler.after should be function.');
+                next(new Error('invalid after filter.'));
+            }
+        } // end of next
+
+        next(err);
+    }
+}

package/lib/common/service/handlerService.ts

@@ -0,0 +1,224 @@
+import * as fs from 'fs';
+import * as utils from '../../util/utils';
+import * as Loader from '@bigtyphoon/melo-loader';
+import * as pathUtil from '../../util/pathUtil';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { Application } from '../../application';
+import { Session, FrontendSession } from './sessionService';
+import { RouteRecord, ServerInfo } from '../../util/constants';
+import { BackendSession } from './backendSessionService';
+import * as path from 'path';
+import { LoaderPathType } from '@bigtyphoon/melo-loader';
+
+let logger = getLogger('melo', path.basename(__filename));
+let forwardLogger = getLogger('forward-log', path.basename(__filename));
+
+export interface HandlerServiceOptions {
+    reloadHandlers?: boolean;
+    enableForwardLog?: boolean;
+    handlersPaths?: string[];
+}
+
+export type HandlerCallback = (err: Error, response ?: any) => void;
+export type HandlerMethod = (msg: any, session: FrontendSession | BackendSession) => Promise<any>;
+export type Handler = { [method: string]: HandlerMethod };
+export type Handlers = { [handler: string]: Handler };
+export type HandlerMap = { [serverType: string]: Handlers };
+
+/**
+ * Handler service.
+ * Dispatch request to the relactive handler.
+ *
+ * @param {Object} app      current application context
+ */
+export class HandlerService {
+    app: Application;
+    handlerMap: HandlerMap = {};
+    handlerPaths: { [serverType: string]: Set<string> } = {};
+    enableForwardLog: boolean;
+
+    constructor(app: Application, opts: HandlerServiceOptions) {
+        this.app = app;
+        if (!!opts.reloadHandlers) {
+            watchHandlers(app, this.handlerMap);
+        }
+        this.enableForwardLog = opts.enableForwardLog || false;
+
+        // 添加默认路径到ServerInfo中
+        let info = app.getCurrentServer();
+        let handlerPath = info.serverType ? pathUtil.getHandlerPath(app.getBase(), info.serverType) : undefined;
+        info.handlerPaths = [];
+        if (handlerPath) {
+            info.handlerPaths.push(handlerPath);
+        }
+
+        // 添加插件中的handler到ServerInfo中
+        for (let plugin of app.usedPlugins) {
+            if (plugin.handlerPath) {
+                info.handlerPaths.push(plugin.handlerPath);
+            }
+        }
+
+        // 添加一台服务器
+        this.addServer(info);
+    }
+
+
+    name = 'handler';
+
+    /**
+     * Handler the request.
+     */
+    handle(routeRecord: RouteRecord, msg: any, session: FrontendSession | BackendSession, cb: HandlerCallback) {
+        // the request should be processed by current server
+        let handler = this.getHandler(routeRecord);
+        if (!handler) {
+            logger.error('[handleManager]: fail to find handler for %j', routeRecord.route);
+            utils.invokeCallback(cb, new Error('fail to find handler for ' + routeRecord.route));
+            return;
+        }
+        let start = Date.now();
+        let self = this;
+
+        let callback = function (err?: any, resp?: any, opts?: any) {
+            if (self.enableForwardLog) {
+                let log = {
+                    route: routeRecord.route,
+                    args: msg,
+                    time: utils.format(new Date(start)),
+                    timeUsed: Date.now() - start
+                };
+                forwardLogger.info(JSON.stringify(log));
+            }
+
+            // resp = getResp(arguments);
+            utils.invokeCallback(cb, err, resp, opts);
+        };
+
+        let method = routeRecord.method;
+
+        if (!Array.isArray(msg)) {
+            handler[method](msg, session).then((resp) => {
+                callback(null, resp);
+            }, (reason) => {
+                callback(reason);
+            });
+        } else {
+            msg.push(session);
+            handler[method].apply(handler, msg).then((resp: any) => {
+                callback(null, resp);
+            }, (reason: any) => {
+
+                callback(reason);
+            });
+        }
+        return;
+    }
+
+    /**
+     * Get handler instance by routeRecord.
+     *
+     * @param  {Object} handlers    handler map
+     * @param  {Object} routeRecord route record parsed from route string
+     * @return {Object}             handler instance if any matchs or null for match fail
+     */
+    getHandler(routeRecord: RouteRecord) {
+        let serverType = routeRecord.serverType;
+        if (!this.handlerMap[serverType]) {
+            this.loadHandlers(serverType);
+        }
+        let handlers = this.handlerMap[serverType] || {};
+        let handler = handlers[routeRecord.handler];
+        if (!handler) {
+            logger.warn('could not find handler for routeRecord: %j', routeRecord);
+            return null;
+        }
+        if (typeof handler[routeRecord.method] !== 'function') {
+            logger.warn('could not find the method %s in handler: %s', routeRecord.method, routeRecord.handler);
+            return null;
+        }
+        return handler;
+    }
+
+    private parseHandler(serverType: string, handlerPath: string) {
+        let modules = Loader.load(handlerPath, this.app, false, true, LoaderPathType.PINUS_HANDLER) as Handlers;
+        for (let name in modules) {
+            let targetHandlers = this.handlerMap[serverType];
+            if (!targetHandlers) {
+                targetHandlers = {};
+                this.handlerMap[serverType] = targetHandlers;
+            }
+            targetHandlers[name] = modules[name];
+        }
+    }
+
+    private addServer(serverInfo: ServerInfo) {
+        let targetPaths = this.handlerPaths[serverInfo.serverType];
+        if (!targetPaths) {
+            targetPaths = new Set<string>();
+            this.handlerPaths[serverInfo.serverType] = targetPaths;
+        }
+        for (let path of serverInfo.handlerPaths) {
+            targetPaths.add(path);
+        }
+    }
+
+    /**
+     * Load handlers from current application
+     */
+    private loadHandlers(serverType: string) {
+        let paths = this.handlerPaths[serverType];
+        for (let path of paths) {
+            this.parseHandler(serverType, path);
+        }
+    }
+}
+
+export function manualReloadHandlers(app: Application) {
+    if (!app.components.__server__) {
+        return;
+    }
+    let p = pathUtil.getHandlerPath(app.getBase(), app.serverType);
+    if (!p) {
+        return;
+    }
+    const handlerMap: HandlerMap = app.components.__server__.server.handlerService.handlerMap;
+    handlerMap[app.serverType] = Loader.load(p, app, true, true, LoaderPathType.PINUS_HANDLER);
+}
+
+let watchHandlers = function (app: Application, handlerMap: HandlerMap) {
+    let p = pathUtil.getHandlerPath(app.getBase(), app.serverType);
+    if (!!p) {
+        fs.watch(p, function (event, name) {
+            if (event === 'change') {
+                handlerMap[app.serverType] = Loader.load(p, app, true, true, LoaderPathType.PINUS_HANDLER);
+            }
+        });
+    }
+};
+
+let getResp = function (args: any) {
+    let len = args.length;
+    if (len === 1) {
+        return [];
+    }
+
+    if (len === 2) {
+        return [args[1]];
+    }
+
+    if (len === 3) {
+        return [args[1], args[2]];
+    }
+
+    if (len === 4) {
+        return [args[1], args[2], args[3]];
+    }
+
+    let r = new Array(len);
+    for (let i = 1; i < len; i++) {
+        r[i] = args[i];
+    }
+
+    return r;
+};