added redis info into error response.

Author: [email protected]

lib/common/errors.js

@@ -15,16 +15,19 @@
  * the base error class
  */
 class AppError extends Error {
-  constructor(status, message) {
+  constructor(redis, status, message) {
     super();
+    this.redis = redis || {};
+    delete this.redis.password;
+
     this.status = status;
     this.message = message || 'unknown exception';
     this.lineNo = -1;
   }
 }
 
 module.exports = {
-  newConnectTimeoutError: msg => new AppError(500, msg || 'ConnectTimeout'),
-  newConnectFailedError: msg => new AppError(500, msg || 'ConnectFailed'),
-  newReplyError: (msg, lineNo = -1) => new AppError(400, msg, lineNo),
+  newConnectTimeoutError: (redis, msg) => new AppError(redis, 500, msg || 'ConnectTimeout'),
+  newConnectFailedError: (redis, msg) => new AppError(redis, 500, msg || 'ConnectFailed'),
+  newReplyError: (redis, msg, lineNo = -1) => new AppError(redis, 400, msg, lineNo),
 };

lib/index.js

@@ -39,7 +39,7 @@ module.exports = {
               result = await handler.method(req, h);
             } catch (e) {
               logger.error(e);
-              result = {code: e.status, message: e.message, line: e.lineNo || -1}
+              result = {code: e.status, redis: e.redis, message: e.message, line: e.lineNo || -1}
               status = e.status || 500;
             }
             return injectHeader(h.response(result).code(status));

lib/redis.js

@@ -18,6 +18,10 @@ const DISCONNECTED = 'disconnected';
 async function connect(body) {
   // already exist
   if (redisInstanceCache[body.id]) {
+    const redisConn = redisInstanceCache[body.id];
+    if (redisConn.status == DISCONNECTED) {
+      redisConn.redis.connect();
+    }
     return Promise.resolve(body);
   }
 
@@ -26,22 +30,26 @@ async function connect(body) {
       host: body.serverModel.ip, port: body.serverModel.port, db: body.serverModel.db,
       password: body.serverModel.password,
       showFriendlyErrorStack: true,
+      maxRetriesPerRequest: 10,
     });
+    
+    body.serverModel.id = body.id;
+
     const timeoutHandler = setTimeout(() => {
       redis.disconnect();
-      reject(errors.newConnectTimeoutError);
+      reject(errors.newConnectTimeoutError(body.serverModel));
     }, 3 * 1000);
 
     redis.on('error', (e) => {
       console.error(e);
       body.status = DISCONNECTED;
-      redisInstanceCache[body.id] = null;
-
     });
 
     redis.on('ready', () => {
-      redisInstanceCache[body.id] = redis;
+      body.redis = redis;
       body.status = CONNECTED;
+      redisInstanceCache[body.id] = body;
+      
       resolve(body);
       clearTimeout(timeoutHandler);
     });
@@ -53,20 +61,21 @@ async function connect(body) {
  * 
  * @param query the query params
  */
-function getRedis(query) {
-  const redis = redisInstanceCache[query.id];
-  if (!redis && redis.status !== CONNECTED) {
-    throw errors.newConnectFailedError;
+function getRedisConnection(query) {
+  const redisConn = redisInstanceCache[query.id];
+  if (!redisConn && redisConn.status !== CONNECTED) {
+    throw errors.newConnectFailedError(redisConn ? redisConn.serverModel : {});
   }
-  return redis;
+  return redisConn;
 }
 
 /**
  * fetch the redis tree
  * @param query the query params
  */
 async function fetchTree(query) {
-  const redis = getRedis(query);
+  const redisConn = getRedisConnection(query);
+  const redis = redisConn.redis;
 
   const root = {};
   const lencommands = {
@@ -91,7 +100,7 @@ async function fetchTree(query) {
       }
     }
   } catch (e) {
-    throw errors.newReplyError(e.message);
+    throw errors.newReplyError(redisConn.serverModel, e.message);
   }
 
   const tree = {};
@@ -166,14 +175,15 @@ async function call(query, body) {
   if (!lines || lines.length <= 0) {
     return [];
   }
-  const redis = getRedis(query);
+  const redisConn = getRedisConnection(query);
+  const redis = redisConn.redis;
 
   const results = [];
   for (let i = 0; i < lines.length; i++) {
     try {
       results.push(await redis.call(...lines[i]));
     } catch (e) {
-      throw errors.newReplyError(e.message, i + 1);
+      throw errors.newReplyError(redisConn.serverModel, e.message, i + 1);
     }
   }
   return results;
@@ -185,12 +195,13 @@ async function call(query, body) {
  * @return {Promise<*>}
  */
 async function dump(query) {
-  const redis = getRedis(query);
+  const redisConn = getRedisConnection(query);
+  const redis = redisConn.redis;
 
   try {
     return await redisDump(query.exportType, redis);
   } catch (e) {
-    throw errors.newReplyError(e.message);
+    throw errors.newReplyError(redisConn.serverModel, e.message);
   }
 }