@yhiot/logger/lib/backend/redis.js

物联网日志队列读写系统,后端目前支持redis

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = createRedis;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _redis = _interopRequireDefault(require("redis"));

var _bluebird = _interopRequireDefault(require("bluebird"));

var _console = _interopRequireDefault(require("console"));

_bluebird.default.promisifyAll(_redis.default);

var DEFAULT_KEY = 'logger';
var DEFAULT_TIMEOUT = 1; // 单位为秒

function createRedis(url) {
  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_KEY;
  var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_TIMEOUT;

  var $r = _redis.default.createClient(url);

  function send(_x, _x2, _x3, _x4) {
    return _send.apply(this, arguments);
  }

  function _send() {
    _send = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(module, event, data, createdAt) {
      var needSend, result;
      return _regenerator.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              needSend = JSON.stringify({
                module: module,
                event: event,
                data: data,
                createdAt: createdAt
              });
              _context.next = 3;
              return $r.LPUSHAsync(key, needSend);

            case 3:
              result = _context.sent;
              return _context.abrupt("return", result);

            case 5:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));
    return _send.apply(this, arguments);
  }

  function _receive(_x5, _x6) {
    return _receive2.apply(this, arguments);
  }

  function _receive2() {
    _receive2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(key, timeout) {
      var data, result;
      return _regenerator.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              data = null;
              _context2.next = 3;
              return $r.BRPOPAsync(key, timeout);

            case 3:
              result = _context2.sent;

              // console.log('receive result:', result);
              if (result && result.length > 1) {
                if (result[1]) {
                  try {
                    data = JSON.parse(result[1]);
                  } catch (error) {
                    _console.default.log('_receive error!', error);
                  }
                }
              } // console.log('_receive:', data);


              return _context2.abrupt("return", data);

            case 6:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2);
    }));
    return _receive2.apply(this, arguments);
  }

  function receive() {
    return _receive3.apply(this, arguments);
  }

  function _receive3() {
    _receive3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
      var callback,
          empty,
          msgcount,
          data,
          _args3 = arguments;
      return _regenerator.default.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              callback = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : null;

              if (!(callback && typeof callback === 'function')) {
                _context3.next = 31;
                break;
              }

              // 回调函数模式, 进入死循环.
              createRedis.prototype.stopStatus = false;
              empty = 0;
              msgcount = 0;

            case 5:
              if (createRedis.prototype.stopStatus) {
                _context3.next = 28;
                break;
              }

              _context3.next = 8;
              return _receive(key, timeout);

            case 8:
              data = _context3.sent;

              if (empty > 0 && empty % 60 === 0) {
                _console.default.debug("empty:".concat(empty, " continue"));
              }

              if (msgcount > 0 && msgcount % 60 === 0) {
                _console.default.debug("msgcount:".concat(msgcount, " continue"));
              }

              if (!data) {
                _context3.next = 24;
                break;
              }

              if (empty > 0) {
                _console.default.debug("empty:".concat(empty, ", new data receive, reset"));

                empty = 0;
              }

              msgcount++;
              _context3.prev = 14;
              _context3.next = 17;
              return callback(data.module, data.event, data.data, data.createdAt);

            case 17:
              _context3.next = 22;
              break;

            case 19:
              _context3.prev = 19;
              _context3.t0 = _context3["catch"](14);

              _console.default.log('error receive callback!', _context3.t0);

            case 22:
              _context3.next = 26;
              break;

            case 24:
              if (msgcount > 0) {
                _console.default.debug("msgcount:".concat(msgcount, ", empty reach, reset"));

                msgcount = 0;
              }

              empty++;

            case 26:
              _context3.next = 5;
              break;

            case 28:
              return _context3.abrupt("return", null);

            case 31:
              _context3.next = 33;
              return _receive(key, timeout);

            case 33:
              return _context3.abrupt("return", _context3.sent);

            case 34:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee3, null, [[14, 19]]);
    }));
    return _receive3.apply(this, arguments);
  }

  function stop() {
    return _stop.apply(this, arguments);
  }

  function _stop() {
    _stop = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
      return _regenerator.default.wrap(function _callee4$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              createRedis.prototype.stopStatus = true;
              _context4.next = 3;
              return $r.quitAsync();

            case 3:
              return _context4.abrupt("return", createRedis.prototype.stopStatus);

            case 4:
            case "end":
              return _context4.stop();
          }
        }
      }, _callee4);
    }));
    return _stop.apply(this, arguments);
  }

  function clear() {
    return _clear.apply(this, arguments);
  }

  function _clear() {
    _clear = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
      return _regenerator.default.wrap(function _callee5$(_context5) {
        while (1) {
          switch (_context5.prev = _context5.next) {
            case 0:
              _context5.next = 2;
              return $r.delAsync(key);

            case 2:
              return _context5.abrupt("return", _context5.sent);

            case 3:
            case "end":
              return _context5.stop();
          }
        }
      }, _callee5);
    }));
    return _clear.apply(this, arguments);
  }

  return {
    send: send,
    receive: receive,
    stop: stop,
    clear: clear
  };
}

createRedis.prototype.stopStatus = false;