no message

build/adapter/fast.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.add = add;
+exports.act = act;
+const _ = require("lodash");
+const path = require("path");
+const rp = require("request-promise");
+const fastify = require("fastify");
+const common_1 = require("../common");
+const log_1 = require("../log");
+const service_1 = require("../service");
+let logger;
+const api = {};
+const fast = fastify({ trustProxy: true });
+let targetPort = 0;
+function init(cfg, callback) {
+    logger = new log_1.Log(`msbase_fastify`);
+    if (cfg.targetPort)
+        targetPort = cfg.targetPort;
+    const start = () => {
+        if (!cfg.port)
+            return;
+        try {
+            _.forEach(cfg.apipath ? cfg.apipath : ['./build/services/'], common_1.requiredir);
+        }
+        catch (error) {
+            logger.log(error.message);
+        }
+        logger.log('api initialized');
+        let circuitBreakerOpt = { threshold: 3, timeout: 3000, resetTimeout: 3000 };
+        if (cfg.circuitBreaker)
+            circuitBreakerOpt = { ...circuitBreakerOpt, ...cfg.circuitBreaker };
+        fast.register(require('fastify-circuit-breaker'), circuitBreakerOpt);
+        fast.register(require('fastify-compress'), { global: false });
+        try {
+            const route = cfg.routefile ? require(path.resolve(cfg.routefile)) : null;
+            if (route)
+                route(fast);
+        }
+        catch (error) {
+            logger.log(error.message);
+        }
+        _.keys(api).length > 0 && fast.register(function (instance, opts, next) {
+            instance.route({
+                method: 'POST',
+                url: '/:cmd/',
+                handler: async (request, reply) => {
+                    let payload = {};
+                    const start = Date.now();
+                    const name = request.params.cmd.toLowerCase();
+                    const bodyJson = JSON.stringify(request.body);
+                    logger.debug(`1-api-${name} args-${bodyJson}`, { method_name: name });
+                    try {
+                        const action = api[name];
+                        if (!action)
+                            throw new Error(`${name} does not exist in ${cfg.name}`);
+                        payload.result = await action(request.body);
+                    }
+                    catch (error) {
+                        payload.error = error.message;
+                    }
+                    const hs = Date.now() - start;
+                    let spend_time = Math.floor(hs / 50);
+                    if (spend_time > 99)
+                        spend_time = 99;
+                    logger.debug(`2-api-${name} args-${bodyJson} result-${JSON.stringify(payload)} 耗时-${hs}`, { method_name: name, spend_time: spend_time });
+                    reply.compress(payload);
+                }
+            });
+            console.log('start ms api route');
+            next();
+        });
+        fast.listen(cfg.port, '0.0.0.0', (err, address) => {
+            if (err)
+                throw err;
+            logger.info(`server listening on ${address}`);
+        });
+    };
+    callback ? callback(start) : start();
+}
+function add(args, callback) {
+    api[args.cmd] = callback;
+    console.log(`api '${args.cmd}' success`);
+}
+async function act(args, isThrowError = false) {
+    if (!args.topic || !args.cmd)
+        throw new Error('topic or cmd is null');
+    if (args.topic)
+        args.topic = args.topic.toLowerCase();
+    if (args.cmd)
+        args.cmd = args.cmd.toLowerCase();
+    const args_obj = _.pick(args, ['data', 'context']);
+    const body = JSON.stringify(args_obj);
+    if (args.topic === service_1.config.name)
+        return api[args.cmd]({ ...args_obj });
+    const url = `http://service-${args.topic}${targetPort ? (':' + targetPort) : ''}/${args.cmd}/`;
+    const start = Date.now();
+    let ret = await rp.post(url, { body, gzip: true, forever: true, headers: { 'Content-Type': 'application/json' } })
+        .then(body => JSON.parse(body))
+        .catch(e => { return { error: e.message }; });
+    const hs = Date.now() - start;
+    let spend_time = Math.floor(hs / 50);
+    if (spend_time > 99)
+        spend_time = 99;
+    const msg = `act--${url}|${body}|${JSON.stringify(ret)}|${hs}`;
+    const opts = { method_name: args.cmd, spend_time: spend_time };
+    logger.debug(msg, opts);
+    if (ret) {
+        if ('error' in ret) {
+            logger.error(msg, opts);
+            if (isThrowError)
+                throw new Error(ret.error);
+        }
+        if ('result' in ret) {
+            ret = ret.result;
+        }
+    }
+    return ret;
+}
+//# sourceMappingURL=fast.js.map
\ No newline at end of file

build/adapter/hemera.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.act = act;
+const nats_1 = require("nats");
+const Hemera = require('nats-hemera');
+let hemera;
+let logger;
+function init(cfg) {
+    logger = console;
+    hemera = new Hemera((0, nats_1.connect)(cfg.nats), {
+        ...cfg.hemera
+    });
+    logger.info('msbase hemera log init success');
+    try {
+        const HemeraZipkin = require('hemera-zipkin');
+        hemera.use(HemeraZipkin, {
+            host: process.env.ZIPKIN_URL,
+            port: process.env.ZIPKIN_PORT,
+            sampling: 1
+        });
+    }
+    catch (e) {
+        logger.info('zipkin未配置: ');
+    }
+    hemera.ready(async () => {
+        logger.log('hemera initialized');
+    });
+    return hemera;
+}
+async function act(args, isThrowError = false) {
+    const starttime = Date.now();
+    let localfn = hemera.router.lookup(args);
+    if (localfn)
+        localfn = localfn.action;
+    if (!args.context)
+        args.context = {};
+    let ret = await (localfn ?
+        localfn(args)
+        : hemera.act(args)).catch((error) => ({ error: error.message, code: 1001 }));
+    if (ret && ret.context)
+        ret = ret.data;
+    if (ret && ret.error)
+        logger.error(ret.error);
+    if (isThrowError && ret && ret.error)
+        throw new Error(ret.error);
+    const total = Date.now() - starttime;
+    if (total > 200) {
+        logger.log(`${JSON.stringify(args)} 调用时间耗时:${total}毫秒 `);
+    }
+    return ret;
+}
+//# sourceMappingURL=hemera.js.map
\ No newline at end of file

build/adapter/index.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.add = add;
+exports.act = act;
+var adapter = require('./hemera');
+var config = {};
+function init(cfg, callback) {
+    switch (cfg.type) {
+        case 'fast':
+            adapter = require('./fast');
+            break;
+        default:
+            adapter = require('./hemera');
+            break;
+    }
+    config = cfg;
+    adapter.init(cfg, callback);
+}
+function add(args, callback) {
+    if (adapter) {
+        adapter.add(ckArgs(args), callback);
+    }
+}
+async function act(args, isThrowError = false) {
+    return adapter.act(ckArgs(args), isThrowError);
+}
+function ckArgs(args) {
+    if (!args)
+        return;
+    if (!args.topic)
+        args.topic = config.name;
+    if (args.topic)
+        args.topic = args.topic.toLowerCase();
+    if (args.cmd)
+        args.cmd = args.cmd.toLowerCase();
+    return args;
+}
+//# sourceMappingURL=index.js.map
\ No newline at end of file

build/hemera.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.act = act;
+const nats_1 = require("nats");
+const Hemera = require('nats-hemera');
+let hemera;
+let logger;
+function init(cfg) {
+    logger = console;
+    hemera = new Hemera((0, nats_1.connect)(cfg.nats), {
+        ...cfg.hemera
+    });
+    logger.info('msbase hemera log init success');
+    try {
+        const HemeraZipkin = require('hemera-zipkin');
+        hemera.use(HemeraZipkin, {
+            host: process.env.ZIPKIN_URL,
+            port: process.env.ZIPKIN_PORT,
+            sampling: 1
+        });
+    }
+    catch (e) {
+        logger.info('zipkin未配置: ');
+    }
+    hemera.ready(async () => {
+        logger.log('hemera initialized');
+    });
+    return hemera;
+}
+async function act(args, isThrowError = false) {
+    const starttime = Date.now();
+    let localfn = hemera.router.lookup(args);
+    if (localfn)
+        localfn = localfn.action;
+    if (!args.context)
+        args.context = {};
+    let ret = await (localfn ?
+        localfn(args)
+        : hemera.act(args)).catch((error) => ({ error: error.message, code: 1001 }));
+    if (ret && ret.context)
+        ret = ret.data;
+    if (ret && ret.error)
+        logger.error(ret.error);
+    if (isThrowError && ret && ret.error)
+        throw new Error(ret.error);
+    const total = Date.now() - starttime;
+    if (total > 200) {
+        logger.log(`${JSON.stringify(args)} 调用时间耗时:${total}毫秒 `);
+    }
+    return ret;
+}
+//# sourceMappingURL=hemera.js.map
\ No newline at end of file

src/adapter/fast.js

+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.act = exports.add = exports.init = void 0;
+const _ = require("lodash");
+const path = require("path");
+const rp = require("request-promise");
+const fastify = require("fastify");
+const common_1 = require("../common");
+const log_1 = require("../log");
+const service_1 = require("../service");
+let logger;
+const api = {};
+const fast = fastify({ trustProxy: true });
+let targetPort = 0;
+function init(cfg, callback) {
+    logger = new log_1.Log(`msbase_fastify`);
+    if (cfg.targetPort)
+        targetPort = cfg.targetPort;
+    const start = () => {
+        if (!cfg.port)
+            return;
+        try {
+            _.forEach(cfg.apipath ? cfg.apipath : ['./build/services/'], common_1.requiredir);
+        }
+        catch (error) {
+            logger.log(error.message);
+        }
+        logger.log('api initialized');
+        // 路由 及 熔断   
+        let circuitBreakerOpt = { threshold: 3, timeout: 3000, resetTimeout: 3000 };
+        if (cfg.circuitBreaker)
+            circuitBreakerOpt = Object.assign(Object.assign({}, circuitBreakerOpt), cfg.circuitBreaker);
+        fast.register(require('fastify-circuit-breaker'), circuitBreakerOpt);
+        // 压缩
+        fast.register(require('fastify-compress'), { global: false });
+        try {
+            const route = cfg.routefile ? require(path.resolve(cfg.routefile)) : null;
+            if (route)
+                route(fast);
+        }
+        catch (error) {
+            logger.log(error.message);
+        }
+        _.keys(api).length > 0 && fast.register(function (instance, opts, next) {
+            instance.route({
+                method: 'POST',
+                url: '/:cmd/',
+                // beforeHandler: instance.circuitBreaker(),
+                handler: (request, reply) => __awaiter(this, void 0, void 0, function* () {
+                    let payload = {};
+                    const start = Date.now();
+                    const name = request.params.cmd.toLowerCase();
+                    const bodyJson = JSON.stringify(request.body);
+                    logger.debug(`1-api-${name} args-${bodyJson}`, { method_name: name });
+                    try {
+                        const action = api[name];
+                        if (!action)
+                            throw new Error(`${name} does not exist in ${cfg.name}`);
+                        payload.result = yield action(request.body);
+                    }
+                    catch (error) {
+                        payload.error = error.message;
+                    }
+                    const hs = Date.now() - start;
+                    let spend_time = Math.floor(hs / 50);
+                    if (spend_time > 99)
+                        spend_time = 99;
+                    logger.debug(`2-api-${name} args-${bodyJson} result-${JSON.stringify(payload)} 耗时-${hs}`, { method_name: name, spend_time: spend_time });
+                    // reply.send(payload)
+                    reply.compress(payload);
+                })
+            });
+            console.log('start ms api route');
+            next();
+        });
+        fast.listen(cfg.port, '0.0.0.0', (err, address) => {
+            if (err)
+                throw err;
+            logger.info(`server listening on ${address}`);
+        });
+    };
+    callback ? callback(start) : start();
+}
+exports.init = init;
+function add(args, callback) {
+    api[args.cmd] = callback;
+    console.log(`api '${args.cmd}' success`);
+}
+exports.add = add;
+function act(args, isThrowError = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!args.topic || !args.cmd)
+            throw new Error('topic or cmd is null');
+        if (args.topic)
+            args.topic = args.topic.toLowerCase();
+        if (args.cmd)
+            args.cmd = args.cmd.toLowerCase();
+        const args_obj = _.pick(args, ['data', 'context']);
+        const body = JSON.stringify(args_obj);
+        if (args.topic === service_1.config.name)
+            return api[args.cmd](Object.assign({}, args_obj));
+        const url = `http://service-${args.topic}${targetPort ? (':' + targetPort) : ''}/${args.cmd}/`;
+        const start = Date.now();
+        let ret = yield rp.post(url, { body, gzip: true, forever: true, headers: { 'Content-Type': 'application/json' } })
+            .then(body => JSON.parse(body))
+            .catch(e => { return { error: e.message }; });
+        const hs = Date.now() - start;
+        let spend_time = Math.floor(hs / 50);
+        if (spend_time > 99)
+            spend_time = 99;
+        const msg = `act--${url}|${body}|${JSON.stringify(ret)}|${hs}`;
+        const opts = { method_name: args.cmd, spend_time: spend_time };
+        logger.debug(msg, opts);
+        if (ret) {
+            if ('error' in ret) {
+                logger.error(msg, opts);
+                if (isThrowError)
+                    throw new Error(ret.error);
+            }
+            if ('result' in ret) {
+                ret = ret.result;
+            }
+        }
+        return ret;
+    });
+}
+exports.act = act;
+//# sourceMappingURL=fast.js.map
\ No newline at end of file

src/adapter/fast.ts

+import _ = require('lodash')
+import * as path from 'path'
+import * as rp from 'request-promise'
+import * as fastify from 'fastify'
+import { requiredir } from '../common'
+import { Log } from '../log'
+import { config } from '../service';
+
+let logger: Log
+const api = {}
+const fast = fastify({ trustProxy: true })
+let targetPort = 0
+
+export function init(cfg: any, callback?: Function) {
+    logger = new Log(`msbase_fastify`)
+
+    if (cfg.targetPort) targetPort = cfg.targetPort
+
+    const start = () => {
+        if (!cfg.port) return
+
+        try {
+            _.forEach(cfg.apipath ? cfg.apipath : ['./build/services/'], requiredir)
+        } catch (error) { logger.log(error.message); }
+        logger.log('api initialized');
+
+        // 路由 及 熔断   
+        let circuitBreakerOpt = { threshold: 3, timeout: 3000, resetTimeout: 3000 }
+        if (cfg.circuitBreaker) circuitBreakerOpt = { ...circuitBreakerOpt, ...cfg.circuitBreaker }
+        fast.register(require('fastify-circuit-breaker'), circuitBreakerOpt)
+        // 压缩
+        fast.register(require('fastify-compress'), { global: false });
+
+        try {
+            const route = cfg.routefile ? require(path.resolve(cfg.routefile)) : null;
+            if (route) route(fast)
+        } catch (error) { logger.log(error.message); }
+        _.keys(api).length > 0 && fast.register(function (instance: any, opts, next) {
+            instance.route({
+                method: 'POST',
+                url: '/:cmd/',
+                // beforeHandler: instance.circuitBreaker(),
+                handler: async (request, reply) => {
+                    let payload: any = {}
+
+                    const start = Date.now()
+                    const name = request.params.cmd.toLowerCase()
+                    const bodyJson = JSON.stringify(request.body)
+
+                    logger.debug(`1-api-${name} args-${bodyJson}`, { method_name: name })
+                    try {
+                        const action = api[name]
+                        if (!action) throw new Error(`${name} does not exist in ${cfg.name}`)
+                        payload.result = await action(request.body);
+                    } catch (error) {
+                        payload.error = error.message
+                    }
+
+                    const hs = Date.now() - start
+                    let spend_time = Math.floor(hs / 50)
+                    if (spend_time > 99) spend_time = 99
+                    logger.debug(`2-api-${name} args-${bodyJson} result-${JSON.stringify(payload)} 耗时-${hs}`, { method_name: name, spend_time: spend_time })
+
+                    // reply.send(payload)
+                    reply.compress(payload)
+                }
+            })
+            console.log('start ms api route')
+            next()
+        });
+
+        fast.listen(cfg.port, '0.0.0.0', (err, address) => {
+            if (err) throw err
+            logger.info(`server listening on ${address}`)
+        })
+    }
+
+    callback ? callback(start) : start()
+}
+
+interface Pattern {
+    pubsub$?: boolean
+    timeout$?: number
+    maxMessages$?: number
+    expectedMessages$?: number
+    [key: string]: any
+}
+
+export function add(args: Pattern, callback: Function) {
+    api[args.cmd] = callback
+    console.log(`api '${args.cmd}' success`)
+}
+
+export async function act(args: Pattern, isThrowError = false) {
+    if (!args.topic || !args.cmd) throw new Error('topic or cmd is null')
+    if (args.topic) args.topic = args.topic.toLowerCase()
+    if (args.cmd) args.cmd = args.cmd.toLowerCase()
+
+    const args_obj = _.pick(args, ['data', 'context']);
+    const body = JSON.stringify(args_obj)
+
+    if (args.topic === config.name) return api[args.cmd]({ ...args_obj });
+    const url = `http://service-${args.topic}${targetPort ? (':' + targetPort) : ''}/${args.cmd}/`
+
+    const start = Date.now()
+    let ret: any = await rp.post(url, { body, gzip: true, forever: true, headers: { 'Content-Type': 'application/json' } })
+        .then(body => JSON.parse(body))
+        .catch(e => { return { error: e.message } })
+
+    const hs = Date.now() - start
+    let spend_time = Math.floor(hs / 50)
+    if (spend_time > 99) spend_time = 99
+
+    const msg = `act--${url}|${body}|${JSON.stringify(ret)}|${hs}`
+    const opts = { method_name: args.cmd, spend_time: spend_time }
+    logger.debug(msg, opts)
+
+    if (ret) {
+        if ('error' in ret) {
+            logger.error(msg, opts)
+            if (isThrowError) throw new Error(ret.error)
+        }
+
+        if ('result' in ret) {
+            ret = ret.result
+        }
+    }
+
+    return ret;
+}

src/adapter/hemera.js

+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.act = exports.add = exports.init = void 0;
+const fs = require("fs");
+const _ = require("lodash");
+const nats_1 = require("nats");
+const path = require("path");
+const Hemera = require('nats-hemera');
+let hemera;
+let logger;
+function init(cfg, callback) {
+    logger = cfg.log ? new cfg.log(`${cfg.name}/hemera`) : console;
+    hemera = new Hemera((0, nats_1.connect)(cfg.nats), Object.assign({}, cfg.hemera));
+    logger.info('msbase hemera log init success');
+    try {
+        const HemeraZipkin = require('hemera-zipkin');
+        hemera.use(HemeraZipkin, {
+            host: process.env.ZIPKIN_URL,
+            port: process.env.ZIPKIN_PORT,
+            sampling: 1
+        });
+    }
+    catch (e) {
+        logger.info('zipkin未配置: ');
+    }
+    hemera.ready(() => __awaiter(this, void 0, void 0, function* () {
+        logger.log('hemera initialized');
+        callback(() => {
+            try {
+                _.forEach(cfg.apipath ? cfg.apipath : ['./build/services/'], requirefile);
+            }
+            catch (error) {
+                logger.log(error.message);
+            }
+            logger.log('api initialized');
+        });
+    }));
+    return hemera;
+}
+exports.init = init;
+function requirefile(dir) {
+    fs.readdirSync(dir).forEach((file) => {
+        try {
+            console.info(`初始化微服务,扫描文件 ${path.resolve(dir + file)}`);
+            if (file.substr(-3) === '.js' && require(path.resolve(dir + file)))
+                return;
+            if (file.indexOf('.') === -1)
+                requirefile(`${dir}${file}/`);
+        }
+        catch (e) {
+            console.info(`微服务初始化异常 ${dir} ${file}`, e);
+        }
+    });
+}
+function add(args, callback) {
+    if (hemera) {
+        hemera.add(args, (req) => __awaiter(this, void 0, void 0, function* () { return callback(req).catch(e => { return { error: e.message }; }); }));
+        // hemera.add(args, async (req, cb) => {
+        //     const ret = await callback(req);
+        //     cb(null, ret);
+        // });
+    }
+}
+exports.add = add;
+function act(args, isThrowError = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const starttime = Date.now();
+        let localfn = hemera.router.lookup(args);
+        if (localfn)
+            localfn = localfn.action;
+        if (!args.context)
+            args.context = {};
+        let ret = yield (localfn ?
+            localfn(args)
+            : hemera.act(args)).catch((error) => ({ error: error.message, code: 1001 }));
+        if (ret && ret.context)
+            ret = ret.data;
+        if (ret && ret.error)
+            logger.error(ret.error);
+        if (isThrowError && ret && ret.error)
+            throw new Error(ret.error);
+        const total = Date.now() - starttime;
+        if (total > 200) {
+            // logger.log(`${JSON.stringify(args)} 调用时间耗时:${total}毫秒 ${JSON.stringify(ret)}`);
+            logger.log(`${JSON.stringify(args)} 调用时间耗时:${total}毫秒 `);
+        }
+        return ret;
+    });
+}
+exports.act = act;
+//# sourceMappingURL=hemera.js.map
\ No newline at end of file

src/adapter/index.js

+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.act = exports.add = exports.init = void 0;
+var adapter = require('./hemera');
+var config = {};
+function init(cfg, callback) {
+    switch (cfg.type) {
+        case 'fast':
+            adapter = require('./fast');
+            break;
+        default:
+            adapter = require('./hemera');
+            break;
+    }
+    config = cfg;
+    adapter.init(cfg, callback);
+}
+exports.init = init;
+function add(args, callback) {
+    if (adapter) {
+        adapter.add(ckArgs(args), callback);
+    }
+}
+exports.add = add;
+function act(args, isThrowError = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return adapter.act(ckArgs(args), isThrowError);
+    });
+}
+exports.act = act;
+function ckArgs(args) {
+    if (!args)
+        return;
+    if (!args.topic)
+        args.topic = config.name;
+    //if (!args.topic || !args.cmd) throw new Error('topic and cmd is null')
+    if (args.topic)
+        args.topic = args.topic.toLowerCase();
+    if (args.cmd)
+        args.cmd = args.cmd.toLowerCase();
+    return args;
+}
+//# sourceMappingURL=index.js.map
\ No newline at end of file

src/adapter/index.ts

+var adapter: any = require('./hemera')
+var config: any = {}
+export function init(cfg: any, callback?: Function) {
+    switch (cfg.type) {
+        case 'fast':
+            adapter = require('./fast')
+            break;
+        default:
+            adapter = require('./hemera')
+            break;
+    }
+    config = cfg
+    adapter.init(cfg, callback)
+}
+
+interface Pattern {
+    pubsub$?: boolean
+    timeout$?: number
+    maxMessages$?: number
+    expectedMessages$?: number
+    [key: string]: any
+}
+
+export function add(args: Pattern, callback: Function) {
+    if (adapter) {
+        adapter.add(ckArgs(args), callback)
+    }
+}
+
+export async function act(args: Pattern, isThrowError = false) {
+    return adapter.act(ckArgs(args), isThrowError)
+}
+
+function ckArgs(args: Pattern) {
+    if (!args) return;
+    if (!args.topic) args.topic = config.name
+    //if (!args.topic || !args.cmd) throw new Error('topic and cmd is null')
+    if (args.topic) args.topic = args.topic.toLowerCase()
+    if (args.cmd) args.cmd = args.cmd.toLowerCase()
+    return args
+}

src/hemera.ts

+import * as fs from 'fs';
+import _ = require('lodash');
+import { connect } from 'nats';
+import * as path from 'path';
+const Hemera = require('nats-hemera');
+
+let hemera;
+let logger;
+
+export function init(cfg: any) {
+    logger = console
+
+    hemera = new Hemera(connect(cfg.nats), {
+        ...cfg.hemera
+    });
+    logger.info('msbase hemera log init success');
+
+    try {
+        const HemeraZipkin = require('hemera-zipkin')
+        hemera.use(HemeraZipkin, {
+            host: process.env.ZIPKIN_URL,
+            port: process.env.ZIPKIN_PORT,
+            sampling: 1
+        })
+    } catch (e) {
+        logger.info('zipkin未配置: ');
+    }
+
+    hemera.ready(async () => {
+        logger.log('hemera initialized');
+    });
+    return hemera;
+}
+
+interface Pattern {
+    pubsub$?: boolean
+    timeout$?: number
+    maxMessages$?: number
+    expectedMessages$?: number
+    [key: string]: any
+}
+
+
+export async function act(args: Pattern, isThrowError = false) {
+    const starttime = Date.now();
+
+    let localfn = hemera.router.lookup(args);
+    if (localfn) localfn = localfn.action;
+    if (!args.context) args.context = {};
+
+    let ret = await (localfn ?
+        localfn(args)
+        : hemera.act(args)).catch((error) => ({ error: error.message, code: 1001 }));
+
+    if (ret && ret.context) ret = ret.data;
+
+    if (ret && ret.error) logger.error(ret.error);
+
+    if (isThrowError && ret && ret.error) throw new Error(ret.error);
+
+    const total = Date.now() - starttime;
+    if (total > 200) {
+        // logger.log(`${JSON.stringify(args)} 调用时间耗时:${total}毫秒 ${JSON.stringify(ret)}`);
+        logger.log(`${JSON.stringify(args)} 调用时间耗时:${total}毫秒 `);
+    }
+
+    return ret;
+}
\ No newline at end of file