evaengine 1.0.0 → 1.0.2

package/src/middlewares/providers.js

@@ -0,0 +1,73 @@
+import SessionMiddleware from '../middlewares/session.js';
+import AuthMiddleware from '../middlewares/auth.js';
+import AuthKongMiddleware from '../middlewares/auth_kong.js';
+import DebugMiddleware from '../middlewares/debug.js';
+import TraceMiddleware from '../middlewares/trace.js';
+import ViewCacheMiddleware from '../middlewares/view_cache.js';
+import ValidatorMiddleware from '../middlewares/validator.js';
+import DI from '../di.js';
+import { ServiceProvider } from '../services/providers.js';
+
+export class SessionMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'session';
+  }
+
+  register() {
+    DI.bindMethod(this.name, SessionMiddleware);
+  }
+}
+
+export class AuthMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'auth';
+  }
+
+  register() {
+    if (DI.get('config').get('token.provider') === 'kong') {
+      DI.bindMethod(this.name, AuthKongMiddleware);
+    } else {
+      DI.bindMethod(this.name, AuthMiddleware);
+    }
+  }
+}
+
+export class DebugMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'debug';
+  }
+
+  register() {
+    DI.bindMethod(this.name, DebugMiddleware);
+  }
+}
+
+export class ViewCacheMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'view_cache';
+  }
+
+  register() {
+    DI.bindMethod(this.name, ViewCacheMiddleware);
+  }
+}
+
+export class TraceMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'trace';
+  }
+
+  register() {
+    DI.bindMethod(this.name, TraceMiddleware);
+  }
+}
+
+export class ValidatorMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'validator';
+  }
+
+  register() {
+    DI.bindMethod(this.name, ValidatorMiddleware);
+  }
+}

package/src/middlewares/session.js

@@ -0,0 +1,58 @@
+import session from 'express-session';
+import { RedisStore } from 'connect-redis';
+import constitute from 'constitute';
+import Config from '../services/config.js';
+import Redis from '../services/redis.js';
+import Namespace from '../services/namespace.js';
+
+let middleware = null;
+
+//Fix issue https://github.com/othiym23/node-continuation-local-storage/issues/29
+const clsifyMiddleware = (fn, ns) =>
+  (req, res, next) =>
+    fn.call(this, req, res, ns.bind(next));
+
+/**
+ * @param _config {Config}
+ * @param redis {Redis}
+ * @param namespace {Namespace}
+ * @returns {function()}
+ * @constructor
+ */
+function SessionMiddleware(_config, redis, namespace) {
+  return () => {
+    if (middleware) {
+      return middleware;
+    }
+    const Store = RedisStore;
+    let store = null;
+    const config = _config.get().session;
+
+    if (config.store) {
+      const RedisClient = new Store(Object.assign({}, config.store, {
+        client: config.store.client || redis.getInstance()
+      }));
+      RedisClient.client.on('error', (err) => {
+        throw err;
+      });
+      store = RedisClient;
+    } else {
+      store = new Store(Object.assign({}, { client: redis.getInstance() }));
+    }
+
+    middleware = session({
+      store,
+      cookie: Object.assign({}, _config.get().cookie),
+      secret: config.secret,
+      resave: config.resave,
+      saveUninitialized: config.saveUninitialized
+    });
+
+    return namespace.isEnabled() ?
+      clsifyMiddleware(middleware, namespace.use().getContext()) :
+      middleware;
+  };
+}
+constitute.Dependencies(Config, Redis, Namespace)(SessionMiddleware);
+
+export default SessionMiddleware;

package/src/middlewares/trace.js

@@ -0,0 +1,229 @@
+import onHeaders from 'on-headers';
+import constitute from 'constitute';
+import { randomString, getHostFullUrl, getHostPort, getHostIp, getMicroTimestamp } from '../utils/index.js';
+import Namespace from '../services/namespace.js';
+import Config from '../services/config.js';
+import Logger from '../services/logger.js';
+import HttpClient from '../services/http_client.js';
+
+const hostIp = getHostIp();
+
+export const tracerToZipkins = (tracer) => {
+  if (!tracer) {
+    return false;
+  }
+  const {
+    url,
+    method,
+    serviceName,
+    spanId: id,
+    traceId,
+    parentId,
+    timestamp,
+    duration,
+    statusCode,
+    port,
+    queries
+  } = tracer;
+
+  const name = `${statusCode} ${method} ${url}`;
+  const endpoint = {
+    serviceName,
+    ipv4: hostIp,
+    port
+  };
+  const zipkin = {
+    id,
+    traceId,
+    name,
+    timestamp,
+    duration,
+    annotations: [
+      {
+        endpoint,
+        timestamp,
+        value: 'sr'
+      },
+      {
+        endpoint,
+        timestamp: timestamp + duration,
+        value: 'ss'
+      }
+    ],
+    binaryAnnotations: [
+      {
+        key: 'traceId',
+        value: traceId
+      },
+      {
+        key: 'spanId',
+        value: id
+      },
+      {
+        key: 'method',
+        value: method
+      },
+      {
+        key: 'url',
+        value: url
+      },
+      {
+        key: 'port',
+        value: port.toString()
+      },
+      {
+        key: 'statusCode',
+        value: statusCode.toString()
+      }
+    ]
+  };
+
+  if (parentId) {
+    zipkin.parentId = parentId;
+  }
+
+  const zipkins = [zipkin];
+  if (queries && queries.length > 0) {
+    queries.forEach((element) => {
+      const { query, cost, finishedAt } = element;
+      zipkins.push({
+        id: randomString(),
+        parentId: id,
+        traceId,
+        name: 'sequelize',
+        timestamp: finishedAt - cost,
+        duration: cost,
+        annotations: [
+          {
+            endpoint,
+            timestamp: finishedAt - cost,
+            value: 'cs'
+          },
+          {
+            endpoint,
+            timestamp: finishedAt,
+            value: 'cr'
+          }
+        ],
+        binaryAnnotations: [{
+          key: 'query',
+          value: query
+        }]
+      });
+    });
+  }
+  return zipkins;
+};
+
+
+function TraceMiddleware(ns, config, logger, client) {
+  const enabled = config.get('trace.enable');
+  return name => (req, res, next) => {
+    const spanId = randomString();
+    const traceId = req.get('X-B3-TraceId') || spanId;
+    const parentId = req.get('X-B3-SpanId') || '';
+    const startedAt = process.hrtime();
+    const timestamp = getMicroTimestamp();
+    const serviceName = name || config.get('app.name');
+    //目前默认全部采样
+    let sampled = enabled ? 1 : 0;
+    //只有service为第二级, 且通过参数关闭时才禁止采样
+    if (sampled && parseInt(req.get('X-B3-Sampled'), 10) < 1 && parentId > 0) {
+      sampled = 0;
+    }
+    const tracer = {
+      serviceName,
+      method: req.method,
+      url: getHostFullUrl(req),
+      port: getHostPort(req),
+      spanId,
+      traceId,
+      parentId,
+      sampled,
+      timestamp,
+      duration: null,
+      statusCode: null,
+      queries: [],
+      debug: {}
+    };
+
+    res.set({
+      'X-Service-Name': serviceName,
+      'X-Requested-At': timestamp,
+      'X-B3-SpanId': spanId,
+      'X-B3-TraceId': traceId,
+      'X-B3-ParentSpanId': parentId,
+      'X-B3-Sampled': sampled
+    });
+
+    if (sampled < 1) {
+      onHeaders(res, () => {
+        const [seconds, nanoseconds] = process.hrtime(startedAt);
+        const duration = ((seconds * 1e3) + (nanoseconds * 1e-6));
+        res.set('X-Response-Milliseconds', parseInt(duration, 10));
+      });
+      next();
+      return;
+    }
+
+    onHeaders(res, () => {
+      const [seconds, nanoseconds] = process.hrtime(startedAt);
+      const duration = ((seconds * 1e3) + (nanoseconds * 1e-6)) * 1000;
+      tracer.duration = parseInt(duration, 10);
+      tracer.statusCode = res.statusCode;
+      res.set('X-Response-Milliseconds', tracer.duration / 1000);
+
+      const useHeader = config.get('trace.header');
+      if (!useHeader) {
+        return;
+      }
+      const zipkins = tracerToZipkins(tracer);
+      if (!zipkins) {
+        logger.warn('Tracer not send by no data for request %s', spanId);
+      } else {
+        res.set(`X-Debug-${spanId}`, JSON.stringify(zipkins));
+      }
+
+      if (Object.keys(tracer.debug).length > 0) {
+        Object.entries(tracer.debug).forEach(([key, value]) => {
+          res.set(key.replace('x-debug', 'X-Debug'), value);
+        });
+      }
+    });
+
+    const recordZipkin = () => {
+      const api = config.get('trace.api');
+      if (!api) {
+        return;
+      }
+      logger.debug('Tracer prepare to send for request %s', spanId);
+      const zipkins = tracerToZipkins(ns.get('tracer'));
+      if (!zipkins) {
+        logger.warn('Tracer not send by no data for request %s', spanId);
+        return;
+      }
+      client.request({
+        url: api,
+        method: 'POST',
+        json: zipkins
+      }).catch((e) => {
+        logger.error('Error happened on sending tracing data', e);
+      });
+    };
+
+    res.on('finish', recordZipkin);
+    res.on('error', recordZipkin);
+
+    ns.bindEmitter(req);
+    ns.bindEmitter(res);
+    ns.run(() => {
+      // logger.debug('Tracer settled for request %s, tracer: %j', spanId, tracer);
+      ns.set('tracer', tracer);
+      next();
+    });
+  };
+}
+
+constitute.Dependencies(Namespace, Config, Logger, HttpClient)(TraceMiddleware);
+
+export default TraceMiddleware;

package/src/middlewares/validator.js

@@ -0,0 +1,50 @@
+import Joi from 'joi';
+import constitute from 'constitute';
+import wrapper from '../utils/wrapper.js';
+import { FormInvalidateException } from '../exceptions/index.js';
+import ValidatorBase from '../services/joi.js';
+
+const validate = (data, schema, options) => {
+  const validationOptions = Object.assign(
+    { abortEarly: false, allowUnknown: true },
+    options
+  );
+  if (schema && typeof schema.validateAsync === 'function') {
+    return schema.validateAsync(data, validationOptions);
+  }
+  return new Promise((resolve, reject) => {
+    Joi.validate(data, schema, validationOptions, (err, value) => {
+      if (err) reject(err);
+      else resolve(value);
+    });
+  });
+};
+
+/**
+ * @returns {function()}
+ * @constructor
+ */
+function ValidatorMiddleware(validatorBase) {
+  return (getSchema, options, validator) =>
+    wrapper(async (req, res, next) => {
+      const { query, body, path } = getSchema(validator || validatorBase.getJoi());
+      try {
+        if (query) {
+          await validate(req.query, query, options);
+        }
+        if (body) {
+          await validate(req.body, body, options);
+        }
+        if (path) {
+          await validate(req.params, path, options);
+        }
+        return next();
+      } catch (e) {
+        throw new FormInvalidateException(e);
+      }
+    });
+}
+
+constitute.Dependencies(ValidatorBase)(ValidatorMiddleware);
+
+export default ValidatorMiddleware;

package/src/middlewares/view_cache.js

@@ -0,0 +1,126 @@
+import constitute from 'constitute';
+import crypto from 'crypto';
+import moment from 'moment-timezone';
+import Logger from '../services/logger.js';
+import Cache from '../services/cache.js';
+import wrapper from '../utils/wrapper.js';
+import { RuntimeException } from '../exceptions/index.js';
+
+export const defaultHashStrategy = obj => obj;
+
+export const defaultHeadersFilter = (res) => {
+  const headers = [];
+  ['Content-Type'].forEach((key) => {
+    const value = res.get(key);
+    if (value) {
+      headers.push([key, value]);
+    }
+  });
+  return headers;
+};
+
+export const requestToCacheKey = (req, hashStrategy) => {
+  const {
+    method,
+    originalUrl,
+    query: originQuery,
+    route,
+    uid = null //Custom rule
+  } = req;
+  const query = { ...originQuery };
+  delete query.flush;
+  if (hashStrategy && typeof hashStrategy !== 'function') {
+    throw new RuntimeException(`View cache hash strategy must be a function for ${originalUrl}`);
+  }
+  if (!route) {
+    throw new RuntimeException(`View cache middleware require route for ${originalUrl}`);
+  }
+  if (method.toLowerCase() !== 'get') {
+    throw new RuntimeException(`View cache middleware only support GET method of http request for ${originalUrl}`);
+  }
+  const { host = 'unknown' } = req.headers;
+  const [urlPath = ''] = originalUrl.split('?');
+  const key = [method, `/${host}`, urlPath].join('').replace(/:/g, '_').toLowerCase();
+  const strategy = hashStrategy || defaultHashStrategy;
+  const hash = crypto
+    .createHash('md5')
+    .update(JSON
+      .stringify(strategy({
+        method,
+        urlPath,
+        query,
+        uid
+      })))
+    .digest('hex');
+  return [key, hash].join(':');
+};
+
+
+/**
+ * @param {Cache} cache
+ * @param {Logger} logger
+ * @returns {function(*=)}
+ * @constructor
+ */
+function ViewCacheMiddleware(cache, logger) {
+  return (options = {}) => {
+    if (options === null || typeof options !== 'object') {
+      options = {
+        ttl: options
+      };
+    }
+    const {
+      ttl,
+      headersFilter,
+      namespace,
+      hashStrategy
+    } = Object.assign({
+      ttl: 60,
+      headersFilter: defaultHeadersFilter,
+      hashStrategy: defaultHashStrategy,
+      namespace: 'view'
+    }, options);
+    return wrapper(async (req, res, next) => {
+      const cacheKey = requestToCacheKey(req, hashStrategy);
+      const {
+        headers: cachedHeaders = [],
+        body: cachedBody
+      } = await cache.namespace(namespace).get(cacheKey)
+      || {
+        headers: [],
+        body: null
+      };
+      if (req.query.flush !== 'true' && cachedBody) {
+        logger.debug('View cache hit by key %s', cacheKey);
+        if (cachedHeaders.length > 0) {
+          cachedHeaders.forEach(([key, value]) => {
+            res.setHeader(key, value);
+          });
+        }
+        res.setHeader('X-View-Cache-Hit', cacheKey);
+        res.send(cachedBody);
+        return;
+      }
+      res.realSend = res.send;
+      res.send = (body) => {
+        logger.debug('View cache missed by key %s, creating...', cacheKey);
+        res.setHeader('X-View-Cache-Miss', cacheKey);
+        res.setHeader('X-View-Cache-Expire-At', moment().add(ttl, 'minute').format('YYYY-MM-DD HH:mm:ss Z'));
+        res.setHeader('X-View-Cache-Created-At', moment().format('YYYY-MM-DD HH:mm:ss Z'));
+        res.realSend(body);
+        const headers = headersFilter && typeof headersFilter === 'function' ?
+          headersFilter(res) : defaultHeadersFilter(res);
+        if (res.statusCode <= 500) {
+          cache.namespace(namespace).set(cacheKey, { headers, body }, ttl).catch((e) => {
+            logger.error('View cache set failed for %s', cacheKey, e);
+          });
+        }
+      };
+      next();
+    });
+  };
+}
+
+constitute.Dependencies(Cache, Logger)(ViewCacheMiddleware);
+
+export default ViewCacheMiddleware;