updated error handling in back-end

Author: standlove

lib/common/errors.js

@@ -19,16 +19,12 @@ class AppError extends Error {
     super();
     this.status = status;
     this.message = message || 'unknown exception';
+    this.lineNo = -1;
   }
 }
 
 module.exports = {
-  newBadRequestError: msg => new AppError(
-    400,
-    msg || 'The request could not be interpreted correctly or some required parameters were missing.',
-  ),
-  newEntityNotFoundError: msg => new AppError(404, msg || 'The entity does not exist.'),
-  newAuthError: msg => new AppError(401, msg || 'Auth failed.'),
-  newPermissionError: msg => new AppError(403, msg || 'The entity does not exist.'),
-  newConflictError: msg => new AppError(409, msg || 'The entity does not exist.'),
+  newConnectTimeoutError: msg => new AppError(500, msg || 'ConnectTimeout'),
+  newConnectFailedError: msg => new AppError(500, msg || 'ConnectFailed'),
+  newReplyError: (msg, lineNo = -1) => new AppError(400, msg, lineNo),
 };

lib/index.js

@@ -38,6 +38,7 @@ module.exports = {
             try {
               result = await handler.method(req, h);
             } catch (e) {
+              logger.error(e);
               result = {code: e.status, message: e.message}
               status = e.status || 500;
             }

lib/redis.js

@@ -7,6 +7,8 @@ const redisDump = require('./tools/redis-dump');
  * cached redis instance
  */
 const redisInstanceCache = {};
+const CONNECTED = 'connected';
+const DISCONNECTED = 'disconnected';
 
 /**
  * connect redis and save the connection instance
@@ -23,54 +25,74 @@ async function connect(body) {
     const redis = new Redis({
       host: body.serverModel.ip, port: body.serverModel.port, db: body.serverModel.db,
       password: body.serverModel.password,
+      showFriendlyErrorStack: true,
     });
     const timeoutHandler = setTimeout(() => {
       redis.disconnect();
-      reject(errors.newBadRequestError("connect timeout!"));
+      reject(errors.newConnectTimeoutError);
     }, 3 * 1000);
 
     redis.on('error', (e) => {
       console.error(e);
-      redisInstanceCache[body.id] = null;
+      body.status = DISCONNECTED;
+      if (e instanceof Redis.MaxRetriesPerRequestError) {
+        redisInstanceCache[body.id] = null;
+      }
     });
 
     redis.on('ready', () => {
       redisInstanceCache[body.id] = redis;
-      body.status = 'connected';
+      body.status = CONNECTED;
       resolve(body);
       clearTimeout(timeoutHandler);
     });
   });
 }
 
 /**
- * fetch the redis tree
+ * Get redis connection
+ * 
  * @param query the query params
  */
-async function fetchTree(query) {
+function getRedis(query) {
   const redis = redisInstanceCache[query.id];
-  if (!redis) {
-    throw errors.newBadRequestError("Redis instance not exist");
+  if (!redis && redis.status !== CONNECTED) {
+    throw errors.newConnectFailedError;
   }
+  return redis;
+}
+
+/**
+ * fetch the redis tree
+ * @param query the query params
+ */
+async function fetchTree(query) {
+  const redis = getRedis(query);
 
   const root = {};
-  const keys = query.keys || (await redis.keys('*'));
   const lencommands = {
     list: 'llen',
     set: 'scard',
     zset: 'zcard',
     hash: 'hlen',
   };
 
-  for (let i = 0; i < keys.length; i++) { // process types
-    const key = keys[i];
-    const type = await redis.type(key);
-    root[key] = {type};
-    if (type !== 'string') {
-      root[key].len = await redis[lencommands[type]](key);
-    } else {
-      root[key].value = await redis.get(key);
+  let keys;
+  try {
+    keys = query.keys || (await redis.keys('*'));
+    
+    for (let i = 0; i < keys.length; i++) { // process types
+      const key = keys[i];
+      const type = await redis.type(key);
+      root[key] = {type};
+      if (type !== 'string') {
+        root[key].len = await redis[lencommands[type]](key);
+      } else {
+        root[key].value = await redis.get(key);
+      }
     }
+  } catch (e) {
+    throw errors.newReplyError(e.message);
   }
 
   const tree = {};
@@ -145,16 +167,14 @@ async function call(query, body) {
   if (!lines || lines.length <= 0) {
     return [];
   }
-  const redis = redisInstanceCache[query.id];
-  if (!redis) {
-    throw errors.newBadRequestError("Redis instance not exist");
-  }
+  const redis = getRedis(query);
+
   const results = [];
   for (let i = 0; i < lines.length; i++) {
     try {
       results.push(await redis.call(...lines[i]));
     } catch (e) {
-      results.push(`${e.message}`);
+      throw errors.newReplyError(e.message, i + 1);
     }
   }
   return results;
@@ -166,14 +186,12 @@ async function call(query, body) {
  * @return {Promise<*>}
  */
 async function dump(query) {
-  const redis = redisInstanceCache[query.id];
-  if (!redis) {
-    throw errors.newBadRequestError("Redis instance not exist");
-  }
+  const redis = getRedis(query);
+
   try {
     return await redisDump(query.exportType, redis);
   } catch (e) {
-    throw errors.newBadRequestError("dump redis failed");
+    throw errors.newReplyError(e.message);
   }
 }