diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index ec839e25758793f7ada6a12684274903f6bfdfa0..7d3bcd9adb6dac45aa2de724f1fe41c385375a5f 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -324,14 +324,12 @@ typedef struct _sql_obj {
   short             vnode;
   int64_t           stime;
   uint32_t          queryId;
-  void *            thandle;
-  SRpcIpSet         ipSet;
   void *            pStream;
   void *            pSubscription;
   char *            sqlstr;
   char              retry;
   char              maxRetry;
-  uint8_t           index;
+  SRpcIpSet        *ipList;
   char              freed : 4;
   char              listed : 4;
   tsem_t            rspSem;
@@ -373,14 +371,16 @@ typedef struct _sstream {
   struct _sstream *prev, *next;
 } SSqlStream;
 
+int32_t tscInitRpc(const char *user, const char *secret);
+
 // tscSql API
 int tsParseSql(SSqlObj *pSql, bool multiVnodeInsertion);
 
 void tscInitMsgs();
 extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);
 
-void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle);
-int   tscProcessSql(SSqlObj *pSql);
+void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, int32_t code);
+int  tscProcessSql(SSqlObj *pSql);
 
 void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows);
 
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index a70a314298ca870e927ae1f7ff3629d0b925747d..b4fb2776527102254721a92d64a45df54afe4551 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -318,13 +318,6 @@ void tscProcessAsyncRes(SSchedMsg *pMsg) {
   int cmd = pCmd->command;
   int code = pRes->code ? -pRes->code : pRes->numOfRows;
 
-  if ((tscKeepConn[cmd] == 0 || (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_ACTION_IN_PROGRESS)) &&
-      pSql->pStream == NULL) {
-    if (pSql->thandle) taosAddConnIntoCache(tscConnCache, pSql->thandle, pSql->ip, pSql->vnode, pTscObj->user);
-
-    pSql->thandle = NULL;
-  }
-
   // in case of async insert, restore the user specified callback function
   bool shouldFree = tscShouldFreeAsyncSqlObj(pSql);
 
@@ -454,8 +447,8 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
       tscTrace("%p failed to renew meterMeta", pSql);
       tsem_post(&pSql->rspSem);
     } else {
-      tscTrace("%p renew meterMeta successfully, command:%d, code:%d, thandle:%p, retry:%d",
-          pSql, pSql->cmd.command, pSql->res.code, pSql->thandle, pSql->retry);
+      tscTrace("%p renew meterMeta successfully, command:%d, code:%d, retry:%d",
+          pSql, pSql->cmd.command, pSql->res.code, pSql->retry);
   
       SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
       assert(pMeterMetaInfo->pMeterMeta == NULL);
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 4ab63c18e9ad339664b1771bead46aedcb0c9d48..cb991691f5473cb7b8c528f017508d53df7b45b2 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -451,7 +451,6 @@ static int insertStmtExecute(STscStmt* stmt) {
   pRes->numOfTotalInCurrentClause = 0;
   
   pRes->qhandle = 0;
-  pSql->thandle = NULL;
 
   tscDoQuery(pSql);
 
diff --git a/src/client/src/tscProfile.c b/src/client/src/tscProfile.c
index c6abfabf93370bac4995b6d8f6384b4fc98a6273..d6af2f59dc293ae78f7c2c74f5a5637f5bbf509a 100644
--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -145,7 +145,7 @@ void tscKillQuery(STscObj *pObj, uint32_t killId) {
 
   if (pSql == NULL) return;
 
-  tscTrace("%p query is killed, queryId:%d thandle:%p", pSql, killId, pSql->thandle);
+  tscTrace("%p query is killed, queryId:%d", pSql, killId);
   taos_stop_query(pSql);
 }
 
@@ -209,16 +209,16 @@ void tscKillStream(STscObj *pObj, uint32_t killId) {
 }
 
 char *tscBuildQueryStreamDesc(char *pMsg, STscObj *pObj) {
-  SQList *pQList = (SQList *)pMsg;
+  SCMQqueryList *pQList = (SCMQqueryList *)pMsg;
   char *  pMax = pMsg + TSDB_PAYLOAD_SIZE - 256;
 
-  SQDesc *pQdesc = pQList->qdesc;
+  SCMQueryDesc *pQdesc = pQList->qdesc;
   pQList->numOfQueries = 0;
 
   // We extract the lock to tscBuildHeartBeatMsg function.
   /* pthread_mutex_lock (&pObj->mutex); */
 
-  pMsg += sizeof(SQList);
+  pMsg += sizeof(SCMQqueryList);
   SSqlObj *pSql = pObj->sqlList;
   while (pSql) {
     /*
@@ -239,15 +239,15 @@ char *tscBuildQueryStreamDesc(char *pMsg, STscObj *pObj) {
     pQList->numOfQueries++;
     pQdesc++;
     pSql = pSql->next;
-    pMsg += sizeof(SQDesc);
+    pMsg += sizeof(SCMQueryDesc);
     if (pMsg > pMax) break;
   }
 
-  SSList *pSList = (SSList *)pMsg;
-  SSDesc *pSdesc = pSList->sdesc;
+  SCMStreamList *pSList = (SCMStreamList *)pMsg;
+  SCMStreamDesc *pSdesc = pSList->sdesc;
   pSList->numOfStreams = 0;
 
-  pMsg += sizeof(SSList);
+  pMsg += sizeof(SCMStreamList);
   SSqlStream *pStream = pObj->streamList;
   while (pStream) {
     strncpy(pSdesc->sql, pStream->pSql->sqlstr, TSDB_SHOW_SQL_LEN - 1);
@@ -265,7 +265,7 @@ char *tscBuildQueryStreamDesc(char *pMsg, STscObj *pObj) {
     pSList->numOfStreams++;
     pSdesc++;
     pStream = pStream->next;
-    pMsg += sizeof(SSDesc);
+    pMsg += sizeof(SCMStreamDesc);
     if (pMsg > pMax) break;
   }
 
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index fb68f6dfaf5c6192714514989a1ab92412a03899..704842506b2476d20ba2146e7ab810ce06a61c87 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -31,12 +31,10 @@
 
 #define TSC_MGMT_VNODE 999
 
-SRpcIpSet  tscMgmtIpList;
 int        tsMasterIndex = 0;
 int        tsSlaveIndex = 1;
 
-//temp
-SRpcIpSet  tscMgmtIpSet;
+SRpcIpSet  tscMgmtIpList;
 SRpcIpSet  tscDnodeIpSet;
 
 int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo) = {0};
@@ -62,29 +60,27 @@ void tscPrintMgmtIp() {
   }
 }
 
-void tscSetMgmtIpListFromCluster(SIpList *pIpList) {
-  tscMgmtIpList.numOfIps = pIpList->numOfIps;
-  if (memcmp(tscMgmtIpList.ip, pIpList->ip, pIpList->numOfIps * 4) != 0) {
-    for (int i = 0; i < pIpList->numOfIps; ++i) {
-      //tinet_ntoa(tscMgmtIpList.ipStr[i], pIpList->ip[i]);
-      tscMgmtIpList.ip[i] = pIpList->ip[i];
-    }
-    tscTrace("cluster mgmt IP list:");
-    tscPrintMgmtIp();
+void tscSetMgmtIpListFromCluster(SRpcIpSet *pIpList) {
+  tscMgmtIpList.numOfIps = htons(pIpList->numOfIps);
+  tscMgmtIpList.index = htons(pIpList->index);
+  tscMgmtIpList.port = htons(pIpList->port);
+  for (int32_t i = 0; i <tscMgmtIpList.numOfIps; ++i) {
+    tscMgmtIpList.ip[i] = pIpList->ip[i];
   }
 }
 
 void tscSetMgmtIpListFromEdge() {
-  if (tscMgmtIpList.numOfIps != 2) {
-    tscMgmtIpList.numOfIps = 2;
+  if (tscMgmtIpList.numOfIps != 1) {
+    tscMgmtIpList.numOfIps = 1;
+    tscMgmtIpList.index = 0;
+    tscMgmtIpList.port = tsMgmtShellPort;
     tscMgmtIpList.ip[0] = inet_addr(tsMasterIp);
-    tscMgmtIpList.ip[1] = inet_addr(tsMasterIp);
     tscTrace("edge mgmt IP list:");
     tscPrintMgmtIp();
   }
 }
 
-void tscSetMgmtIpList(SIpList *pIpList) {
+void tscSetMgmtIpList(SRpcIpSet *pIpList) {
   /*
     * The iplist returned by the cluster edition is the current management nodes
     * and the iplist returned by the edge edition is empty
@@ -120,15 +116,15 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
   SSqlRes *pRes = &pSql->res;
 
   if (code == 0) {
-    SHeartBeatRsp *pRsp = (SHeartBeatRsp *)pRes->pRsp;
-    SIpList *      pIpList = &pRsp->ipList;
+    SCMHeartBeatRsp *pRsp = (SCMHeartBeatRsp *)pRes->pRsp;
+    SRpcIpSet *      pIpList = &pRsp->ipList;
     tscSetMgmtIpList(pIpList);
 
     if (pRsp->killConnection) {
       tscKillConnection(pObj);
     } else {
-      if (pRsp->queryId) tscKillQuery(pObj, pRsp->queryId);
-      if (pRsp->streamId) tscKillStream(pObj, pRsp->streamId);
+      if (pRsp->queryId) tscKillQuery(pObj, htonl(pRsp->queryId));
+      if (pRsp->streamId) tscKillStream(pObj, htonl(pRsp->streamId));
     }
   } else {
     tscTrace("heart beat failed, code:%d", code);
@@ -169,9 +165,7 @@ void tscProcessActivityTimer(void *handle, void *tmrId) {
   }
 
   if (tscShouldFreeHeatBeat(pObj->pHb)) {
-    tscTrace("%p free HB object and release connection, pConn:%p", pObj, pObj->pHb->thandle);
-    //taosCloseRpcConn(pObj->pHb->thandle);
-
+    tscTrace("%p free HB object and release connection", pObj);
     tscFreeSqlObj(pObj->pHb);
     tscCloseTscObj(pObj);
     return;
@@ -180,287 +174,56 @@ void tscProcessActivityTimer(void *handle, void *tmrId) {
   tscProcessSql(pObj->pHb);
 }
 
-
-void tscGetConnToMgmt(SSqlObj *pSql, uint8_t *pCode) {
-  STscObj *pTscObj = pSql->pTscObj;
-  if (pSql->retry < tscGetMgmtConnMaxRetryTimes()) {
-    *pCode = 0;
-    pSql->retry++;
-    pSql->index = pSql->index % tscMgmtIpList.numOfIps;
-    if (pSql->cmd.command > TSDB_SQL_READ && pSql->index == 0) pSql->index = 1;
-    void *thandle = taosGetConnFromCache(tscConnCache, tscMgmtIpList.ip[pSql->index], TSC_MGMT_VNODE, pTscObj->user);
-
-
-//    if (thandle == NULL) {
-//      SRpcConnInit connInit;
-//      memset(&connInit, 0, sizeof(connInit));
-//      connInit.cid = 0;
-//      connInit.sid = 0;
-//      connInit.meterId = pSql->pTscObj->user;
-//      connInit.peerId = 0;
-//      connInit.shandle = pTscMgmtConn;
-//      connInit.ahandle = pSql;
-//      connInit.peerPort = tsMgmtShellPort;
-//      connInit.spi = 1;
-//      connInit.encrypt = 0;
-//      connInit.secret = pSql->pTscObj->pass;
-//
-//      connInit.peerIp = tscMgmtIpList.ipstr[pSql->index];
-//      thandle = taosOpenRpcConn(&connInit, pCode);
-//    }
-
-    pSql->thandle = thandle;
-    pSql->ip = tscMgmtIpList.ip[pSql->index];
-    pSql->vnode = TSC_MGMT_VNODE;
-    tscTrace("%p mgmt index:%d ip:0x%x is picked up, pConn:%p", pSql, pSql->index, tscMgmtIpList.ip[pSql->index],
-             pSql->thandle);
-  }
-
-  // the pSql->res.code is the previous error(status) code.
-  if (pSql->thandle == NULL && pSql->retry >= pSql->maxRetry) {
-    if (pSql->res.code != TSDB_CODE_SUCCESS && pSql->res.code != TSDB_CODE_ACTION_IN_PROGRESS) {
-      *pCode = pSql->res.code;
-    }
-
-    tscError("%p reach the max retry:%d, code:%d", pSql, pSql->retry, *pCode);
-  }
-}
-
-void tscGetConnToVnode(SSqlObj *pSql, uint8_t *pCode) {
-  SVPeerDesc *pVPeersDesc = NULL;
-  static int  vidIndex = 0;
-  STscObj *   pTscObj = pSql->pTscObj;
-
-  pSql->thandle = NULL;
-
-  SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {  // multiple vnode query
-    SVnodeSidList *vnodeList = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, pMeterMetaInfo->vnodeIndex);
-    if (vnodeList != NULL) {
-      pVPeersDesc = vnodeList->vpeerDesc;
-    }
-  } else {
-    SMeterMeta *pMeta = pMeterMetaInfo->pMeterMeta;
-    if (pMeta == NULL) {
-      tscError("%p pMeterMeta is NULL", pSql);
-      pSql->retry = pSql->maxRetry;
-      return;
-    }
-    pVPeersDesc = pMeta->vpeerDesc;
-  }
-
-  if (pVPeersDesc == NULL) {
-    pSql->retry = pSql->maxRetry;
-    tscError("%p pVPeerDesc is NULL", pSql);
-  }
-
-  while (pSql->retry < pSql->maxRetry) {
-    (pSql->retry)++;
-    char ipstr[40] = {0};
-    if (pVPeersDesc[pSql->index].ip == 0) {
-      /*
-       * in the edge edition, ip is 0, and at this time we use masterIp instead
-       * in the cluster edition, ip is vnode ip
-       */
-      pVPeersDesc[pSql->index].ip = tscMgmtIpList.ip[0];
-    }
-    *pCode = TSDB_CODE_SUCCESS;
-
-    void *thandle =
-        taosGetConnFromCache(tscConnCache, pVPeersDesc[pSql->index].ip, pVPeersDesc[pSql->index].vnode, pTscObj->user);
-
-//    if (thandle == NULL) {
-//      SRpcConnInit connInit;
-//      tinet_ntoa(ipstr, pVPeersDesc[pSql->index].ip);
-//      memset(&connInit, 0, sizeof(connInit));
-//      connInit.cid = vidIndex;
-//      connInit.sid = 0;
-//      connInit.spi = 0;
-//      connInit.encrypt = 0;
-//      connInit.meterId = pSql->pTscObj->user;
-//      connInit.peerId = htonl((pVPeersDesc[pSql->index].vnode << TSDB_SHELL_VNODE_BITS));
-//      connInit.shandle = pVnodeConn;
-//      connInit.ahandle = pSql;
-//      connInit.peerIp = ipstr;
-//      connInit.peerPort = tsVnodeShellPort;
-//      thandle = taosOpenRpcConn(&connInit, pCode);
-//      vidIndex = (vidIndex + 1) % tscNumOfThreads;
-//    }
-
-    pSql->thandle = thandle;
-    pSql->ip = pVPeersDesc[pSql->index].ip;
-    pSql->vnode = pVPeersDesc[pSql->index].vnode;
-    tscTrace("%p vnode:%d ip:%p index:%d is picked up, pConn:%p", pSql, pVPeersDesc[pSql->index].vnode,
-             pVPeersDesc[pSql->index].ip, pSql->index, pSql->thandle);
-
-    //TODO fetch from vpeerdesc
-    pSql->ipSet = tscMgmtIpSet;
-    break;
-  }
-
-  // the pSql->res.code is the previous error(status) code.
-  if (pSql->thandle == NULL && pSql->retry >= pSql->maxRetry) {
-    if (pSql->res.code != TSDB_CODE_SUCCESS && pSql->res.code != TSDB_CODE_ACTION_IN_PROGRESS) {
-      *pCode = pSql->res.code;
-    }
-
-    tscError("%p reach the max retry:%d, code:%d", pSql, pSql->retry, *pCode);
-  }
-}
-
 int tscSendMsgToServer(SSqlObj *pSql) {
-  uint8_t code = TSDB_CODE_NETWORK_UNAVAIL;
-
-  if (pSql->thandle == NULL) {
-    if (pSql->cmd.command < TSDB_SQL_MGMT)
-      tscGetConnToVnode(pSql, &code);
-    else
-      tscGetConnToMgmt(pSql, &code);
-  }
-
-  if (pSql->thandle) {
-    /*
-     * the total length of message
-     * rpc header + actual message body + digest
-     *
-     * the pSql object may be released automatically during insert procedure, in which the access of
-     * message body by using "if (pHeader->msgType & 1)" may cause the segment fault.
-     *
-     */
-    size_t totalLen = pSql->cmd.payloadLen + tsRpcHeadSize + 100;
-
-    // the memory will be released by taosProcessResponse, so no memory leak here
-    char *pStart = rpcMallocCont(pSql->cmd.payloadLen);
-    if (NULL == pStart) {
-      tscError("%p msg:%s malloc fail", pSql, taosMsg[pSql->cmd.msgType]);
-      return TSDB_CODE_CLI_OUT_OF_MEMORY;
-    }
-    memcpy(pStart, pSql->cmd.payload + tsRpcHeadSize, pSql->cmd.payloadLen);
-
-    tscTrace("%p msg:%s is sent to server", pSql, taosMsg[pSql->cmd.msgType]);
-
-    if (pStart) {
-      /*
-       * this SQL object may be released by other thread due to the completion of this query even before the log
-       * is dumped to log file. So the signature needs to be kept in a local variable.
-       */
-      uint64_t signature = (uint64_t)pSql->signature;
-      //if (tscUpdateVnodeMsg[pSql->cmd.command]) (*tscUpdateVnodeMsg[pSql->cmd.command])(pSql, pStart);
-
-      if (pSql->cmd.command < TSDB_SQL_MGMT) {
-        rpcSendRequest(pTscMgmtConn, &tscMgmtIpList, pSql->cmd.msgType, pStart, pSql->cmd.payloadLen, pSql);
-      } else {
-        SRpcIpSet rpcSet = tscMgmtIpList;
-        rpcSendRequest(pVnodeConn, &rpcSet, pSql->cmd.msgType, pStart, pSql->cmd.payloadLen, pSql);
-      }
-
-      tscTrace("%p send msg code:%d sig:%p", pSql, code, signature);
-    }
+  char *pMsg = rpcMallocCont(pSql->cmd.payloadLen);
+  if (NULL == pMsg) {
+    tscError("%p msg:%s malloc fail", pSql, taosMsg[pSql->cmd.msgType]);
+    return TSDB_CODE_CLI_OUT_OF_MEMORY;
   }
 
-  return code;
-}
+  tscPrint("%p msg:%s is sent to server %d", pSql, taosMsg[pSql->cmd.msgType], pSql->ipList->port);
 
-void tscProcessMgmtRedirect(SSqlObj *pSql, uint8_t *cont) {
-  SIpList *pIpList = (SIpList *)(cont);
-  tscSetMgmtIpList(pIpList);
+  memcpy(pMsg, pSql->cmd.payload, pSql->cmd.payloadLen);
 
-  if (pSql->cmd.command < TSDB_SQL_READ) {
-    tsMasterIndex = 0;
-    pSql->index = 0;
+  pSql->ipList->ip[0] = inet_addr("192.168.0.1");
+  if (pSql->cmd.command < TSDB_SQL_MGMT) {
+    rpcSendRequest(pVnodeConn, pSql->ipList, pSql->cmd.msgType, pMsg, pSql->cmd.payloadLen, pSql);
   } else {
-    pSql->index++;
+    rpcSendRequest(pTscMgmtConn, pSql->ipList, pSql->cmd.msgType, pMsg, pSql->cmd.payloadLen, pSql);
   }
 
-  tscPrintMgmtIp();
+  return TSDB_CODE_SUCCESS;
 }
 
-void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle) {
-  if (ahandle == NULL) return NULL;
-
-  SIntMsg *pMsg = (SIntMsg *)msg;
+void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, int32_t code) {
+  tscPrint("response is received, pCont:%p, code:%d", pCont, code);
   SSqlObj *pSql = (SSqlObj *)ahandle;
-  SSqlRes *pRes = &pSql->res;
-  SSqlCmd *pCmd = &pSql->cmd;
-  STscObj *pObj = pSql->pTscObj;
-  int      code = TSDB_CODE_NETWORK_UNAVAIL;
-
-  if (pSql->signature != pSql) {
+  if (pSql == NULL || pSql->signature != pSql) {
     tscError("%p sql is already released, signature:%p", pSql, pSql->signature);
-    return NULL;
-  }
-
-  if (pSql->thandle != thandle) {
-    tscError("%p thandle:%p is different from received:%p", pSql, pSql->thandle, thandle);
-    return NULL;
+    return;
   }
 
-  tscTrace("%p msg:%p is received from server, pConn:%p", pSql, msg, thandle);
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
+  STscObj *pObj = pSql->pTscObj;
+  tscTrace("%p msg:%p is received from server", pSql, pCont);
 
   if (pSql->freed || pObj->signature != pObj) {
     tscTrace("%p sql is already released or DB connection is closed, freed:%d pObj:%p signature:%p", pSql, pSql->freed,
              pObj, pObj->signature);
-    taosAddConnIntoCache(tscConnCache, pSql->thandle, pSql->ip, pSql->vnode, pObj->user);
     tscFreeSqlObj(pSql);
-    return ahandle;
+    rpcFreeCont(pCont);
+    return;
   }
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  if (msg == NULL) {
-    tscTrace("%p no response from ip:%s", pSql, taosIpStr(pSql->ip));
-
-    pSql->index++;
-    pSql->thandle = NULL;
-    // todo taos_stop_query() in async model
-    /*
-     * in case of
-     * 1. query cancelled(pRes->code != TSDB_CODE_QUERY_CANCELLED), do NOT re-issue the request to server.
-     * 2. retrieve, do NOT re-issue the retrieve request since the qhandle may have been released by server
-     */
-    if (pCmd->command != TSDB_SQL_FETCH && pCmd->command != TSDB_SQL_RETRIEVE && pCmd->command != TSDB_SQL_KILL_QUERY &&
-        pRes->code != TSDB_CODE_QUERY_CANCELLED) {
-      code = tscSendMsgToServer(pSql);
-      if (code == 0) return NULL;
-    }
-
-    // renew meter meta in case it is changed
-    if (pCmd->command < TSDB_SQL_FETCH && pRes->code != TSDB_CODE_QUERY_CANCELLED) {
-      pSql->maxRetry = TSDB_VNODES_SUPPORT * 2;
-      code = tscRenewMeterMeta(pSql, pMeterMetaInfo->name);
-      pRes->code = code;
-      if (code == TSDB_CODE_ACTION_IN_PROGRESS) return pSql;
-
-      if (pMeterMetaInfo->pMeterMeta) {
-        code = tscSendMsgToServer(pSql);
-        if (code == 0) return pSql;
-      }
-    }
+  if (pCont == NULL) {
+    code = TSDB_CODE_NETWORK_UNAVAIL;
   } else {
-    uint16_t rspCode = pMsg->content[0];
-    
-    if (rspCode == TSDB_CODE_REDIRECT) {
-      tscTrace("%p it shall be redirected!", pSql);
-      taosAddConnIntoCache(tscConnCache, thandle, pSql->ip, pSql->vnode, pObj->user);
-      pSql->thandle = NULL;
-
-      if (pCmd->command > TSDB_SQL_MGMT) {
-        tscProcessMgmtRedirect(pSql, pMsg->content + 1);
-      } else if (pCmd->command == TSDB_SQL_INSERT) {
-        pSql->index++;
-        pSql->maxRetry = TSDB_VNODES_SUPPORT * 2;
-      } else {
-        pSql->index++;
-      }
-
-      code = tscSendMsgToServer(pSql);
-      if (code == 0) return pSql;
-      msg = NULL;
-    } else if (rspCode == TSDB_CODE_NOT_ACTIVE_TABLE || rspCode == TSDB_CODE_INVALID_TABLE_ID ||
-        rspCode == TSDB_CODE_INVALID_VNODE_ID || rspCode == TSDB_CODE_NOT_ACTIVE_VNODE ||
-        rspCode == TSDB_CODE_NETWORK_UNAVAIL || rspCode == TSDB_CODE_NOT_ACTIVE_SESSION ||
-        rspCode == TSDB_CODE_TABLE_ID_MISMATCH) {
+    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+    if (code == TSDB_CODE_NOT_ACTIVE_TABLE || code == TSDB_CODE_INVALID_TABLE_ID ||
+        code == TSDB_CODE_INVALID_VNODE_ID || code == TSDB_CODE_NOT_ACTIVE_VNODE ||
+        code == TSDB_CODE_NETWORK_UNAVAIL || code == TSDB_CODE_NOT_ACTIVE_SESSION ||
+        code == TSDB_CODE_TABLE_ID_MISMATCH) {
       /*
        * not_active_table: 1. the virtual node may fail to create table, since the procedure of create table is asynchronized,
        *                   the virtual node may have not create table till now, so try again by using the new metermeta.
@@ -471,53 +234,33 @@ void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle) {
        *                   removed. So, renew metermeta and try again.
        * not_active_session: db has been move to other node, the vnode does not exist on this dnode anymore.
        */
-     pSql->thandle = NULL;
-      taosAddConnIntoCache(tscConnCache, thandle, pSql->ip, pSql->vnode, pObj->user);
-
       if (pCmd->command == TSDB_SQL_CONNECT) {
         code = TSDB_CODE_NETWORK_UNAVAIL;
+        rpcFreeCont(pCont);
+        return;
       } else if (pCmd->command == TSDB_SQL_HB) {
         code = TSDB_CODE_NOT_READY;
+        rpcFreeCont(pCont);
+        return;
       } else {
-        tscTrace("%p it shall renew meter meta, code:%d", pSql, rspCode);
+        tscTrace("%p it shall renew meter meta, code:%d", pSql, code);
 
         pSql->maxRetry = TSDB_VNODES_SUPPORT * 2;
-        pSql->res.code = (uint8_t)rspCode;  // keep the previous error code
+        pSql->res.code = (uint8_t) code;  // keep the previous error code
 
         code = tscRenewMeterMeta(pSql, pMeterMetaInfo->name);
-        if (code == TSDB_CODE_ACTION_IN_PROGRESS) return pSql;
 
         if (pMeterMetaInfo->pMeterMeta) {
-          code = tscSendMsgToServer(pSql);
-          if (code == 0) return pSql;
+          tscSendMsgToServer(pSql);
+          rpcFreeCont(pCont);
+          return;
         }
       }
-
-      msg = NULL;
-    } else {  // for other error set and return to invoker
-      code = rspCode;
     }
   }
 
   pSql->retry = 0;
 
-  if (msg) {
-    if (pCmd->command < TSDB_SQL_MGMT) {
-      if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
-        if (pMeterMetaInfo->pMeterMeta)  // it may be deleted
-          pMeterMetaInfo->pMeterMeta->index = pSql->index;
-      } else {
-        SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, pMeterMetaInfo->vnodeIndex);
-        pVnodeSidList->index = pSql->index;
-      }
-    } else {
-      if (pCmd->command > TSDB_SQL_READ)
-        tsSlaveIndex = pSql->index;
-      else
-        tsMasterIndex = pSql->index;
-    }
-  }
-
   if (pSql->fp == NULL) tsem_wait(&pSql->emptyRspSem);
 
   pRes->rspLen = 0;
@@ -527,11 +270,11 @@ void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle) {
     tscTrace("%p query is cancelled, code:%d", pSql, pRes->code);
   }
 
-  if (msg && pRes->code != TSDB_CODE_QUERY_CANCELLED) {
-    assert(pMsg->msgType == pCmd->msgType + 1);
-    pRes->code = pMsg->content[0];
-    pRes->rspType = pMsg->msgType;
-    pRes->rspLen = pMsg->msgLen - sizeof(SIntMsg);
+  if (pRes->code != TSDB_CODE_QUERY_CANCELLED) {
+    assert(type == pCmd->msgType + 1);
+    pRes->code = (int8_t)code;
+    pRes->rspType = type;
+    pRes->rspLen = contLen;
 
     char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
     if (tmp == NULL) {
@@ -539,7 +282,7 @@ void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle) {
     } else {
       pRes->pRsp = tmp;
       if (pRes->rspLen) {
-        memcpy(pRes->pRsp, pMsg->content + 1, pRes->rspLen - 1);
+        memcpy(pRes->pRsp, pCont, pRes->rspLen);
       }
     }
 
@@ -552,7 +295,7 @@ void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle) {
      * There is not response callback function for submit response.
      * The actual inserted number of points is the first number.
      */
-    if (pMsg->msgType == TSDB_MSG_TYPE_DNODE_SUBMIT_RSP) {
+    if (type == TSDB_MSG_TYPE_DNODE_SUBMIT_RSP) {
       pRes->numOfRows += *(int32_t *)pRes->pRsp;
 
       tscTrace("%p cmd:%d code:%d, inserted rows:%d, rsp len:%d", pSql, pCmd->command, pRes->code,
@@ -562,14 +305,6 @@ void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle) {
     }
   }
 
-  if (tscKeepConn[pCmd->command] == 0 ||
-      (pRes->code != TSDB_CODE_SUCCESS && pRes->code != TSDB_CODE_ACTION_IN_PROGRESS)) {
-    if (pSql->thandle != NULL) {
-      taosAddConnIntoCache(tscConnCache, pSql->thandle, pSql->ip, pSql->vnode, pObj->user);
-      pSql->thandle = NULL;
-    }
-  }
-
   if (pSql->fp == NULL) {
     tsem_post(&pSql->rspSem);
   } else {
@@ -611,7 +346,7 @@ void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle) {
     }
   }
 
-  return ahandle;
+  rpcFreeCont(pCont);
 }
 
 static SSqlObj *tscCreateSqlObjForSubquery(SSqlObj *pSql, SRetrieveSupport *trsupport, SSqlObj *prevSqlObj);
@@ -771,28 +506,27 @@ int tscProcessSql(SSqlObj *pSql) {
   }
 
   tscTrace("%p SQL cmd:%d will be processed, name:%s, type:%d", pSql, pCmd->command, name, type);
-  pSql->retry = 0;
   if (pSql->cmd.command < TSDB_SQL_MGMT) {
-    pSql->maxRetry = TSDB_VNODES_SUPPORT;
-
     // the pMeterMetaInfo cannot be NULL
     if (pMeterMetaInfo == NULL) {
       pSql->res.code = TSDB_CODE_OTHERS;
       return pSql->res.code;
     }
 
-    if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
-      pSql->index = pMeterMetaInfo->pMeterMeta->index;
-    } else {  // it must be the parent SSqlObj for super table query
-      if ((pQueryInfo->type & TSDB_QUERY_TYPE_SUBQUERY) != 0) {
-        int32_t idx = pMeterMetaInfo->vnodeIndex;
-
-        SVnodeSidList *pSidList = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, idx);
-        pSql->index = pSidList->index;
-      }
-    }
+    //TODO change the connect info in metadata
+    return TSDB_CODE_OTHERS;
+//    if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+//      pSql->index = pMeterMetaInfo->pMeterMeta->index;
+//    } else {  // it must be the parent SSqlObj for super table query
+//      if ((pQueryInfo->type & TSDB_QUERY_TYPE_SUBQUERY) != 0) {
+//        int32_t idx = pMeterMetaInfo->vnodeIndex;
+//
+//        SVnodeSidList *pSidList = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, idx);
+//        pSql->index = pSidList->index;
+//      }
+//    }
   } else if (pSql->cmd.command < TSDB_SQL_LOCAL) {
-    pSql->index = pSql->cmd.command < TSDB_SQL_READ ? tsMasterIndex : tsSlaveIndex;
+    pSql->ipList = &tscMgmtIpList;
   } else {  // local handler
     return (*tscProcessMsgRsp[pCmd->command])(pSql);
   }
@@ -1313,7 +1047,7 @@ void tscKillMetricQuery(SSqlObj *pSql) {
   for (int i = 0; i < pSql->numOfSubs; ++i) {
     SSqlObj *pSub = pSql->pSubs[i];
 
-    if (pSub == NULL || pSub->thandle == NULL) {
+    if (pSub == NULL) {
       continue;
     }
 
@@ -1485,7 +1219,8 @@ void tscUpdateVnodeInSubmitMsg(SSqlObj *pSql, char *buf) {
 
   pMsg = buf + tsRpcHeadSize;
 
-  pShellMsg = (SShellSubmitMsg *)pMsg;
+  //TODO set iplist
+  //pShellMsg = (SShellSubmitMsg *)pMsg;
   //pShellMsg->vnode = htons(pMeterMeta->vpeerDesc[pSql->index].vnode);
   //tscTrace("%p update submit msg vnode:%s:%d", pSql, taosIpStr(pMeterMeta->vpeerDesc[pSql->index].ip),
   //         htons(pShellMsg->vnode));
@@ -1518,20 +1253,21 @@ int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 }
 
 void tscUpdateVnodeInQueryMsg(SSqlObj *pSql, char *buf) {
-  SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-
-  char *          pStart = buf + tsRpcHeadSize;
-  SQueryMeterMsg *pQueryMsg = (SQueryMeterMsg *)pStart;
-
-  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {  // pColumnModel == NULL, query on meter
-    SMeterMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta;
-    pQueryMsg->vnode = htons(pMeterMeta->vpeerDesc[pSql->index].vnode);
-  } else {  // query on metric
-    SMetricMeta *  pMetricMeta = pMeterMetaInfo->pMetricMeta;
-    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pMeterMetaInfo->vnodeIndex);
-    pQueryMsg->vnode = htons(pVnodeSidList->vpeerDesc[pSql->index].vnode);
-  }
+  //TODO
+//  SSqlCmd *       pCmd = &pSql->cmd;
+//  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+//
+//  char *          pStart = buf + tsRpcHeadSize;
+//  SQueryMeterMsg *pQueryMsg = (SQueryMeterMsg *)pStart;
+//
+//  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {  // pColumnModel == NULL, query on meter
+//    SMeterMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta;
+//    pQueryMsg->vnode = htons(pMeterMeta->vpeerDesc[pSql->index].vnode);
+//  } else {  // query on metric
+//    SMetricMeta *  pMetricMeta = pMeterMetaInfo->pMetricMeta;
+//    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pMeterMetaInfo->vnodeIndex);
+//    pQueryMsg->vnode = htons(pVnodeSidList->vpeerDesc[pSql->index].vnode);
+//  }
 }
 
 /*
@@ -2601,27 +2337,24 @@ int tscProcessRetrieveMetricRsp(SSqlObj *pSql) {
 int tscProcessEmptyResultRsp(SSqlObj *pSql) { return tscLocalResultCommonBuilder(pSql, 0); }
 
 int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
-  SCMConnectMsg *pConnect;
-  char *       pMsg, *pStart;
-
-  SSqlCmd *pCmd = &pSql->cmd;
   STscObj *pObj = pSql->pTscObj;
-  pMsg = pCmd->payload + tsRpcHeadSize;
-  pStart = pMsg;
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->msgType = TSDB_MSG_TYPE_CONNECT;
+  pCmd->payloadLen = sizeof(SCMConnectMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("%p failed to malloc for query msg", pSql);
+    return TSDB_CODE_CLI_OUT_OF_MEMORY;
+  }
 
-  pConnect = (SCMConnectMsg *)pMsg;
+  SCMConnectMsg *pConnect = (SCMConnectMsg*)pCmd->payload;
 
   char *db;  // ugly code to move the space
   db = strstr(pObj->db, TS_PATH_DELIMITER);
   db = (db == NULL) ? pObj->db : db + 1;
   strcpy(pConnect->db, db);
-
   strcpy(pConnect->clientVersion, version);
-
-  pMsg += sizeof(SCMConnectMsg);
-
-  pCmd->payloadLen = pMsg - pStart;
-  pCmd->msgType = TSDB_MSG_TYPE_CONNECT;
+  strcpy(pConnect->msgVersion, "");
 
   return TSDB_CODE_SUCCESS;
 }
@@ -2884,18 +2617,18 @@ int tscEstimateHeartBeatMsgLength(SSqlObj *pSql) {
   STscObj *pObj = pSql->pTscObj;
 
   size += tsRpcHeadSize + sizeof(SMgmtHead);
-  size += sizeof(SQList);
+  size += sizeof(SCMQqueryList);
 
   SSqlObj *tpSql = pObj->sqlList;
   while (tpSql) {
-    size += sizeof(SQDesc);
+    size += sizeof(SCMQueryDesc);
     tpSql = tpSql->next;
   }
 
-  size += sizeof(SSList);
+  size += sizeof(SCMStreamList);
   SSqlStream *pStream = pObj->streamList;
   while (pStream) {
-    size += sizeof(SSDesc);
+    size += sizeof(SCMStreamDesc);
     pStream = pStream->next;
   }
 
@@ -3323,10 +3056,10 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
   assert(len <= tListLen(pObj->db));
   strncpy(pObj->db, temp, tListLen(pObj->db));
   
-  SIpList *    pIpList;
-  char *rsp = pRes->pRsp + sizeof(SCMConnectRsp);
-  pIpList = (SIpList *)rsp;
-  tscSetMgmtIpList(pIpList);
+//  SIpList *    pIpList;
+//  char *rsp = pRes->pRsp + sizeof(SCMConnectRsp);
+//  pIpList = (SIpList *)rsp;
+//  tscSetMgmtIpList(pIpList);
 
   strcpy(pObj->sversion, pConnect->serverVersion);
   pObj->writeAuth = pConnect->writeAuth;
@@ -3453,18 +3186,7 @@ int tscProcessRetrieveRspFromVnode(SSqlObj *pSql) {
 
   pRes->row = 0;
 
-  /**
-   * If the query result is exhausted, or current query is to free resource at server side,
-   * the connection will be recycled.
-   */
-  if ((pRes->numOfRows == 0 && !(tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) && pRes->offset > 0)) ||
-      ((pQueryInfo->type & TSDB_QUERY_TYPE_FREE_RESOURCE) == TSDB_QUERY_TYPE_FREE_RESOURCE)) {
-    tscTrace("%p no result or free resource, recycle connection", pSql);
-    taosAddConnIntoCache(tscConnCache, pSql->thandle, pSql->ip, pSql->vnode, pObj->user);
-    pSql->thandle = NULL;
-  } else {
-    tscTrace("%p numOfRows:%d, offset:%d, not recycle connection", pSql, pRes->numOfRows, pRes->offset);
-  }
+  tscTrace("%p numOfRows:%d, offset:%d", pSql, pRes->numOfRows, pRes->offset);
 
   return 0;
 }
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 0ea4c64204cd56278234cec1448d75b72adb3840..467a95a9418329705052f853cb3d20dabadd84c5 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -36,11 +36,6 @@ TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const
 
   taos_init();
 
-  if (pTscMgmtConn == NULL || pVnodeConn == NULL) {
-    globalCode = TSDB_CODE_APP_ERROR;
-    return NULL;
-  }
-
   if (user == NULL) {
     globalCode = TSDB_CODE_INVALID_ACCT;
     return NULL;
@@ -63,15 +58,30 @@ TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const
     }
   }
 
+  if (tscInitRpc(user, pass) != 0) {
+    globalCode = TSDB_CODE_NETWORK_UNAVAIL;
+    return NULL;
+  }
+
   if (ip && ip[0]) {
-    tscMgmtIpList.numOfIps = 3;
-    tscMgmtIpList.ip[0] = inet_addr(ip);
-    tscMgmtIpList.ip[1] = inet_addr(tsMasterIp);
-    tscMgmtIpList.ip[2] = inet_addr(tsSecondIp);
     tscMgmtIpList.index = 0;
     tscMgmtIpList.port = tsMgmtShellPort;
+    tscMgmtIpList.numOfIps = 1;
+    tscMgmtIpList.ip[0] = inet_addr(ip);
+
+    if (tsMasterIp[0] && strcmp(ip, tsMasterIp) != 0) {
+      tscMgmtIpList.numOfIps = 2;
+      tscMgmtIpList.ip[1] = inet_addr(tsMasterIp);
+    }
+
+    if (tsSecondIp[0] && strcmp(tsSecondIp, tsMasterIp) != 0) {
+      tscMgmtIpList.numOfIps = 3;
+      tscMgmtIpList.ip[2] = inet_addr(tsSecondIp);
+    }
   }
 
+  tscMgmtIpList.port = port ? port : tsMgmtShellPort;
+
   pObj = (STscObj *)malloc(sizeof(STscObj));
   if (NULL == pObj) {
     globalCode = TSDB_CODE_CLI_OUT_OF_MEMORY;
@@ -208,7 +218,6 @@ int taos_query_imp(STscObj *pObj, SSqlObj *pSql) {
    * to free connection, which may cause segment fault, when the parse phrase is not even successfully executed.
    */
   pRes->qhandle = 0;
-  pSql->thandle = NULL;
 
   if (pRes->code == TSDB_CODE_SUCCESS) {
     tscDoQuery(pSql);
@@ -713,7 +722,6 @@ void taos_free_result_imp(TAOS_RES* res, int keepCmd) {
     /* Query rsp is not received from vnode, so the qhandle is NULL */
     tscTrace("%p qhandle is null, abort free, fp:%p", pSql, pSql->fp);
     if (pSql->fp != NULL) {
-      pSql->thandle = NULL;
       tscFreeSqlObj(pSql);
       tscTrace("%p Async SqlObj is freed by app", pSql);
     } else if (keepCmd) {
@@ -774,7 +782,6 @@ void taos_free_result_imp(TAOS_RES* res, int keepCmd) {
        *
        * Then this object will be reused and no free operation is required.
        */
-      pSql->thandle = NULL;
       if (keepCmd) {
         tscFreeSqlResult(pSql);
         tscTrace("%p sql result is freed by app while sql command is kept", pSql);
@@ -785,7 +792,6 @@ void taos_free_result_imp(TAOS_RES* res, int keepCmd) {
     }
   } else {
     // if no free resource msg is sent to vnode, we free this object immediately.
-    pSql->thandle = NULL;
 
     if (pSql->fp) {
       assert(pRes->numOfRows == 0 || (pCmd->command > TSDB_SQL_LOCAL));
@@ -899,11 +905,6 @@ void taos_stop_query(TAOS_RES *res) {
     return;
   }
 
-  if (pSql->thandle == NULL) {
-    tscTrace("%p no connection, abort cancel", res);
-    return;
-  }
-
   //taosStopRpcConn(pSql->thandle);
   tscTrace("%p query is cancelled", res);
 }
@@ -1147,7 +1148,6 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
    * to free connection, which may cause segment fault, when the parse phrase is not even successfully executed.
    */
   pRes->qhandle = 0;
-  pSql->thandle = NULL;
   free(str);
 
   if (pRes->code != TSDB_CODE_SUCCESS) {
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 610c119e6d327c9b8b372136959b07098ffaef2e..6bf53fae37c42f709f6c46415d4114fd2d8cfd60 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -382,7 +382,6 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
       pRes->numOfRows = 1;
       pRes->numOfTotal = 0;
       pRes->qhandle = 0;
-      pSql->thandle = NULL;
       pSql->cmd.command = TSDB_SQL_SELECT;
       pQueryInfo->type = type;
 
diff --git a/src/client/src/tscSystem.c b/src/client/src/tscSystem.c
index f411698bb7e6182c644aa28dbea93d8b9b844f54..f805bfa4a8d409b6c39ca81a4f7d3da6d15836f7 100644
--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
@@ -45,6 +45,7 @@ int     tsInsertHeadSize;
 extern int            tscEmbedded;
 int                   tscNumOfThreads;
 static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
+static pthread_mutex_t tscMutex;
 
 extern int  tsTscEnableRecordSql;
 extern int  tsNumOfLogLines;
@@ -56,11 +57,64 @@ void tscCheckDiskUsage(void *para, void *unused) {
   taosTmrReset(tscCheckDiskUsage, 1000, NULL, tscTmr, &tscCheckDiskUsageTmr);
 }
 
+int32_t tscInitRpc(const char *user, const char *secret) {
+  SRpcInit rpcInit;
+  char secretEncrypt[32] = {0};
+  taosEncryptPass((uint8_t *)secret, strlen(secret), secretEncrypt);
+
+  pthread_mutex_lock(&tscMutex);
+  if (pVnodeConn == NULL) {
+    memset(&rpcInit, 0, sizeof(rpcInit));
+    rpcInit.localIp = tsLocalIp;
+    rpcInit.localPort = 0;
+    rpcInit.label = "TSC-vnode";
+    rpcInit.numOfThreads = tscNumOfThreads;
+    rpcInit.cfp = tscProcessMsgFromServer;
+    rpcInit.sessions = tsMaxVnodeConnections;
+    rpcInit.connType = TAOS_CONN_CLIENT;
+    rpcInit.user = user;
+    rpcInit.ckey = "key";
+    rpcInit.secret = secretEncrypt;
+
+    pVnodeConn = rpcOpen(&rpcInit);
+    if (pVnodeConn == NULL) {
+      tscError("failed to init connection to vnode");
+      pthread_mutex_unlock(&tscMutex);
+      return -1;
+    }
+  }
+
+  if (pTscMgmtConn == NULL) {
+    memset(&rpcInit, 0, sizeof(rpcInit));
+    rpcInit.localIp = tsLocalIp;
+    rpcInit.localPort = 0;
+    rpcInit.label = "TSC-mgmt";
+    rpcInit.numOfThreads = 1;
+    rpcInit.cfp = tscProcessMsgFromServer;
+    rpcInit.sessions = tsMaxMgmtConnections;
+    rpcInit.connType = TAOS_CONN_CLIENT;
+    rpcInit.idleTime = 2000;
+    rpcInit.user = "root";
+    rpcInit.ckey = "key";
+    rpcInit.secret = secretEncrypt;
+
+    pTscMgmtConn = rpcOpen(&rpcInit);
+    if (pTscMgmtConn == NULL) {
+      tscError("failed to init connection to mgmt");
+      pthread_mutex_unlock(&tscMutex);
+      return -1;
+    }
+  }
+
+  pthread_mutex_unlock(&tscMutex);
+  return 0;
+}
+
 void taos_init_imp() {
   char        temp[128];
   struct stat dirstat;
-  SRpcInit    rpcInit;
 
+  pthread_mutex_init(&tscMutex, NULL);
   srand(taosGetTimestampSec());
   deltaToUtcInitOnce();
 
@@ -101,7 +155,7 @@ void taos_init_imp() {
   tscMgmtIpList.numOfIps = 1;
   tscMgmtIpList.ip[0] = inet_addr(tsMasterIp);
 
-  if (tsSecondIp[0]) {
+  if (tsSecondIp[0] && strcmp(tsSecondIp, tsMasterIp) != 0) {
     tscMgmtIpList.numOfIps = 2;
     tscMgmtIpList.ip[1] = inet_addr(tsSecondIp);
   }
@@ -124,34 +178,6 @@ void taos_init_imp() {
     return;
   }
 
-  memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.localIp = tsLocalIp;
-  rpcInit.localPort = 0;
-  rpcInit.label = "TSC-vnode";
-  rpcInit.numOfThreads = tscNumOfThreads;
-  rpcInit.afp = tscProcessMsgFromServer;
-  rpcInit.sessions = tsMaxVnodeConnections;
-  rpcInit.connType = TAOS_CONN_SOCKET_TYPE_C();
-  pVnodeConn = rpcOpen(&rpcInit);
-  if (pVnodeConn == NULL) {
-    tscError("failed to init connection to vnode");
-    return;
-  }
-
-  memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.localIp = tsLocalIp;
-  rpcInit.localPort = 0;
-  rpcInit.label = "TSC-mgmt";
-  rpcInit.numOfThreads = 1;
-  rpcInit.afp = tscProcessMsgFromServer;
-  rpcInit.sessions = tsMaxMgmtConnections;
-  rpcInit.connType = TAOS_CONN_SOCKET_TYPE_C();
-  pTscMgmtConn = rpcOpen(&rpcInit);
-  if (pTscMgmtConn == NULL) {
-    tscError("failed to init connection to mgmt");
-    return;
-  }
-
   tscTmr = taosTmrInit(tsMaxMgmtConnections * 2, 200, 60000, "TSC");
   if(0 == tscEmbedded){
     taosTmrReset(tscCheckDiskUsage, 10, NULL, tscTmr, &tscCheckDiskUsageTmr);      
@@ -319,10 +345,10 @@ static int taos_options_imp(TSDB_OPTION option, const char *pStr) {
       assert(cfg != NULL);
     
       if (cfg->cfgStatus <= TSDB_CFG_CSTATUS_OPTION) {
-        if (strcasecmp(pStr, TAOS_SOCKET_TYPE_NAME_UDP) != 0 && strcasecmp(pStr, TAOS_SOCKET_TYPE_NAME_TCP) != 0) {
-          tscError("only 'tcp' or 'udp' allowed for configuring the socket type");
-          return -1;
-        }
+//        if (strcasecmp(pStr, TAOS_SOCKET_TYPE_NAME_UDP) != 0 && strcasecmp(pStr, TAOS_SOCKET_TYPE_NAME_TCP) != 0) {
+//          tscError("only 'tcp' or 'udp' allowed for configuring the socket type");
+//          return -1;
+//        }
 
         strncpy(tsSocketType, pStr, tListLen(tsSocketType));
         cfg->cfgStatus = TSDB_CFG_CSTATUS_OPTION;
diff --git a/src/dnode/src/dnodeModule.c b/src/dnode/src/dnodeModule.c
index 70754cc6eb1ac16d463c7c0e2d84436d0c1357a5..96d0db5f6a0da50d0471d6c17e569c938e53d13d 100644
--- a/src/dnode/src/dnodeModule.c
+++ b/src/dnode/src/dnodeModule.c
@@ -121,10 +121,6 @@ void dnodeStartModulesImp() {
       }
     }
   }
-
-  if (tsModule[TSDB_MOD_MGMT].num != 0 && tsModule[TSDB_MOD_MGMT].cleanUpFp) {
-    (*tsModule[TSDB_MOD_MGMT].cleanUpFp)();
-  }
 }
 
 void (*dnodeStartModules)() = dnodeStartModulesImp;
diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c
index 164bc80a3576100993d95a193f949cedd4070e08..c7747f112e46133941dc0418880fa9f7c05001ee 100644
--- a/src/dnode/src/dnodeShell.c
+++ b/src/dnode/src/dnodeShell.c
@@ -85,7 +85,7 @@ int32_t dnodeInitShell() {
   rpcInit.numOfThreads = numOfThreads;
   rpcInit.cfp           = dnodeProcessMsgFromShell;
   rpcInit.sessions     = TSDB_SESSIONS_PER_DNODE;
-  rpcInit.connType     = TAOS_CONN_SOCKET_TYPE_S();
+  rpcInit.connType     = TAOS_CONN_SERVER;
   rpcInit.idleTime     = tsShellActivityTimer * 2000;
 
   tsDnodeShellServer = rpcOpen(&rpcInit);
diff --git a/src/inc/mnode.h b/src/inc/mnode.h
index 794e41cc6c741848e26af4f0ab88968fbfc26d6a..682e82bcaea09fb63c43adfe70879207dd2c7230 100644
--- a/src/inc/mnode.h
+++ b/src/inc/mnode.h
@@ -244,6 +244,8 @@ typedef struct _db_obj {
   void *          vgTimer;
 } SDbObj;
 
+struct _acctObj;
+
 typedef struct _user_obj {
   char              user[TSDB_USER_LEN + 1];
   char              pass[TSDB_KEY_LEN];
@@ -254,6 +256,9 @@ typedef struct _user_obj {
   char              reserved[16];
   char              updateEnd[1];
   struct _user_obj *prev, *next;
+  struct _acctObj * pAcct;
+  SCMQqueryList *   pQList;  // query list
+  SCMStreamList *   pSList;  // stream list
 } SUserObj;
 
 typedef struct {
@@ -274,7 +279,7 @@ typedef struct {
   char    accessState;  // Checked by mgmt heartbeat message
 } SAcctInfo;
 
-typedef struct {
+typedef struct _acctObj {
   char      user[TSDB_USER_LEN + 1];
   char      pass[TSDB_KEY_LEN];
   SAcctCfg  cfg;
@@ -290,28 +295,6 @@ typedef struct {
   pthread_mutex_t  mutex;
 } SAcctObj;
 
-typedef struct _connObj {
-  SAcctObj *       pAcct;
-  SDbObj *         pDb;
-  SUserObj *       pUser;
-  char             user[TSDB_USER_LEN];
-  uint64_t         stime;               // login time
-  char             superAuth : 1;       // super user flag
-  char             writeAuth : 1;       // write flag
-  char             killConnection : 1;  // kill the connection flag
-  uint8_t          usePublicIp : 1;     // if the connection request is publicIp
-  uint8_t          reserved : 4;
-  uint32_t         queryId;             // query ID to be killed
-  uint32_t         streamId;            // stream ID to be killed
-  uint32_t         ip;                  // shell IP
-  uint16_t         port;                // shell port
-  void *           thandle;
-  SQList *         pQList;  // query list
-  SSList *         pSList;  // stream list
-  uint64_t         qhandle;
-  struct _connObj *prev, *next;
-} SConnObj;
-
 typedef struct {
   char spi;
   char encrypt;
diff --git a/src/inc/sdb.h b/src/inc/sdb.h
index 7316fd7ef5275b8edc4a2a32ae6aaa543e78a9bd..d48adc5bbd0b1550a6aaafc5ee58e787ead3ad85 100644
--- a/src/inc/sdb.h
+++ b/src/inc/sdb.h
@@ -37,8 +37,8 @@ extern int      sdbExtConns;
 extern int      sdbMaster;
 extern uint32_t sdbPublicIp;
 extern uint32_t sdbMasterStartTime;
-extern SIpList *pSdbIpList;
-extern SIpList *pSdbPublicIpList;
+extern SRpcIpSet *pSdbIpList;
+extern SRpcIpSet *pSdbPublicIpList;
 
 extern void (*sdbWorkAsMasterCallback)();  // this function pointer will be set by taosd
 
@@ -71,8 +71,6 @@ enum _sdbaction {
   SDB_MAX_ACTION_TYPES
 };
 
-#ifdef CLUSTER
-
 #define SDB_MAX_PEERS 4
 typedef struct {
   uint32_t ip;
@@ -103,8 +101,6 @@ extern SSdbPeer *sdbPeer[];
 #define sdbInited (sdbPeer[0])
 #define sdbStatus (sdbPeer[0]->status)
 
-#endif
-
 void *sdbOpenTable(int maxRows, int32_t maxRowSize, char *name, uint8_t keyType, char *directory,
                    void *(*appTool)(char, void *, char *, int, int *));
 
@@ -138,6 +134,7 @@ int sdbCfgNode(char *cont);
 
 int64_t sdbGetVersion();
 
+int32_t sdbGetRunStatus();
 
 #define TSDB_MAX_TABLES 1000
 extern void* tsChildTableSdb;
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index bf4787c449e6796d1b28e8a728a87d2be69ebe28..2f5ceb72d11cddb513c3cafd2dd3c2775918dd0a 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -26,6 +26,7 @@ extern "C" {
 #include "taosdef.h"
 #include "taoserror.h"
 #include "taosdef.h"
+#include "trpc.h"
 
 // message type
 #define TSDB_MSG_TYPE_REG                    1
@@ -187,25 +188,8 @@ typedef enum {
 
 extern char *taosMsg[];
 
-#define TSDB_MSG_DEF_MAX_MPEERS        5
-#define TSDB_MSG_DEF_VERSION_LEN       64
-#define TSDB_MSG_DEF_DB_LEN            128
-#define TSDB_MSG_DEF_USER_LEN          128
-#define TSDB_MSG_DEF_TABLE_LEN         128
-#define TSDB_MSG_DEF_ACCT_LEN          128
-
 #pragma pack(push, 1)
 
-typedef struct {
-  char     numOfIps;
-  uint32_t ip[];
-} SIpList;
-
-typedef struct {
-  char     numOfIps;
-  uint32_t ip[TSDB_MAX_MGMT_IPS];
-} SMgmtIpList;
-
 typedef struct {
   uint32_t customerId;
   uint32_t osId;
@@ -332,20 +316,17 @@ typedef struct {
 } SAlterTableMsg;
 
 typedef struct {
-  char clientVersion[TSDB_MSG_DEF_VERSION_LEN];
-  char msgVersion[TSDB_MSG_DEF_VERSION_LEN];
-  char db[TSDB_MSG_DEF_DB_LEN];
+  char clientVersion[TSDB_VERSION_LEN];
+  char msgVersion[TSDB_VERSION_LEN];
+  char db[TSDB_TABLE_ID_LEN];
 } SCMConnectMsg;
 
 typedef struct {
-  char     acctId[TSDB_MSG_DEF_ACCT_LEN];
-  char     serverVersion[TSDB_MSG_DEF_VERSION_LEN];
-  int8_t   writeAuth;
-  int8_t   superAuth;
-  int16_t  index;
-  int16_t  numOfIps;
-  uint16_t port;
-  uint32_t ip[TSDB_MSG_DEF_MAX_MPEERS];
+  char      acctId[TSDB_ACCT_LEN];
+  char      serverVersion[TSDB_VERSION_LEN];
+  int8_t    writeAuth;
+  int8_t    superAuth;
+  SRpcIpSet ipList;
 } SCMConnectRsp;
 
 typedef struct {
@@ -799,19 +780,12 @@ typedef struct {
   char config[60];
 } SCfgMsg;
 
-typedef struct {
-  uint32_t queryId;
-  uint32_t streamId;
-  char     killConnection;
-  SIpList  ipList;
-} SHeartBeatRsp;
-
 typedef struct {
   char     sql[TSDB_SHOW_SQL_LEN];
   uint32_t queryId;
   int64_t  useconds;
   int64_t  stime;
-} SQDesc;
+} SCMQueryDesc;
 
 typedef struct {
   char     sql[TSDB_SHOW_SQL_LEN];
@@ -822,17 +796,29 @@ typedef struct {
   int64_t  stime;
   int64_t  slidingTime;
   int64_t  interval;
-} SSDesc;
+} SCMStreamDesc;
 
 typedef struct {
   int32_t numOfQueries;
-  SQDesc  qdesc[];
-} SQList;
+  SCMQueryDesc  qdesc[];
+} SCMQqueryList;
 
 typedef struct {
   int32_t numOfStreams;
-  SSDesc  sdesc[];
-} SSList;
+  SCMStreamDesc  sdesc[];
+} SCMStreamList;
+
+typedef struct {
+  SCMQqueryList qlist;
+  SCMStreamList slist;
+} SCMHeartBeatMsg;
+
+typedef struct {
+  uint32_t  queryId;
+  uint32_t  streamId;
+  int8_t    killConnection;
+  SRpcIpSet ipList;
+} SCMHeartBeatRsp;
 
 typedef struct {
   uint64_t handle;
diff --git a/src/inc/trpc.h b/src/inc/trpc.h
index 121bb183827fdb8205c56524470929cabe41e0a7..4cf94a993b50a2d8484b7186c995f25ba3b145ec 100644
--- a/src/inc/trpc.h
+++ b/src/inc/trpc.h
@@ -39,7 +39,7 @@ typedef struct {
   uint32_t  clientIp;
   uint16_t  clientPort;
   uint32_t  serverIp;
-  char     *user;
+  char      user[TSDB_USER_LEN];
 } SRpcConnInfo;
 
 typedef struct {
diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c
index 27a4aaaa0cd24d84b46003ec3195f130d3ee8c85..22af4ca5c3d7a9514b0d604757b92e2b72cc952b 100644
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -800,6 +800,8 @@ void source_file(TAOS *con, char *fptr) {
 }
 
 void shellGetGrantInfo(void *con) {
+  return;
+
   char sql[] = "show grants";
 
   int code = taos_query(con, sql);
diff --git a/src/kit/shell/src/shellMain.c b/src/kit/shell/src/shellMain.c
index a7b7e8383bafab2f76682488d131c0d2bfbe65d3..8c060295e13fa1c03c596b9bab12e1efb2318158 100644
--- a/src/kit/shell/src/shellMain.c
+++ b/src/kit/shell/src/shellMain.c
@@ -81,7 +81,7 @@ struct arguments args = {
  */
 int main(int argc, char* argv[]) {
   /*setlocale(LC_ALL, "en_US.UTF-8"); */
-
+  
   if (!checkVersion()) {
     exit(EXIT_FAILURE);
   }
diff --git a/src/mnode/inc/mgmtAcct.h b/src/mnode/inc/mgmtAcct.h
index edffebaddc85df1345b7f5a9c41970330596512e..8aef8cf658dff0602bf0d88a53e008ccf8f4b7c7 100644
--- a/src/mnode/inc/mgmtAcct.h
+++ b/src/mnode/inc/mgmtAcct.h
@@ -34,8 +34,8 @@ extern int32_t   (*mgmtCheckDbLimit)(SAcctObj *pAcct);
 extern int32_t   (*mgmtCheckTableLimit)(SAcctObj *pAcct, SCreateTableMsg *pCreate);
 extern void      (*mgmtCheckAcct)();
 extern void      (*mgmtCleanUpAccts)();
-extern int32_t   (*mgmtGetAcctMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-extern int32_t   (*mgmtRetrieveAccts)(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+extern int32_t   (*mgmtGetAcctMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+extern int32_t   (*mgmtRetrieveAccts)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 #ifdef __cplusplus
 }
diff --git a/src/mnode/inc/mgmtConn.h b/src/mnode/inc/mgmtConn.h
index 550cf6c20d2c10f20082281186c831cc642294f1..93de283036fe5a32d918ace5276f2cf457d5f7ce 100644
--- a/src/mnode/inc/mgmtConn.h
+++ b/src/mnode/inc/mgmtConn.h
@@ -22,8 +22,8 @@ extern "C" {
 
 #include "mnode.h"
 
-int mgmtGetConnsMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int mgmtRetrieveConns(SShowObj *pShow, char *data, int rows, SConnObj *pConn);
+int mgmtGetConnsMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int mgmtRetrieveConns(SShowObj *pShow, char *data, int rows, void *pConn);
 
 #ifdef __cplusplus
 }
diff --git a/src/mnode/inc/mgmtDb.h b/src/mnode/inc/mgmtDb.h
index 20575e21822de58c02938c720e1807401a66062b..56738d9ac2d1d2382f0a42b72650f16fe61f3fe3 100644
--- a/src/mnode/inc/mgmtDb.h
+++ b/src/mnode/inc/mgmtDb.h
@@ -24,14 +24,13 @@ extern "C" {
 
 void    mgmtMonitorDbDrop(void *unused, void *unusedt);
 int32_t mgmtAlterDb(SAcctObj *pAcct, SAlterDbMsg *pAlter);
-int32_t mgmtUseDb(SConnObj *pConn, char *name);
 int32_t mgmtAddVgroupIntoDb(SDbObj *pDb, SVgObj *pVgroup);
 int32_t mgmtAddVgroupIntoDbTail(SDbObj *pDb, SVgObj *pVgroup);
 int32_t mgmtRemoveVgroupFromDb(SDbObj *pDb, SVgObj *pVgroup);
 int32_t mgmtMoveVgroupToTail(SDbObj *pDb, SVgObj *pVgroup);
 int32_t mgmtMoveVgroupToHead(SDbObj *pDb, SVgObj *pVgroup);
-int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 void    mgmtCleanUpDbs();
 
 int32_t mgmtInitDbs();
diff --git a/src/mnode/inc/mgmtDnode.h b/src/mnode/inc/mgmtDnode.h
index 325ef5bb71fba64ba59755f4b1a65058e943165f..8cf6a2b274b5e9f03984434b1b6661062ec4f7c1 100644
--- a/src/mnode/inc/mgmtDnode.h
+++ b/src/mnode/inc/mgmtDnode.h
@@ -30,19 +30,19 @@ int32_t mgmtDropDnodeByIp(uint32_t ip);
 int32_t mgmtGetNextVnode(SVnodeGid *pVnodeGid);
 void    mgmtSetDnodeVgid(SVnodeGid vnodeGid[], int32_t numOfVnodes, int32_t vgId);
 void    mgmtUnSetDnodeVgid(SVnodeGid vnodeGid[], int32_t numOfVnodes);
-int32_t mgmtGetDnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t mgmtGetDnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 int32_t mgmtSendCfgDnodeMsg(char *cont);
 void    mgmtSetDnodeMaxVnodes(SDnodeObj *pDnode);
 
-int32_t mgmtGetConfigMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t mgmtGetConfigMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
-int32_t mgmtGetModuleMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t mgmtGetModuleMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
-int32_t mgmtGetVnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t mgmtGetVnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 extern int32_t    (*mgmtInitDnodes)();
 extern void       (*mgmtCleanUpDnodes)();
@@ -51,8 +51,8 @@ extern int32_t    (*mgmtGetDnodesNum)();
 extern void*      (*mgmtGetNextDnode)(SShowObj *pShow, SDnodeObj **pDnode);
 extern int32_t    (*mgmtUpdateDnode)(SDnodeObj *pDnode);
 extern void       (*mgmtSetDnodeUnRemove)(SDnodeObj *pDnode);
-extern int32_t    (*mgmtGetScoresMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-extern int32_t    (*mgmtRetrieveScores)(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+extern int32_t    (*mgmtGetScoresMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+extern int32_t    (*mgmtRetrieveScores)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 extern bool       (*mgmtCheckConfigShow)(SGlobalConfig *cfg);
 
 extern SDnodeObj tsDnodeObj;
diff --git a/src/mnode/inc/mgmtGrant.h b/src/mnode/inc/mgmtGrant.h
index d8ae27430e630f765a559277b932c6ce6f277e00..b57962540fcfc05535e43d16a4335080a646af6c 100644
--- a/src/mnode/inc/mgmtGrant.h
+++ b/src/mnode/inc/mgmtGrant.h
@@ -30,8 +30,8 @@ extern void    (*mgmtRestoreTimeSeries)(uint32_t timeseries);
 extern int32_t (*mgmtCheckTimeSeries)(uint32_t timeseries);
 extern int32_t (*mgmtCheckUserGrant)();
 extern int32_t (*mgmtCheckDbGrant)();
-extern int32_t (*mgmtGetGrantsMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-extern int32_t (*mgmtRetrieveGrants)(SShowObj *pShow, char *data, int rows, SConnObj *pConn);
+extern int32_t (*mgmtGetGrantsMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+extern int32_t (*mgmtRetrieveGrants)(SShowObj *pShow, char *data, int rows, void *pConn);
 
 #ifdef __cplusplus
 }
diff --git a/src/mnode/inc/mgmtMnode.h b/src/mnode/inc/mgmtMnode.h
index 94ec307c43e23c70a00b7ab29adf5a1ed29acc51..f7848ffad1ea39f04ef94a8a923567fc2cd13d9d 100644
--- a/src/mnode/inc/mgmtMnode.h
+++ b/src/mnode/inc/mgmtMnode.h
@@ -24,8 +24,8 @@ extern "C" {
 #include <stdbool.h>
 #include "mnode.h"
 
-extern int32_t (*mgmtGetMnodeMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-extern int32_t (*mgmtRetrieveMnodes)(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+extern int32_t (*mgmtGetMnodeMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+extern int32_t (*mgmtRetrieveMnodes)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 #ifdef __cplusplus
 }
diff --git a/src/mnode/inc/mgmtProfile.h b/src/mnode/inc/mgmtProfile.h
index 6d5a08c4bb51d827f16b4b83f85f2bc1a23241a5..bb5e518cc7e6bc7b3a46e07492fae014dd945a78 100644
--- a/src/mnode/inc/mgmtProfile.h
+++ b/src/mnode/inc/mgmtProfile.h
@@ -22,21 +22,21 @@ extern "C" {
 
 #include "mnode.h"
 
-int mgmtGetQueryMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
+int32_t mgmtGetQueryMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
 
-int mgmtGetStreamMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
+int32_t mgmtGetStreamMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
 
-int mgmtRetrieveQueries(SShowObj *pShow, char *data, int rows, SConnObj *pConn);
+int32_t mgmtRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
-int mgmtRetrieveStreams(SShowObj *pShow, char *data, int rows, SConnObj *pConn);
+int32_t mgmtRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
-int mgmtSaveQueryStreamList(char *cont, int contLen, SConnObj *pConn);
+int32_t mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg);
 
-int mgmtKillQuery(char *qidstr, SConnObj *pConn);
+int32_t mgmtKillQuery(char *qidstr, void *pConn);
 
-int mgmtKillStream(char *qidstr, SConnObj *pConn);
+int32_t mgmtKillStream(char *qidstr, void *pConn);
 
-int mgmtKillConnection(char *qidstr, SConnObj *pConn);
+int32_t mgmtKillConnection(char *qidstr, void *pConn);
 
 #ifdef __cplusplus
 }
diff --git a/src/mnode/inc/mgmtShell.h b/src/mnode/inc/mgmtShell.h
index 529a4396045cb0b17528c07c8e01d1ec4ba2713e..b530fe01ba15bcb43f3d44b0e225a53738e02603 100644
--- a/src/mnode/inc/mgmtShell.h
+++ b/src/mnode/inc/mgmtShell.h
@@ -27,14 +27,14 @@ extern "C" {
 int32_t  mgmtInitShell();
 void mgmtCleanUpShell();
 
-extern int32_t (*mgmtCheckRedirectMsg)(SConnObj *pConn, int32_t msgType);
-extern int32_t (*mgmtProcessAlterAcctMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn);
-extern int32_t (*mgmtProcessCreateDnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn);
-extern int32_t (*mgmtProcessCfgMnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn);
-extern int32_t (*mgmtProcessDropMnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn);
-extern int32_t (*mgmtProcessDropDnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn);
-extern int32_t (*mgmtProcessDropAcctMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn);
-extern int32_t (*mgmtProcessCreateAcctMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn);
+extern int32_t (*mgmtCheckRedirectMsg)(void *pConn, int32_t msgType);
+extern int32_t (*mgmtProcessAlterAcctMsg)(void *pCont, int32_t contLen, void *ahandle);
+extern int32_t (*mgmtProcessCreateDnodeMsg)(void *pCont, int32_t contLen, void *ahandle);
+extern int32_t (*mgmtProcessCfgMnodeMsg)(void *pCont, int32_t contLen, void *ahandle);
+extern int32_t (*mgmtProcessDropMnodeMsg)(void *pCont, int32_t contLen, void *ahandle);
+extern int32_t (*mgmtProcessDropDnodeMsg)(void *pCont, int32_t contLen, void *ahandle);
+extern int32_t (*mgmtProcessDropAcctMsg)(void *pCont, int32_t contLen, void *ahandle);
+extern int32_t (*mgmtProcessCreateAcctMsg)(void *pCont, int32_t contLen, void *ahandle);
 
 #ifdef __cplusplus
 }
diff --git a/src/mnode/inc/mgmtTable.h b/src/mnode/inc/mgmtTable.h
index 0b5b7636fda7e13ead5e095b174f5de48fcc93b3..9a3417318586fed7f54d7af0bfe8bc0d62f94381 100644
--- a/src/mnode/inc/mgmtTable.h
+++ b/src/mnode/inc/mgmtTable.h
@@ -29,18 +29,18 @@ int32_t     mgmtInitTables();
 STableInfo* mgmtGetTable(char *tableId);
 STableInfo* mgmtGetTableByPos(uint32_t dnodeIp, int32_t vnode, int32_t sid);
 
-int32_t  mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SSuperTableMetaMsg *pInfo);
+int32_t  mgmtRetrieveMetricMeta(void *pConn, char **pStart, SSuperTableMetaMsg *pInfo);
 int32_t  mgmtCreateTable(SDbObj *pDb, SCreateTableMsg *pCreate);
 int32_t  mgmtDropTable(SDbObj *pDb, char *meterId, int32_t ignore);
 int32_t  mgmtAlterTable(SDbObj *pDb, SAlterTableMsg *pAlter);
-int32_t  mgmtGetTableMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t  mgmtRetrieveTables(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t  mgmtGetTableMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t  mgmtRetrieveTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 void     mgmtCleanUpMeters();
 
 void    mgmtAddTableIntoSuperTable(SSuperTableObj *pStable);
 void    mgmtRemoveTableFromSuperTable(SSuperTableObj *pStable);
-int32_t mgmtGetSuperTableMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t mgmtRetrieveSuperTables(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t mgmtGetSuperTableMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t mgmtRetrieveSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 
 
diff --git a/src/mnode/inc/mgmtUser.h b/src/mnode/inc/mgmtUser.h
index 2977d688f7dadf5f05afeedc5df25a89abbc97d9..946cd5103a9e06d6c15d40738b46dde40e5cc867 100644
--- a/src/mnode/inc/mgmtUser.h
+++ b/src/mnode/inc/mgmtUser.h
@@ -29,9 +29,10 @@ SUserObj *mgmtGetUser(char *name);
 int32_t   mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass);
 int32_t   mgmtDropUser(SAcctObj *pAcct, char *name);
 int32_t   mgmtUpdateUser(SUserObj *pUser);
-int32_t   mgmtGetUserMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t   mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t   mgmtGetUserMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t   mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 void      mgmtCleanUpUsers();
+SUserObj *mgmtGetUserFromConn(void *pConn);
 
 #ifdef __cplusplus
 }
diff --git a/src/mnode/inc/mgmtVgroup.h b/src/mnode/inc/mgmtVgroup.h
index 845da4e159c91a5dcfff8ec3622395ba1cf69b2e..79947038dd10493a461307062bee91685c97f7e7 100644
--- a/src/mnode/inc/mgmtVgroup.h
+++ b/src/mnode/inc/mgmtVgroup.h
@@ -29,8 +29,8 @@ SVgObj *mgmtGetVgroup(int32_t vgId);
 SVgObj *mgmtCreateVgroup(SDbObj *pDb);
 int32_t mgmtDropVgroup(SDbObj *pDb, SVgObj *pVgroup);
 void    mgmtSetVgroupIdPool();
-int32_t mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+int32_t mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 void    mgmtCleanUpVgroups();
 
 SVgObj *mgmtGetAvailVgroup(SDbObj *pDb);
diff --git a/src/mnode/src/mgmtAcct.c b/src/mnode/src/mgmtAcct.c
index 17d20b67cce73aa6dc4d18979f7541381060075f..297898be2489063b2133491d4be6efc4d0533145 100644
--- a/src/mnode/src/mgmtAcct.c
+++ b/src/mnode/src/mgmtAcct.c
@@ -153,14 +153,14 @@ void mgmtCleanUpAcctsImp() {
 
 void (*mgmtCleanUpAccts)() = mgmtCleanUpAcctsImp;
 
-int32_t mgmtGetAcctMetaImp(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetAcctMetaImp(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   return TSDB_CODE_OPS_NOT_SUPPORT;
 }
 
-int32_t (*mgmtGetAcctMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) = mgmtGetAcctMetaImp;
+int32_t (*mgmtGetAcctMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) = mgmtGetAcctMetaImp;
 
-int32_t mgmtRetrieveAcctsImp(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveAcctsImp(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   return 0;
 }
 
-int32_t (*mgmtRetrieveAccts)(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) = mgmtRetrieveAcctsImp;
+int32_t (*mgmtRetrieveAccts)(SShowObj *pShow, char *data, int32_t rows, void *pConn) = mgmtRetrieveAcctsImp;
diff --git a/src/mnode/src/mgmtConn.c b/src/mnode/src/mgmtConn.c
index 9314d0b479af54d594c56a0193bc0840030a5411..86448b220bd5d1bf323a1dbf3e2930dc769a5e2b 100644
--- a/src/mnode/src/mgmtConn.c
+++ b/src/mnode/src/mgmtConn.c
@@ -32,42 +32,42 @@ typedef struct {
   SConnInfo connInfo[];
 } SConnShow;
 
-int mgmtGetConns(SShowObj *pShow, SConnObj *pConn) {
-  SAcctObj * pAcct = pConn->pAcct;
-  SConnShow *pConnShow;
-
-  pthread_mutex_lock(&pAcct->mutex);
-
-  pConnShow = malloc(sizeof(SConnInfo) * pAcct->acctInfo.numOfConns + sizeof(SConnShow));
-  pConnShow->index = 0;
-  pConnShow->numOfConns = 0;
-
-  if (pAcct->acctInfo.numOfConns > 0) {
-    pConn = pAcct->pConn;
-    SConnInfo *pConnInfo = pConnShow->connInfo;
-
-    while (pConn && pConn->pUser) {
-      strcpy(pConnInfo->user, pConn->pUser->user);
-      pConnInfo->ip = pConn->ip;
-      pConnInfo->port = pConn->port;
-      pConnInfo->stime = pConn->stime;
-
-      pConnShow->numOfConns++;
-      pConnInfo++;
-      pConn = pConn->next;
-    }
-  }
-
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  // sorting based on useconds
-
-  pShow->pNode = pConnShow;
+int mgmtGetConns(SShowObj *pShow, void *pConn) {
+//  SAcctObj * pAcct = pConn->pAcct;
+//  SConnShow *pConnShow;
+//
+//  pthread_mutex_lock(&pAcct->mutex);
+//
+//  pConnShow = malloc(sizeof(SConnInfo) * pAcct->acctInfo.numOfConns + sizeof(SConnShow));
+//  pConnShow->index = 0;
+//  pConnShow->numOfConns = 0;
+//
+//  if (pAcct->acctInfo.numOfConns > 0) {
+//    pConn = pAcct->pConn;
+//    SConnInfo *pConnInfo = pConnShow->connInfo;
+//
+//    while (pConn && pConn->pUser) {
+//      strcpy(pConnInfo->user, pConn->pUser->user);
+//      pConnInfo->ip = pConn->ip;
+//      pConnInfo->port = pConn->port;
+//      pConnInfo->stime = pConn->stime;
+//
+//      pConnShow->numOfConns++;
+//      pConnInfo++;
+//      pConn = pConn->next;
+//    }
+//  }
+//
+//  pthread_mutex_unlock(&pAcct->mutex);
+//
+//  // sorting based on useconds
+//
+//  pShow->pNode = pConnShow;
 
   return 0;
 }
 
-int mgmtGetConnsMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int mgmtGetConnsMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   int cols = 0;
 
   pShow->bytes[cols] = TSDB_METER_NAME_LEN;
@@ -104,7 +104,7 @@ int mgmtGetConnsMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   return 0;
 }
 
-int mgmtRetrieveConns(SShowObj *pShow, char *data, int rows, SConnObj *pConn) {
+int mgmtRetrieveConns(SShowObj *pShow, char *data, int rows, void *pConn) {
   int   numOfRows = 0;
   char *pWrite;
   int   cols = 0;
diff --git a/src/mnode/src/mgmtDb.c b/src/mnode/src/mgmtDb.c
index 379f678ac1e0e7921b4c12988b420a362ac4cf3d..c90a70bbdcb679ed0ad4914264a2881d9ca60c5d 100644
--- a/src/mnode/src/mgmtDb.c
+++ b/src/mnode/src/mgmtDb.c
@@ -26,6 +26,7 @@
 #include "mgmtDnodeInt.h"
 #include "mgmtGrant.h"
 #include "mgmtTable.h"
+#include "mgmtUser.h"
 #include "mgmtVgroup.h"
 
 extern void *tsVgroupSdb;
@@ -472,20 +473,6 @@ int32_t mgmtAlterDb(SAcctObj *pAcct, SAlterDbMsg *pAlter) {
   return code;
 }
 
-int32_t mgmtUseDb(SConnObj *pConn, char *name) {
-  SDbObj  *pDb;
-  int32_t code = TSDB_CODE_INVALID_DB;
-
-  // here change the default db for connect.
-  pDb = mgmtGetDb(name);
-  if (pDb) {
-    pConn->pDb = pDb;
-    code = 0;
-  }
-
-  return code;
-}
-
 int32_t mgmtAddVgroupIntoDb(SDbObj *pDb, SVgObj *pVgroup) {
   pVgroup->next = pDb->pHead;
   pVgroup->prev = NULL;
@@ -540,10 +527,12 @@ void mgmtCleanUpDbs() {
   sdbCloseTable(tsDbSdb);
 }
 
-int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
   SSchema *pSchema = tsGetSchema(pMeta);
+  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  if (pUser == NULL) return 0;
 
   pShow->bytes[cols] = TSDB_DB_NAME_LEN;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
@@ -564,7 +553,7 @@ int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   cols++;
 
 #ifndef __CLOUD_VERSION__
-  if (strcmp(pConn->pAcct->user, "root") == 0) {
+  if (strcmp(pUser->user, "root") == 0) {
 #endif
     pShow->bytes[cols] = 4;
     pSchema[cols].type = TSDB_DATA_TYPE_INT;
@@ -576,7 +565,7 @@ int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
 #endif
 
 #ifndef __CLOUD_VERSION__
-  if (strcmp(pConn->pAcct->user, "root") == 0) {
+  if (strcmp(pUser->user, "root") == 0) {
 #endif
     pShow->bytes[cols] = 2;
     pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
@@ -600,7 +589,7 @@ int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   cols++;
 
 #ifndef __CLOUD_VERSION__
-  if (strcmp(pConn->pAcct->user, "root") == 0) {
+  if (strcmp(pUser->user, "root") == 0) {
 #endif
     pShow->bytes[cols] = 4;
     pSchema[cols].type = TSDB_DATA_TYPE_INT;
@@ -675,8 +664,8 @@ int32_t mgmtGetDbMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
 
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
-  pShow->numOfRows = pConn->pAcct->acctInfo.numOfDbs;
-  pShow->pNode = pConn->pAcct->pHead;
+  pShow->numOfRows = pUser->pAcct->acctInfo.numOfDbs;
+  pShow->pNode = pUser->pAcct->pHead;
 
   return 0;
 }
@@ -687,18 +676,20 @@ char *mgmtGetDbStr(char *src) {
   return ++pos;
 }
 
-int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows = 0;
   SDbObj *pDb = NULL;
   char *  pWrite;
   int32_t cols = 0;
+  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  if (pUser == NULL) return 0;
 
   while (numOfRows < rows) {
     pDb = (SDbObj *)pShow->pNode;
     if (pDb == NULL) break;
     pShow->pNode = (void *)pDb->next;
     if (mgmtCheckIsMonitorDB(pDb->name, tsMonitorDbName)) {
-      if (strcmp(pConn->pUser->user, "root") != 0 && strcmp(pConn->pUser->user, "_root") != 0 && strcmp(pConn->pUser->user, "monitor") != 0 ) {
+      if (strcmp(pUser->user, "root") != 0 && strcmp(pUser->user, "_root") != 0 && strcmp(pUser->user, "monitor") != 0 ) {
         continue;
       }
     }
@@ -718,7 +709,7 @@ int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, SConnObj *pCo
     cols++;
 
 #ifndef __CLOUD_VERSION__
-    if (strcmp(pConn->pAcct->user, "root") == 0) {
+    if (strcmp(pUser->user, "root") == 0) {
 #endif
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
       *(int32_t *)pWrite = pDb->numOfVgroups;
@@ -728,7 +719,7 @@ int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, SConnObj *pCo
 #endif
 
 #ifndef __CLOUD_VERSION__
-    if (strcmp(pConn->pAcct->user, "root") == 0) {
+    if (strcmp(pUser->user, "root") == 0) {
 #endif
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
       *(int16_t *)pWrite = pDb->cfg.replications;
@@ -746,7 +737,7 @@ int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, SConnObj *pCo
     cols++;
 
 #ifndef __CLOUD_VERSION__
-    if (strcmp(pConn->pAcct->user, "root") == 0) {
+    if (strcmp(pUser->user, "root") == 0) {
 #endif
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
       *(int32_t *)pWrite = pDb->cfg.maxSessions - 1;  // table num can be created should minus 1
diff --git a/src/mnode/src/mgmtDnode.c b/src/mnode/src/mgmtDnode.c
index ba5c29452709108aa16984b0ee3655765a68744d..f180b12af3d888d4e560d7d4af3f8b0c34d7cec1 100644
--- a/src/mnode/src/mgmtDnode.c
+++ b/src/mnode/src/mgmtDnode.c
@@ -21,6 +21,7 @@
 #include "mnode.h"
 #include "mgmtDnode.h"
 #include "mgmtBalance.h"
+#include "mgmtUser.h"
 
 SDnodeObj tsDnodeObj;
 
@@ -96,10 +97,13 @@ void mgmtUnSetDnodeVgid(SVnodeGid vnodeGid[], int32_t numOfVnodes) {
   }
 }
 
-int32_t mgmtGetDnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetDnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
-  if (strcmp(pConn->pAcct->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
+  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  if (pUser == NULL) return 0;
+
+  if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -158,7 +162,7 @@ int32_t mgmtGetDnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t   numOfRows = 0;
   SDnodeObj *pDnode   = NULL;
   char      *pWrite;
@@ -208,10 +212,13 @@ int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, SConnObj *
   return numOfRows;
 }
 
-int32_t mgmtGetModuleMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetModuleMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
-  if (strcmp(pConn->pAcct->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
+  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  if (pUser == NULL) return 0;
+
+  if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -259,7 +266,7 @@ int32_t mgmtGetModuleMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t    numOfRows = 0;
   SDnodeObj *pDnode = NULL;
   char *     pWrite;
@@ -298,10 +305,13 @@ int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, SConnObj
   return numOfRows;
 }
 
-int32_t mgmtGetConfigMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetConfigMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
-  if (strcmp(pConn->pAcct->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
+  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  if (pUser == NULL) return 0;
+
+  if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -336,7 +346,7 @@ int32_t mgmtGetConfigMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows = 0;
 
   for (int32_t i = tsGlobalConfigNum - 1; i >= 0 && numOfRows < rows; --i) {
@@ -383,10 +393,11 @@ int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, SConnObj
   return numOfRows;
 }
 
-int32_t mgmtGetVnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetVnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
-
-  if (strcmp(pConn->pAcct->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
+  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  if (pUser == NULL) return 0;
+  if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -456,7 +467,7 @@ int32_t mgmtGetVnodeMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t        numOfRows = 0;
   SDnodeObj *pDnode = NULL;
   char *     pWrite;
@@ -560,17 +571,17 @@ void *mgmtGetNextDnodeImp(SShowObj *pShow, SDnodeObj **pDnode) {
 
 void *(*mgmtGetNextDnode)(SShowObj *pShow, SDnodeObj **pDnode) = mgmtGetNextDnodeImp;
 
-int32_t mgmtGetScoresMetaImp(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetScoresMetaImp(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   return TSDB_CODE_OPS_NOT_SUPPORT;
 }
 
-int32_t (*mgmtGetScoresMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) = mgmtGetScoresMetaImp;
+int32_t (*mgmtGetScoresMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) = mgmtGetScoresMetaImp;
 
-int32_t mgmtRetrieveScoresImp(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveScoresImp(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   return 0;
 }
 
-int32_t (*mgmtRetrieveScores)(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) = mgmtRetrieveScoresImp;
+int32_t (*mgmtRetrieveScores)(SShowObj *pShow, char *data, int32_t rows, void *pConn) = mgmtRetrieveScoresImp;
 
 void mgmtSetDnodeUnRemoveImp(SDnodeObj *pDnode) {
 }
diff --git a/src/mnode/src/mgmtGrant.c b/src/mnode/src/mgmtGrant.c
index 8beeae154d5ec0737f97b56a7c6768aae24bd488..3fe0b4fd5c19966fa0618f5d0121b3e5382dae6e 100644
--- a/src/mnode/src/mgmtGrant.c
+++ b/src/mnode/src/mgmtGrant.c
@@ -37,9 +37,9 @@ int32_t (*mgmtCheckTimeSeries)(uint32_t timeseries) = mgmtCheckTimeSeriesImp;
 bool mgmtCheckExpiredImp() { return false; }
 bool (*mgmtCheckExpired)() = mgmtCheckExpiredImp;
 
-int32_t mgmtGetGrantsMetaImp(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) { return TSDB_CODE_OPS_NOT_SUPPORT; }
-int32_t (*mgmtGetGrantsMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) = mgmtGetGrantsMetaImp;
+int32_t mgmtGetGrantsMetaImp(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) { return TSDB_CODE_OPS_NOT_SUPPORT; }
+int32_t (*mgmtGetGrantsMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) = mgmtGetGrantsMetaImp;
 
-int32_t mgmtRetrieveGrantsImp(SShowObj *pShow, char *data, int rows, SConnObj *pConn) { return 0; }
-int32_t (*mgmtRetrieveGrants)(SShowObj *pShow, char *data, int rows, SConnObj *pConn) = mgmtRetrieveGrantsImp;
+int32_t mgmtRetrieveGrantsImp(SShowObj *pShow, char *data, int rows, void *pConn) { return 0; }
+int32_t (*mgmtRetrieveGrants)(SShowObj *pShow, char *data, int rows, void *pConn) = mgmtRetrieveGrantsImp;
 
diff --git a/src/mnode/src/mgmtMnode.c b/src/mnode/src/mgmtMnode.c
index eda22b09ebfebce8af010e6f4a521a1ae0dd912d..cda45196851a6aa8ef2f13ba5d5f6d3b9c36e6cc 100644
--- a/src/mnode/src/mgmtMnode.c
+++ b/src/mnode/src/mgmtMnode.c
@@ -16,14 +16,14 @@
 #define _DEFAULT_SOURCE
 #include "mgmtMnode.h"
 
-int32_t mgmtGetMnodeMetaImp(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
+int32_t mgmtGetMnodeMetaImp(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
   return TSDB_CODE_OPS_NOT_SUPPORT;
 }
 
-int32_t (*mgmtGetMnodeMeta)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) = mgmtGetMnodeMetaImp;
+int32_t (*mgmtGetMnodeMeta)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) = mgmtGetMnodeMetaImp;
 
-int32_t mgmtRetrieveMnodesImp(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveMnodesImp(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   return 0;
 }
 
-int32_t (*mgmtRetrieveMnodes)(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) = mgmtRetrieveMnodesImp;
+int32_t (*mgmtRetrieveMnodes)(SShowObj *pShow, char *data, int32_t rows, void *pConn) = mgmtRetrieveMnodesImp;
diff --git a/src/mnode/src/mgmtProfile.c b/src/mnode/src/mgmtProfile.c
index 298767d2eae8b674141f5a529929bb338b01b60d..64d0c9467ce1c753767b8606b1a08f913bfae439 100644
--- a/src/mnode/src/mgmtProfile.c
+++ b/src/mnode/src/mgmtProfile.c
@@ -28,97 +28,97 @@ typedef struct {
 } SCDesc;
 
 typedef struct {
-  int      index;
-  int      numOfQueries;
+  int32_t      index;
+  int32_t      numOfQueries;
   SCDesc * connInfo;
   SCDesc **cdesc;
-  SQDesc   qdesc[];
+  SCMQueryDesc   qdesc[];
 } SQueryShow;
 
 typedef struct {
-  int      index;
-  int      numOfStreams;
+  int32_t      index;
+  int32_t      numOfStreams;
   SCDesc * connInfo;
   SCDesc **cdesc;
-  SSDesc   sdesc[];
+  SCMStreamDesc   sdesc[];
 } SStreamShow;
 
-int mgmtSaveQueryStreamList(char *cont, int contLen, SConnObj *pConn) {
-  SAcctObj *pAcct = pConn->pAcct;
-
-  if (contLen <= 0 || pAcct == NULL) {
-    return 0;
-  }
-
-  pthread_mutex_lock(&pAcct->mutex);
-
-  if (pConn->pQList) {
-    pAcct->acctInfo.numOfQueries -= pConn->pQList->numOfQueries;
-    pAcct->acctInfo.numOfStreams -= pConn->pSList->numOfStreams;
-  }
-
-  pConn->pQList = realloc(pConn->pQList, contLen);
-  memcpy(pConn->pQList, cont, contLen);
-
-  pConn->pSList = (SSList *)(((char *)pConn->pQList) + pConn->pQList->numOfQueries * sizeof(SQDesc) + sizeof(SQList));
-
-  pAcct->acctInfo.numOfQueries += pConn->pQList->numOfQueries;
-  pAcct->acctInfo.numOfStreams += pConn->pSList->numOfStreams;
-
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  return 0;
+int32_t  mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg) {
+//  SAcctObj *pAcct = pConn->pAcct;
+//
+//  if (contLen <= 0 || pAcct == NULL) {
+//    return 0;
+//  }
+//
+//  pthread_mutex_lock(&pAcct->mutex);
+//
+//  if (pConn->pQList) {
+//    pAcct->acctInfo.numOfQueries -= pConn->pQList->numOfQueries;
+//    pAcct->acctInfo.numOfStreams -= pConn->pSList->numOfStreams;
+//  }
+//
+//  pConn->pQList = realloc(pConn->pQList, contLen);
+//  memcpy(pConn->pQList, cont, contLen);
+//
+//  pConn->pSList = (SCMStreamList *)(((char *)pConn->pQList) + pConn->pQList->numOfQueries * sizeof(SCMQueryDesc) + sizeof(SCMQqueryList));
+//
+//  pAcct->acctInfo.numOfQueries += pConn->pQList->numOfQueries;
+//  pAcct->acctInfo.numOfStreams += pConn->pSList->numOfStreams;
+//
+//  pthread_mutex_unlock(&pAcct->mutex);
+
+  return TSDB_CODE_SUCCESS;
 }
 
-int mgmtGetQueries(SShowObj *pShow, SConnObj *pConn) {
-  SAcctObj *  pAcct = pConn->pAcct;
-  SQueryShow *pQueryShow;
-
-  pthread_mutex_lock(&pAcct->mutex);
-
-  pQueryShow = malloc(sizeof(SQDesc) * pAcct->acctInfo.numOfQueries + sizeof(SQueryShow));
-  pQueryShow->numOfQueries = 0;
-  pQueryShow->index = 0;
-  pQueryShow->connInfo = NULL;
-  pQueryShow->cdesc = NULL;
-
-  if (pAcct->acctInfo.numOfQueries > 0) {
-    pQueryShow->connInfo = (SCDesc *)malloc(pAcct->acctInfo.numOfConns * sizeof(SCDesc));
-    pQueryShow->cdesc = (SCDesc **)malloc(pAcct->acctInfo.numOfQueries * sizeof(SCDesc *));
-
-    pConn = pAcct->pConn;
-    SQDesc * pQdesc = pQueryShow->qdesc;
-    SCDesc * pCDesc = pQueryShow->connInfo;
-    SCDesc **ppCDesc = pQueryShow->cdesc;
-
-    while (pConn) {
-      if (pConn->pQList && pConn->pQList->numOfQueries > 0) {
-        pCDesc->ip = pConn->ip;
-        pCDesc->port = pConn->port;
-        strcpy(pCDesc->user, pConn->pUser->user);
-
-        memcpy(pQdesc, pConn->pQList->qdesc, sizeof(SQDesc) * pConn->pQList->numOfQueries);
-        pQdesc += pConn->pQList->numOfQueries;
-        pQueryShow->numOfQueries += pConn->pQList->numOfQueries;
-        for (int i = 0; i < pConn->pQList->numOfQueries; ++i, ++ppCDesc) *ppCDesc = pCDesc;
-
-        pCDesc++;
-      }
-      pConn = pConn->next;
-    }
-  }
-
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  // sorting based on useconds
-
-  pShow->pNode = pQueryShow;
+int32_t mgmtGetQueries(SShowObj *pShow, void *pConn) {
+//  SAcctObj *  pAcct = pConn->pAcct;
+//  SQueryShow *pQueryShow;
+//
+//  pthread_mutex_lock(&pAcct->mutex);
+//
+//  pQueryShow = malloc(sizeof(SCMQueryDesc) * pAcct->acctInfo.numOfQueries + sizeof(SQueryShow));
+//  pQueryShow->numOfQueries = 0;
+//  pQueryShow->index = 0;
+//  pQueryShow->connInfo = NULL;
+//  pQueryShow->cdesc = NULL;
+//
+//  if (pAcct->acctInfo.numOfQueries > 0) {
+//    pQueryShow->connInfo = (SCDesc *)malloc(pAcct->acctInfo.numOfConns * sizeof(SCDesc));
+//    pQueryShow->cdesc = (SCDesc **)malloc(pAcct->acctInfo.numOfQueries * sizeof(SCDesc *));
+//
+//    pConn = pAcct->pConn;
+//    SCMQueryDesc * pQdesc = pQueryShow->qdesc;
+//    SCDesc * pCDesc = pQueryShow->connInfo;
+//    SCDesc **ppCDesc = pQueryShow->cdesc;
+//
+//    while (pConn) {
+//      if (pConn->pQList && pConn->pQList->numOfQueries > 0) {
+//        pCDesc->ip = pConn->ip;
+//        pCDesc->port = pConn->port;
+//        strcpy(pCDesc->user, pConn->pUser->user);
+//
+//        memcpy(pQdesc, pConn->pQList->qdesc, sizeof(SCMQueryDesc) * pConn->pQList->numOfQueries);
+//        pQdesc += pConn->pQList->numOfQueries;
+//        pQueryShow->numOfQueries += pConn->pQList->numOfQueries;
+//        for (int32_t i = 0; i < pConn->pQList->numOfQueries; ++i, ++ppCDesc) *ppCDesc = pCDesc;
+//
+//        pCDesc++;
+//      }
+//      pConn = pConn->next;
+//    }
+//  }
+//
+//  pthread_mutex_unlock(&pAcct->mutex);
+//
+//  // sorting based on useconds
+//
+//  pShow->pNode = pQueryShow;
 
   return 0;
 }
 
-int mgmtGetQueryMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
-  int cols = 0;
+int32_t mgmtGetQueryMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
+  int32_t cols = 0;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -156,7 +156,7 @@ int mgmtGetQueryMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;
-  for (int i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
+  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
 
   pShow->numOfRows = 1000000;
   pShow->pNode = NULL;
@@ -166,70 +166,70 @@ int mgmtGetQueryMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   return 0;
 }
 
-int mgmtKillQuery(char *qidstr, SConnObj *pConn) {
-  char *temp, *chr, idstr[64];
-  strcpy(idstr, qidstr);
-
-  temp = idstr;
-  chr = strchr(temp, ':');
-  if (chr == NULL) goto _error;
-  *chr = 0;
-  uint32_t ip = inet_addr(temp);
-
-  temp = chr + 1;
-  chr = strchr(temp, ':');
-  if (chr == NULL) goto _error;
-  *chr = 0;
-  uint16_t port = htons(atoi(temp));
-
-  temp = chr + 1;
-  uint32_t queryId = atoi(temp);
-
-  SAcctObj *pAcct = pConn->pAcct;
-
-  pthread_mutex_lock(&pAcct->mutex);
-
-  pConn = pAcct->pConn;
-  while (pConn) {
-    if (pConn->ip == ip && pConn->port == port && pConn->pQList) {
-      int     i;
-      SQDesc *pQDesc = pConn->pQList->qdesc;
-      for (i = 0; i < pConn->pQList->numOfQueries; ++i, ++pQDesc) {
-        if (pQDesc->queryId == queryId) break;
-      }
-
-      if (i < pConn->pQList->numOfQueries) break;
-    }
-
-    pConn = pConn->next;
-  }
-
-  if (pConn) pConn->queryId = queryId;
-
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  if (pConn == NULL || pConn->pQList == NULL || pConn->pQList->numOfQueries == 0) goto _error;
-
-  mTrace("query:%s is there, kill it", qidstr);
-  return 0;
-
-_error:
-  mTrace("query:%s is not there", qidstr);
+int32_t mgmtKillQuery(char *qidstr, void *pConn) {
+//  char *temp, *chr, idstr[64];
+//  strcpy(idstr, qidstr);
+//
+//  temp = idstr;
+//  chr = strchr(temp, ':');
+//  if (chr == NULL) goto _error;
+//  *chr = 0;
+//  uint32_t ip = inet_addr(temp);
+//
+//  temp = chr + 1;
+//  chr = strchr(temp, ':');
+//  if (chr == NULL) goto _error;
+//  *chr = 0;
+//  uint16_t port = htons(atoi(temp));
+//
+//  temp = chr + 1;
+//  uint32_t queryId = atoi(temp);
+//
+//  SAcctObj *pAcct = pConn->pAcct;
+//
+//  pthread_mutex_lock(&pAcct->mutex);
+//
+//  pConn = pAcct->pConn;
+//  while (pConn) {
+//    if (pConn->ip == ip && pConn->port == port && pConn->pQList) {
+//      int32_t     i;
+//      SCMQueryDesc *pQDesc = pConn->pQList->qdesc;
+//      for (i = 0; i < pConn->pQList->numOfQueries; ++i, ++pQDesc) {
+//        if (pQDesc->queryId == queryId) break;
+//      }
+//
+//      if (i < pConn->pQList->numOfQueries) break;
+//    }
+//
+//    pConn = pConn->next;
+//  }
+//
+//  if (pConn) pConn->queryId = queryId;
+//
+//  pthread_mutex_unlock(&pAcct->mutex);
+//
+//  if (pConn == NULL || pConn->pQList == NULL || pConn->pQList->numOfQueries == 0) goto _error;
+//
+//  mTrace("query:%s is there, kill it", qidstr);
+//  return 0;
+//
+//_error:
+//  mTrace("query:%s is not there", qidstr);
 
   return TSDB_CODE_INVALID_QUERY_ID;
 }
 
-int mgmtRetrieveQueries(SShowObj *pShow, char *data, int rows, SConnObj *pConn) {
-  int   numOfRows = 0;
+int32_t mgmtRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+  int32_t   numOfRows = 0;
   char *pWrite;
-  int   cols = 0;
+  int32_t   cols = 0;
 
   SQueryShow *pQueryShow = (SQueryShow *)pShow->pNode;
 
   if (rows > pQueryShow->numOfQueries - pQueryShow->index) rows = pQueryShow->numOfQueries - pQueryShow->index;
 
   while (numOfRows < rows) {
-    SQDesc *pNode = pQueryShow->qdesc + pQueryShow->index;
+    SCMQueryDesc *pNode = pQueryShow->qdesc + pQueryShow->index;
     SCDesc *pCDesc = pQueryShow->cdesc[pQueryShow->index];
     cols = 0;
 
@@ -269,55 +269,55 @@ int mgmtRetrieveQueries(SShowObj *pShow, char *data, int rows, SConnObj *pConn)
   return numOfRows;
 }
 
-int mgmtGetStreams(SShowObj *pShow, SConnObj *pConn) {
-  SAcctObj *   pAcct = pConn->pAcct;
-  SStreamShow *pStreamShow;
-
-  pthread_mutex_lock(&pAcct->mutex);
-
-  pStreamShow = malloc(sizeof(SSDesc) * pAcct->acctInfo.numOfStreams + sizeof(SQueryShow));
-  pStreamShow->numOfStreams = 0;
-  pStreamShow->index = 0;
-  pStreamShow->connInfo = NULL;
-  pStreamShow->cdesc = NULL;
-
-  if (pAcct->acctInfo.numOfStreams > 0) {
-    pStreamShow->connInfo = (SCDesc *)malloc(pAcct->acctInfo.numOfConns * sizeof(SCDesc));
-    pStreamShow->cdesc = (SCDesc **)malloc(pAcct->acctInfo.numOfStreams * sizeof(SCDesc *));
-
-    pConn = pAcct->pConn;
-    SSDesc * pSdesc = pStreamShow->sdesc;
-    SCDesc * pCDesc = pStreamShow->connInfo;
-    SCDesc **ppCDesc = pStreamShow->cdesc;
-
-    while (pConn) {
-      if (pConn->pSList && pConn->pSList->numOfStreams > 0) {
-        pCDesc->ip = pConn->ip;
-        pCDesc->port = pConn->port;
-        strcpy(pCDesc->user, pConn->pUser->user);
-
-        memcpy(pSdesc, pConn->pSList->sdesc, sizeof(SSDesc) * pConn->pSList->numOfStreams);
-        pSdesc += pConn->pSList->numOfStreams;
-        pStreamShow->numOfStreams += pConn->pSList->numOfStreams;
-        for (int i = 0; i < pConn->pSList->numOfStreams; ++i, ++ppCDesc) *ppCDesc = pCDesc;
-
-        pCDesc++;
-      }
-      pConn = pConn->next;
-    }
-  }
-
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  // sorting based on useconds
-
-  pShow->pNode = pStreamShow;
+int32_t mgmtGetStreams(SShowObj *pShow, void *pConn) {
+//  SAcctObj *   pAcct = pConn->pAcct;
+//  SStreamShow *pStreamShow;
+//
+//  pthread_mutex_lock(&pAcct->mutex);
+//
+//  pStreamShow = malloc(sizeof(SCMStreamDesc) * pAcct->acctInfo.numOfStreams + sizeof(SQueryShow));
+//  pStreamShow->numOfStreams = 0;
+//  pStreamShow->index = 0;
+//  pStreamShow->connInfo = NULL;
+//  pStreamShow->cdesc = NULL;
+//
+//  if (pAcct->acctInfo.numOfStreams > 0) {
+//    pStreamShow->connInfo = (SCDesc *)malloc(pAcct->acctInfo.numOfConns * sizeof(SCDesc));
+//    pStreamShow->cdesc = (SCDesc **)malloc(pAcct->acctInfo.numOfStreams * sizeof(SCDesc *));
+//
+//    pConn = pAcct->pConn;
+//    SCMStreamDesc * pSdesc = pStreamShow->sdesc;
+//    SCDesc * pCDesc = pStreamShow->connInfo;
+//    SCDesc **ppCDesc = pStreamShow->cdesc;
+//
+//    while (pConn) {
+//      if (pConn->pSList && pConn->pSList->numOfStreams > 0) {
+//        pCDesc->ip = pConn->ip;
+//        pCDesc->port = pConn->port;
+//        strcpy(pCDesc->user, pConn->pUser->user);
+//
+//        memcpy(pSdesc, pConn->pSList->sdesc, sizeof(SCMStreamDesc) * pConn->pSList->numOfStreams);
+//        pSdesc += pConn->pSList->numOfStreams;
+//        pStreamShow->numOfStreams += pConn->pSList->numOfStreams;
+//        for (int32_t i = 0; i < pConn->pSList->numOfStreams; ++i, ++ppCDesc) *ppCDesc = pCDesc;
+//
+//        pCDesc++;
+//      }
+//      pConn = pConn->next;
+//    }
+//  }
+//
+//  pthread_mutex_unlock(&pAcct->mutex);
+//
+//  // sorting based on useconds
+//
+//  pShow->pNode = pStreamShow;
 
   return 0;
 }
 
-int mgmtGetStreamMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
-  int      cols = 0;
+int32_t mgmtGetStreamMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
+  int32_t      cols = 0;
   SSchema *pSchema = tsGetSchema(pMeta);
 
   pShow->bytes[cols] = TSDB_USER_LEN;
@@ -366,7 +366,7 @@ int mgmtGetStreamMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;
-  for (int i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
+  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
 
   pShow->numOfRows = 1000000;
   pShow->pNode = NULL;
@@ -376,17 +376,17 @@ int mgmtGetStreamMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   return 0;
 }
 
-int mgmtRetrieveStreams(SShowObj *pShow, char *data, int rows, SConnObj *pConn) {
-  int   numOfRows = 0;
+int32_t mgmtRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+  int32_t   numOfRows = 0;
   char *pWrite;
-  int   cols = 0;
+  int32_t   cols = 0;
 
   SStreamShow *pStreamShow = (SStreamShow *)pShow->pNode;
 
   if (rows > pStreamShow->numOfStreams - pStreamShow->index) rows = pStreamShow->numOfStreams - pStreamShow->index;
 
   while (numOfRows < rows) {
-    SSDesc *pNode = pStreamShow->sdesc + pStreamShow->index;
+    SCMStreamDesc *pNode = pStreamShow->sdesc + pStreamShow->index;
     SCDesc *pCDesc = pStreamShow->cdesc[pStreamShow->index];
     cols = 0;
 
@@ -434,101 +434,101 @@ int mgmtRetrieveStreams(SShowObj *pShow, char *data, int rows, SConnObj *pConn)
   return numOfRows;
 }
 
-int mgmtKillStream(char *qidstr, SConnObj *pConn) {
-  char *temp, *chr, idstr[64];
-  strcpy(idstr, qidstr);
-
-  temp = idstr;
-  chr = strchr(temp, ':');
-  if (chr == NULL) goto _error;
-  *chr = 0;
-  uint32_t ip = inet_addr(temp);
-
-  temp = chr + 1;
-  chr = strchr(temp, ':');
-  if (chr == NULL) goto _error;
-  *chr = 0;
-  uint16_t port = htons(atoi(temp));
-
-  temp = chr + 1;
-  uint32_t streamId = atoi(temp);
-
-  SAcctObj *pAcct = pConn->pAcct;
-
-  pthread_mutex_lock(&pAcct->mutex);
-
-  pConn = pAcct->pConn;
-  while (pConn) {
-    if (pConn->ip == ip && pConn->port == port && pConn->pSList) {
-      int     i;
-      SSDesc *pSDesc = pConn->pSList->sdesc;
-      for (i = 0; i < pConn->pSList->numOfStreams; ++i, ++pSDesc) {
-        if (pSDesc->streamId == streamId) break;
-      }
-
-      if (i < pConn->pSList->numOfStreams) break;
-    }
-
-    pConn = pConn->next;
-  }
-
-  if (pConn) pConn->streamId = streamId;
-
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  if (pConn == NULL || pConn->pSList == NULL || pConn->pSList->numOfStreams == 0) goto _error;
-
-  mTrace("stream:%s is there, kill it", qidstr);
-  return 0;
-
-_error:
-  mTrace("stream:%s is not there", qidstr);
+int32_t mgmtKillStream(char *qidstr, void *pConn) {
+//  char *temp, *chr, idstr[64];
+//  strcpy(idstr, qidstr);
+//
+//  temp = idstr;
+//  chr = strchr(temp, ':');
+//  if (chr == NULL) goto _error;
+//  *chr = 0;
+//  uint32_t ip = inet_addr(temp);
+//
+//  temp = chr + 1;
+//  chr = strchr(temp, ':');
+//  if (chr == NULL) goto _error;
+//  *chr = 0;
+//  uint16_t port = htons(atoi(temp));
+//
+//  temp = chr + 1;
+//  uint32_t streamId = atoi(temp);
+//
+//  SAcctObj *pAcct = pConn->pAcct;
+//
+//  pthread_mutex_lock(&pAcct->mutex);
+//
+//  pConn = pAcct->pConn;
+//  while (pConn) {
+//    if (pConn->ip == ip && pConn->port == port && pConn->pSList) {
+//      int32_t     i;
+//      SCMStreamDesc *pSDesc = pConn->pSList->sdesc;
+//      for (i = 0; i < pConn->pSList->numOfStreams; ++i, ++pSDesc) {
+//        if (pSDesc->streamId == streamId) break;
+//      }
+//
+//      if (i < pConn->pSList->numOfStreams) break;
+//    }
+//
+//    pConn = pConn->next;
+//  }
+//
+//  if (pConn) pConn->streamId = streamId;
+//
+//  pthread_mutex_unlock(&pAcct->mutex);
+//
+//  if (pConn == NULL || pConn->pSList == NULL || pConn->pSList->numOfStreams == 0) goto _error;
+//
+//  mTrace("stream:%s is there, kill it", qidstr);
+//  return 0;
+//
+//_error:
+//  mTrace("stream:%s is not there", qidstr);
 
   return TSDB_CODE_INVALID_STREAM_ID;
 }
 
-int mgmtKillConnection(char *qidstr, SConnObj *pConn) {
-  SConnObj *pConn1 = NULL;
-  char *    temp, *chr, idstr[64];
-  strcpy(idstr, qidstr);
-
-  temp = idstr;
-  chr = strchr(temp, ':');
-  if (chr == NULL) goto _error;
-  *chr = 0;
-  uint32_t ip = inet_addr(temp);
-
-  temp = chr + 1;
-  uint16_t port = htons(atoi(temp));
-  SAcctObj *pAcct = pConn->pAcct;
-  
-  pthread_mutex_lock(&pAcct->mutex);
-
-  pConn = pAcct->pConn;
-  while (pConn) {
-    if (pConn->ip == ip && pConn->port == port) {
-      // there maybe two connections from a shell
-      if (pConn1 == NULL)
-        pConn1 = pConn;
-      else
-        break;
-    }
-
-    pConn = pConn->next;
-  }
-
-  if (pConn1) pConn1->killConnection = 1;
-  if (pConn) pConn->killConnection = 1;
-
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  if (pConn1 == NULL) goto _error;
-
-  mTrace("connection:%s is there, kill it", qidstr);
-  return 0;
-
-_error:
-  mTrace("connection:%s is not there", qidstr);
+int32_t mgmtKillConnection(char *qidstr, void *pConn) {
+//  void *pConn1 = NULL;
+//  char *    temp, *chr, idstr[64];
+//  strcpy(idstr, qidstr);
+//
+//  temp = idstr;
+//  chr = strchr(temp, ':');
+//  if (chr == NULL) goto _error;
+//  *chr = 0;
+//  uint32_t ip = inet_addr(temp);
+//
+//  temp = chr + 1;
+//  uint16_t port = htons(atoi(temp));
+//  SAcctObj *pAcct = pConn->pAcct;
+//
+//  pthread_mutex_lock(&pAcct->mutex);
+//
+//  pConn = pAcct->pConn;
+//  while (pConn) {
+//    if (pConn->ip == ip && pConn->port == port) {
+//      // there maybe two connections from a shell
+//      if (pConn1 == NULL)
+//        pConn1 = pConn;
+//      else
+//        break;
+//    }
+//
+//    pConn = pConn->next;
+//  }
+//
+//  if (pConn1) pConn1->killConnection = 1;
+//  if (pConn) pConn->killConnection = 1;
+//
+//  pthread_mutex_unlock(&pAcct->mutex);
+//
+//  if (pConn1 == NULL) goto _error;
+//
+//  mTrace("connection:%s is there, kill it", qidstr);
+//  return 0;
+//
+//_error:
+//  mTrace("connection:%s is not there", qidstr);
 
   return TSDB_CODE_INVALID_CONNECTION;
 }
diff --git a/src/mnode/src/mgmtShell.c b/src/mnode/src/mgmtShell.c
index 82a1d6dd1fc0a6e01ad67873cfd8de2c8b63c58a..1cc7892f38bc8b67060ff69effd556a59a288565 100644
--- a/src/mnode/src/mgmtShell.c
+++ b/src/mnode/src/mgmtShell.c
@@ -38,31 +38,44 @@
 
 #define MAX_LEN_OF_METER_META (sizeof(SMultiMeterMeta) + sizeof(SSchema) * TSDB_MAX_COLUMNS + sizeof(SSchema) * TSDB_MAX_TAGS + TSDB_MAX_TAGS_LEN)
 
-typedef int32_t (*GetMateFp)(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn);
-typedef int32_t (*RetrieveMetaFp)(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn);
+typedef int32_t (*GetMateFp)(SMeterMeta *pMeta, SShowObj *pShow, void *pConn);
+typedef int32_t (*RetrieveMetaFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 static GetMateFp* mgmtGetMetaFp;
 static RetrieveMetaFp* mgmtRetrieveFp;
 static void mgmtInitShowMsgFp();
 
 void *    tsShellConn = NULL;
-SConnObj *connList;
-void      mgmtProcessMsgFromShell(char type, void *pCont, int32_t contLen, void *ahandle, int32_t code);
-int32_t       mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey);
-int32_t     (*mgmtProcessShellMsg[TSDB_MSG_TYPE_MAX])(char *, int32_t, SConnObj *);
-void      mgmtInitProcessShellMsg();
-int32_t       mgmtRedirectMsg(SConnObj *pConn, int32_t msgType);
-int32_t       mgmtKillQuery(char *queryId, SConnObj *pConn);
 
-void mgmtProcessTranRequest(SSchedMsg *pSchedMsg) {
-  SIntMsg * pMsg = (SIntMsg *)(pSchedMsg->msg);
-  SConnObj *pConn = (SConnObj *)(pSchedMsg->thandle);
+static void mgmtProcessMsgFromShell(char type, void *pCont, int contLen, void *ahandle, int32_t code);
+static int32_t (*mgmtProcessShellMsg[TSDB_MSG_TYPE_MAX])(void *pCont, int32_t contLen, void *ahandle);
+static int32_t mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey);
 
-  char *cont = (char *)pMsg->content + sizeof(SMgmtHead);
-  int32_t   contLen = pMsg->msgLen - sizeof(SIntMsg) - sizeof(SMgmtHead);
+void    mgmtInitProcessShellMsg();
+int32_t mgmtKillQuery(char *queryId, void *pConn);
 
-  if (pConn->pAcct) (*mgmtProcessShellMsg[pMsg->msgType])(cont, contLen, pConn);
+void mgmtProcessTranRequest(SSchedMsg *sched) {
+  int8_t  msgType = *(int8_t *) (sched->msg);
+  int32_t contLen = *(int32_t *) (sched->msg  + sizeof(int8_t));
+  int8_t  *pCont  = sched->msg + sizeof(int32_t) + sizeof(int8_t);
+  void    *pConn  = sched->thandle;
 
-  if (pSchedMsg->msg) free(pSchedMsg->msg);
+  (*mgmtProcessShellMsg[msgType])(pCont, contLen, pConn);
+  if (sched->msg) {
+    free(sched->msg);
+  }
+}
+
+void mgmtAddToTranRequest(int8_t type, void *pCont, int contLen, void *ahandle) {
+  SSchedMsg schedMsg;
+  schedMsg.msg = malloc(contLen + sizeof(int32_t) + sizeof(int8_t));
+  schedMsg.fp = mgmtProcessTranRequest;
+  schedMsg.tfp = NULL;
+  schedMsg.thandle = ahandle;
+  *(int8_t *) (schedMsg.msg) = type;
+  *(int32_t *) (schedMsg.msg + sizeof(int8_t)) = contLen;
+  memcpy(schedMsg.msg, pCont + sizeof(int32_t) + sizeof(int8_t), contLen);
+
+  taosScheduleTask(tsMgmtTranQhandle, &schedMsg);
 }
 
 int32_t mgmtInitShell() {
@@ -71,26 +84,20 @@ int32_t mgmtInitShell() {
   mgmtInitProcessShellMsg();
   mgmtInitShowMsgFp();
 
-  int32_t size = sizeof(SConnObj) * tsMaxShellConns;
-  connList = (SConnObj *)malloc(size);
-  if (connList == NULL) {
-    mError("failed to malloc for connList to shell");
-    return -1;
-  }
-  memset(connList, 0, size);
-
   int32_t numOfThreads = tsNumOfCores * tsNumOfThreadsPerCore / 4.0;
   if (numOfThreads < 1) numOfThreads = 1;
 
-  memset(&rpcInit, 0, sizeof(rpcInit));
+  //TODO
+  numOfThreads = 1;
 
-  rpcInit.localIp = tsAnyIp ? "0.0.0.0" : tsPrivateIp;;
+  memset(&rpcInit, 0, sizeof(rpcInit));
+    rpcInit.localIp = tsAnyIp ? "0.0.0.0" : tsPrivateIp;;
   rpcInit.localPort = tsMgmtShellPort;
   rpcInit.label = "MND-shell";
   rpcInit.numOfThreads = numOfThreads;
   rpcInit.cfp = mgmtProcessMsgFromShell;
   rpcInit.sessions = tsMaxShellConns;
-  rpcInit.connType = TAOS_CONN_SOCKET_TYPE_S();
+  rpcInit.connType = TAOS_CONN_SERVER;
   rpcInit.idleTime = tsShellActivityTimer * 2000;
   rpcInit.afp = mgmtRetriveUserAuthInfo;
 
@@ -108,7 +115,6 @@ void mgmtCleanUpShell() {
     rpcClose(tsShellConn);
     tsShellConn = NULL;
   }
-  tfree(connList);
 }
 
 static void mgmtSetSchemaFromMeters(SSchema *pSchema, STabObj *pMeterObj, uint32_t numOfCols) {
@@ -136,51 +142,7 @@ static uint32_t mgmtSetMeterTagValue(char *pTags, STabObj *pMetric, STabObj *pMe
   return tagsLen;
 }
 
-//static char *mgmtAllocMsg(SConnObj *pConn, int32_t size, char **pMsg, STaosRsp **pRsp) {
-//  char *pStart = taosBuildRspMsgWithSize(pConn->thandle, TSDB_MSG_TYPE_TABLE_META_RSP, size);
-//  if (pStart == NULL) return 0;
-//  *pMsg = pStart;
-//  *pRsp = (STaosRsp *)(*pMsg);
-//
-//  return pStart;
-//  return 0;
-//}
-
-//static char *mgmtForMultiAllocMsg(SConnObj *pConn, int32_t size, char **pMsg, STaosRsp **pRsp) {
-//  char *pStart = taosBuildRspMsgWithSize(pConn->thandle, TSDB_MSG_TYPE_MULTI_TABLE_META_RSP, size);
-//  if (pStart == NULL) return 0;
-//  *pMsg = pStart;
-//  *pRsp = (STaosRsp *)(*pMsg);
-//
-//  return pStart;
-//  return 0;
-//}
-
-/**
- * check if we need to add mgmtProcessMeterMetaMsg into tranQueue, which will be executed one-by-one.
- *
- * @param pMsg
- * @return
- */
-bool mgmtCheckMeterMetaMsgType(char *pMsg) {
-//  SMeterInfoMsg *pInfo = (SMeterInfoMsg *)pMsg;
-//
-//  int16_t   autoCreate = htons(pInfo->createFlag);
-//  STableInfo *table      = mgmtGetTable(pInfo->meterId);
-
-// If table does not exists and autoCreate flag is set, we add the handler into another task queue, namely tranQueue
-//  bool addIntoTranQueue = (pMeterObj == NULL && autoCreate == 1);
-//  if (addIntoTranQueue) {
-//    mTrace("meter:%s auto created task added", pInfo->meterId);
-//  }
-
-//  bool addIntoTranQueue = true;
-
-//  return addIntoTranQueue;
-  return 0;
-}
-
-int32_t mgmtProcessMeterMetaMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessMeterMetaMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SMeterInfoMsg *pInfo = (SMeterInfoMsg *)pMsg;
 //  STabObj *      pMeterObj = NULL;
 //  SVgObj *       pVgroup = NULL;
@@ -352,7 +314,7 @@ int32_t mgmtProcessMeterMetaMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
  *                |                                                                                          |                       |
  *              pStart                                                                                   pCurMeter                 pTail
  **/
-int32_t mgmtProcessMultiMeterMetaMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessMultiMeterMetaMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SDbObj *          pDbObj    = NULL;
 //  STabObj *         pMeterObj = NULL;
 //  SVgObj *          pVgroup   = NULL;
@@ -507,7 +469,7 @@ int32_t mgmtProcessMultiMeterMetaMsg(char *pMsg, int32_t msgLen, SConnObj *pConn
   return 0;
 }
 
-int32_t mgmtProcessMetricMetaMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessMetricMetaMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SSuperTableMetaMsg *pSuperTableMetaMsg = (SSuperTableMetaMsg *)pMsg;
 //  STabObj *       pMetric;
 //  STaosRsp *      pRsp;
@@ -558,7 +520,7 @@ int32_t mgmtProcessMetricMetaMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessCreateDbMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCreateDbMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SCreateDbMsg *pCreate = (SCreateDbMsg *)pMsg;
 //  int32_t           code = 0;
 //
@@ -593,12 +555,12 @@ int32_t mgmtProcessCreateDbMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessCreateMnodeMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCreateMnodeMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  return rpcSendResponse(pConn->thandle, TSDB_MSG_TYPE_CREATE_MNODE_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
 
-int32_t mgmtProcessAlterDbMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessAlterDbMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SAlterDbMsg *pAlter = (SAlterDbMsg *)pMsg;
 //  int32_t          code = 0;
 //
@@ -624,7 +586,7 @@ int32_t mgmtProcessAlterDbMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessKillQueryMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessKillQueryMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  int32_t         code = 0;
 //  SKillQuery *pKill = (SKillQuery *)pMsg;
 //
@@ -639,7 +601,7 @@ int32_t mgmtProcessKillQueryMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessKillStreamMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessKillStreamMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  int32_t          code = 0;
 //  SKillStream *pKill = (SKillStream *)pMsg;
 //
@@ -654,7 +616,7 @@ int32_t mgmtProcessKillStreamMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessKillConnectionMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessKillConnectionMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  int32_t              code = 0;
 //  SKillConnection *pKill = (SKillConnection *)pMsg;
 //
@@ -669,7 +631,7 @@ int32_t mgmtProcessKillConnectionMsg(char *pMsg, int32_t msgLen, SConnObj *pConn
   return 0;
 }
 
-int32_t mgmtProcessCreateUserMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCreateUserMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SCreateUserMsg *pCreate = (SCreateUserMsg *)pMsg;
 //  int32_t             code = 0;
 //
@@ -691,7 +653,7 @@ int32_t mgmtProcessCreateUserMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessAlterUserMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessAlterUserMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SAlterUserMsg *pAlter = (SAlterUserMsg *)pMsg;
 //  int32_t            code = 0;
 //  SUserObj *     pUser;
@@ -803,7 +765,7 @@ int32_t mgmtProcessAlterUserMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessDropUserMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessDropUserMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SDropUserMsg *pDrop = (SDropUserMsg *)pMsg;
 //  int32_t           code = 0;
 //  SUserObj *    pUser;
@@ -862,7 +824,7 @@ int32_t mgmtProcessDropUserMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessDropDbMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessDropDbMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SDropDbMsg *pDrop = (SDropDbMsg *)pMsg;
 //  int32_t         code;
 //
@@ -883,7 +845,7 @@ int32_t mgmtProcessDropDbMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessUseDbMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessUseDbMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SUseDbMsg *pUse = (SUseDbMsg *)pMsg;
 //  int32_t        code;
 //
@@ -933,7 +895,7 @@ static void mgmtInitShowMsgFp() {
   mgmtRetrieveFp[TSDB_MGMT_TABLE_VNODES] = mgmtRetrieveVnodes;
 }
 
-int32_t mgmtProcessShowMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessShowMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SShowMsg *   pShowMsg = (SShowMsg *)pMsg;
 //  STaosRsp *   pRsp;
 //  char *       pStart;
@@ -992,7 +954,7 @@ int32_t mgmtProcessShowMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessRetrieveMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessRetrieveMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SRetrieveMeterMsg *pRetrieve;
 //  SRetrieveMeterRsp *pRsp;
 //  int32_t                rowsToRead = 0, size = 0, rowsRead = 0;
@@ -1080,7 +1042,7 @@ int32_t mgmtProcessRetrieveMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessCreateTableMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCreateTableMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SCreateTableMsg *pCreate = (SCreateTableMsg *)pMsg;
 //  int32_t              code;
 //  SSchema *        pSchema;
@@ -1135,7 +1097,7 @@ int32_t mgmtProcessCreateTableMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessDropTableMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessDropTableMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SDropTableMsg *pDrop = (SDropTableMsg *)pMsg;
 //  int32_t            code;
 //
@@ -1161,7 +1123,7 @@ int32_t mgmtProcessDropTableMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessAlterTableMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessAlterTableMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  SAlterTableMsg *pAlter = (SAlterTableMsg *)pMsg;
 //  int32_t             code;
 //
@@ -1202,7 +1164,7 @@ int32_t mgmtProcessAlterTableMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
   return 0;
 }
 
-int32_t mgmtProcessCfgDnodeMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCfgDnodeMsg(void *pCont, int32_t contLen, void *ahandle) {
 //  int32_t      code = 0;
 //  SCfgMsg *pCfg = (SCfgMsg *)pMsg;
 //
@@ -1220,129 +1182,94 @@ int32_t mgmtProcessCfgDnodeMsg(char *pMsg, int32_t msgLen, SConnObj *pConn) {
 //
 //  if (code == 0) mTrace("dnode:%s is configured by %s", pCfg->ip, pConn->pUser->user);
 //
-//  return 0;
-//}
-//
-//int32_t mgmtProcessHeartBeatMsg(char *cont, int32_t contLen, SConnObj *pConn) {
-//  char *    pStart, *pMsg;
-//  int32_t       msgLen;
-//  STaosRsp *pRsp;
-//
-//  mgmtSaveQueryStreamList(cont, contLen, pConn);
-//
-//  pStart = taosBuildRspMsgWithSize(pConn->thandle, TSDB_MSG_TYPE_HEARTBEAT_RSP, 128);
-//  if (pStart == NULL) return 0;
-//  pMsg = pStart;
-//  pRsp = (STaosRsp *)pMsg;
-//  pRsp->code = 0;
-//  pMsg = (char *)pRsp->more;
-//
-//  SHeartBeatRsp *pHBRsp = (SHeartBeatRsp *)pRsp->more;
-//  pHBRsp->queryId = pConn->queryId;
-//  pConn->queryId = 0;
-//  pHBRsp->streamId = pConn->streamId;
-//  pHBRsp->streamId = pConn->streamId;
-//  pConn->streamId = 0;
-//  pHBRsp->killConnection = pConn->killConnection;
-//
-//  if (pConn->usePublicIp) {
-//    if (pSdbPublicIpList != NULL) {
-//      int32_t size = pSdbPublicIpList->numOfIps * 4;
-//      pHBRsp->ipList.numOfIps = pSdbPublicIpList->numOfIps;
-//      memcpy(pHBRsp->ipList.ip, pSdbPublicIpList->ip, size);
-//      pMsg += sizeof(SHeartBeatRsp) + size;
-//    } else {
-//      pHBRsp->ipList.numOfIps = 0;
-//      pMsg += sizeof(SHeartBeatRsp);
-//    }
-//
-//  } else {
-//    if (pSdbIpList != NULL) {
-//      int32_t size = pSdbIpList->numOfIps * 4;
-//      pHBRsp->ipList.numOfIps = pSdbIpList->numOfIps;
-//      memcpy(pHBRsp->ipList.ip, pSdbIpList->ip, size);
-//      pMsg += sizeof(SHeartBeatRsp) + size;
-//    } else {
-//      pHBRsp->ipList.numOfIps = 0;
-//      pMsg += sizeof(SHeartBeatRsp);
-//    }
-//  }
-//  msgLen = pMsg - pStart;
-//
-//  taosSendMsgToPeer(pConn->thandle, pStart, msgLen);
-
   return 0;
 }
 
-void mgmtEstablishConn(SConnObj *pConn) {
-//  atomic_fetch_add_32(&mgmtShellConns, 1);
-//  atomic_fetch_add_32(&sdbExtConns, 1);
-//  pConn->stime = taosGetTimestampMs();
-//
-//  if (strcmp(pConn->pUser->user, "root") == 0) {
-//    pConn->superAuth = 1;
-//    pConn->writeAuth = 1;
-//  } else {
-//    pConn->superAuth = pConn->pUser->superAuth;
-//    pConn->writeAuth = pConn->pUser->writeAuth;
-//    if (pConn->superAuth) {
-//      pConn->writeAuth = 1;
-//    }
-//  }
-//
-//  int32_t tempint32;
-//  uint32_t tempuint32;
-//  taosGetRpcConnInfo(pConn->thandle, &tempuint32, &pConn->ip, &pConn->port, &tempint32, &tempint32);
-//  mgmtAddConnIntoAcct(pConn);
+int32_t mgmtProcessHeartBeatMsg(void *pCont, int32_t contLen, void *ahandle) {
+  SCMHeartBeatMsg *pHBMsg = (SCMHeartBeatMsg *) pCont;
+  mgmtSaveQueryStreamList(pHBMsg);
+
+  SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(contLen);
+  if (pHBRsp == NULL) {
+    rpcSendResponse(ahandle, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0);
+    rpcFreeCont(pCont);
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+  }
+
+  SRpcConnInfo connInfo;
+  rpcGetConnInfo(ahandle, &connInfo);
+
+  pHBRsp->ipList.index = 0;
+  pHBRsp->ipList.port = htons(tsMgmtShellPort);
+  pHBRsp->ipList.numOfIps = 0;
+  if (pSdbPublicIpList != NULL && pSdbIpList != NULL) {
+    pHBRsp->ipList.numOfIps = htons(pSdbPublicIpList->numOfIps);
+    if (connInfo.serverIp == tsPublicIpInt) {
+      for (int i = 0; i < pSdbPublicIpList->numOfIps; ++i) {
+        pHBRsp->ipList.ip[i] = htonl(pSdbPublicIpList->ip[i]);
+      }
+    } else {
+      for (int i = 0; i < pSdbIpList->numOfIps; ++i) {
+        pHBRsp->ipList.ip[i] = htonl(pSdbIpList->ip[i]);
+      }
+    }
+  }
+
+  /*
+   * TODO
+   * Dispose kill stream or kill query message
+   */
+  pHBRsp->queryId = 0;
+  pHBRsp->streamId = 0;
+  pHBRsp->killConnection = 0;
+
+  rpcSendResponse(ahandle, TSDB_CODE_SUCCESS, pHBRsp, sizeof(SCMHeartBeatMsg));
+  rpcFreeCont(pCont);
+
+  return TSDB_CODE_SUCCESS;
 }
 
 int32_t mgmtRetriveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+  *spi = 0;
+  *encrypt = 0;
+  *ckey = 0;
+
   SUserObj *pUser = mgmtGetUser(user);
   if (pUser == NULL) {
-    *spi = 0;
-    *encrypt = 0;
-    *ckey = 0;
     *secret = 0;
     return TSDB_CODE_INVALID_USER;
+  } else {
+    memcpy(secret, pUser->pass, TSDB_KEY_LEN);
+    return TSDB_CODE_SUCCESS;
   }
-
-  *spi = 1;
-  *encrypt = 0;
-  *ckey = 0;
-  memcpy(secret, pUser->pass, TSDB_KEY_LEN);
-  return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtProcessConnectMsg(int8_t type, void *pCont, int32_t contLen, void *ahandle, int32_t code) {
+static int32_t mgmtProcessConnectMsg(void *pCont, int32_t contLen, void *thandle) {
   SCMConnectMsg *pConnectMsg = (SCMConnectMsg *) pCont;
   SRpcConnInfo connInfo;
-  rpcGetConnInfo(ahandle, &connInfo);
+  rpcGetConnInfo(thandle, &connInfo);
+  int32_t code;
 
   SUserObj *pUser = mgmtGetUser(connInfo.user);
   if (pUser == NULL) {
-    mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
-    rpcSendResponse(ahandle, TSDB_CODE_INVALID_USER, NULL, 0);
-    return TSDB_CODE_INVALID_USER;
+    code = TSDB_CODE_INVALID_USER;
+    goto connect_over;
   }
 
   if (mgmtCheckExpired()) {
-    mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
-    rpcSendResponse(ahandle, TSDB_CODE_GRANT_EXPIRED, NULL, 0);
-    return TSDB_CODE_GRANT_EXPIRED;
+    code = TSDB_CODE_GRANT_EXPIRED;
+    goto connect_over;
   }
 
   SAcctObj *pAcct = mgmtGetAcct(pUser->acct);
   if (pAcct == NULL) {
-    mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
-    rpcSendResponse(ahandle, TSDB_CODE_INVALID_ACCT, NULL, 0);
-    return TSDB_CODE_INVALID_ACCT;
+    code = TSDB_CODE_INVALID_ACCT;
+    goto connect_over;
   }
 
   code = taosCheckVersion(pConnectMsg->clientVersion, version, 3);
   if (code != TSDB_CODE_SUCCESS) {
-    mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
-    rpcSendResponse(ahandle, code, NULL, 0);
-    return code;
+    goto connect_over;
   }
 
   if (pConnectMsg->db[0]) {
@@ -1350,131 +1277,95 @@ int32_t mgmtProcessConnectMsg(int8_t type, void *pCont, int32_t contLen, void *a
     sprintf(dbName, "%x%s%s", pAcct->acctId, TS_PATH_DELIMITER, pConnectMsg->db);
     SDbObj *pDb = mgmtGetDb(dbName);
     if (pDb == NULL) {
-      mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
-      rpcSendResponse(ahandle, TSDB_CODE_INVALID_DB, NULL, 0);
-      return TSDB_CODE_INVALID_DB;
+      code = TSDB_CODE_INVALID_DB;
+      goto connect_over;
     }
   }
 
   SCMConnectRsp *pConnectRsp = rpcMallocCont(sizeof(SCMConnectRsp));
   if (pConnectRsp == NULL) {
-    mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
-    rpcSendResponse(ahandle, TSDB_CODE_SERV_OUT_OF_MEMORY, NULL, 0);
-    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+    code = TSDB_CODE_SERV_OUT_OF_MEMORY;
+    goto connect_over;
   }
 
   sprintf(pConnectRsp->acctId, "%x", pAcct->acctId);
   strcpy(pConnectRsp->serverVersion, version);
   pConnectRsp->writeAuth = pUser->writeAuth;
   pConnectRsp->superAuth = pUser->superAuth;
-
-  pConnectRsp->index = 0;
+  pConnectRsp->ipList.index = 0;
+  pConnectRsp->ipList.port = htons(tsMgmtShellPort);
+  pConnectRsp->ipList.numOfIps = 0;
   if (pSdbPublicIpList != NULL && pSdbIpList != NULL) {
-    pConnectRsp->numOfIps = htons(pSdbPublicIpList->numOfIps);
-    pConnectRsp->port = htons(tsMgmtShellPort);
+    pConnectRsp->ipList.numOfIps = htons(pSdbPublicIpList->numOfIps);
     if (connInfo.serverIp == tsPublicIpInt) {
       for (int i = 0; i < pSdbPublicIpList->numOfIps; ++i) {
-        pConnectRsp->ip[i] = htonl(pSdbPublicIpList->ip[i]);
+        pConnectRsp->ipList.ip[i] = htonl(pSdbPublicIpList->ip[i]);
       }
     } else {
       for (int i = 0; i < pSdbIpList->numOfIps; ++i) {
-        pConnectRsp->ip[i] = htonl(pSdbIpList->ip[i]);
+        pConnectRsp->ipList.ip[i] = htonl(pSdbIpList->ip[i]);
       }
     }
+  }
+
+connect_over:
+  if (code != TSDB_CODE_SUCCESS) {
+    mLError("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
+    rpcSendResponse(thandle, code, NULL, 0);
   } else {
-    pConnectRsp->numOfIps = 0;
-    pConnectRsp->port = htons(tsMgmtShellPort);
+    mLPrint("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
+    rpcSendResponse(thandle, code, pConnectRsp, sizeof(SCMConnectRsp));
   }
 
-  mLPrint("user:%s login from %s, code:%d", connInfo.user, taosIpStr(connInfo.clientIp), code);
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
-void mgmtProcessMsgFromShell(char type, void *pCont, int32_t contLen, void *ahandle, int32_t code) {
-//  SIntMsg * pMsg = (SIntMsg *)msg;
-//  SConnObj *pConn = (SConnObj *)ahandle;
-//
-//  if (msg == NULL) {
-//    if (pConn) {
-//      mgmtRemoveConnFromAcct(pConn);
-//      atomic_fetch_sub_32(&mgmtShellConns, 1);
-//      atomic_fetch_sub_32(&sdbExtConns, 1);
-//      mTrace("connection from %s is closed", pConn->pUser->user);
-//      memset(pConn, 0, sizeof(SConnObj));
-//    }
-//
-//    return NULL;
-//  }
-//
-//#ifdef CLUSTER
-//  if (sdbInited == NULL || sdbStatus != SDB_STATUS_SERVING) {
-//    taosSendSimpleRsp(thandle, pMsg->msgType + 1, TSDB_CODE_NOT_READY);
-//    mTrace("shell msg is ignored since SDB is not ready");
-//  }
-//#endif
-//
-//  if (pConn == NULL) {
-//    pConn = connList + pMsg->destId;
-//    pConn->thandle = thandle;
-//    strcpy(pConn->user, pMsg->meterId);
-//    pConn->usePublicIp = (pMsg->destIp == tsPublicIpInt ? 1 : 0);
-//    mTrace("pConn:%p is rebuild, destIp:%s publicIp:%s usePublicIp:%u",
-//            pConn, taosIpStr(pMsg->destIp), taosIpStr(tsPublicIpInt), pConn->usePublicIp);
-//  }
-//
-//  if (pMsg->msgType == TSDB_MSG_TYPE_CONNECT) {
-//    (*mgmtProcessShellMsg[pMsg->msgType])((char *)pMsg->content, pMsg->msgLen - sizeof(SIntMsg), pConn);
-//  } else {
-//    SMgmtHead *pHead = (SMgmtHead *)pMsg->content;
-//    if (pConn->pAcct == NULL) {
-//      pConn->pUser = mgmtGetUser(pConn->user);
-//      if (pConn->pUser) {
-//        pConn->pAcct = mgmtGetAcct(pConn->pUser->acct);
-//        mgmtEstablishConn(pConn);
-//        mTrace("login from:%x:%hu", pConn->ip, htons(pConn->port));
-//      }
-//    }
-//
-//    if (pConn->pAcct) {
-//      if (pConn->pDb == NULL || strncmp(pConn->pDb->name, pHead->db, tListLen(pConn->pDb->name)) != 0) {
-//        pConn->pDb = mgmtGetDb(pHead->db);
-//      }
-//
-//      char *cont = (char *)pMsg->content + sizeof(SMgmtHead);
-//      int32_t   contLen = pMsg->msgLen - sizeof(SIntMsg) - sizeof(SMgmtHead);
-//
-//      // read-only request can be executed concurrently
-//      if ((pMsg->msgType == TSDB_MSG_TYPE_TABLE_META && (!mgmtCheckMeterMetaMsgType(cont))) ||
-//          pMsg->msgType == TSDB_MSG_TYPE_STABLE_META || pMsg->msgType == TSDB_MSG_TYPE_DNODE_RETRIEVE ||
-//          pMsg->msgType == TSDB_MSG_TYPE_SHOW || pMsg->msgType == TSDB_MSG_TYPE_MULTI_TABLE_META) {
-//        (*mgmtProcessShellMsg[pMsg->msgType])(cont, contLen, pConn);
-//      } else {
-//        if (mgmtProcessShellMsg[pMsg->msgType]) {
-//          SSchedMsg schedMsg;
-//          schedMsg.msg = malloc(pMsg->msgLen);  // Message to deal with
-//          memcpy(schedMsg.msg, pMsg, pMsg->msgLen);
-//
-//          schedMsg.fp = mgmtProcessTranRequest;
-//          schedMsg.tfp = NULL;
-//          schedMsg.thandle = pConn;
-//
-//          taosScheduleTask(tsMgmtTranQhandle, &schedMsg);
-//        } else {
-//          mError("%s from shell is not processed", taosMsg[pMsg->msgType]);
-//        }
-//      }
-//    } else {
-//      taosSendSimpleRsp(thandle, pMsg->msgType + 1, TSDB_CODE_DISCONNECTED);
-//    }
-//  }
-//
-//  if (pConn->pAcct == NULL) {
-//    taosCloseRpcConn(pConn->thandle);
-//    memset(pConn, 0, sizeof(SConnObj));  // close the connection;
-//    pConn = NULL;
-//  }
-//
-//  return pConn;
+/**
+ * check if we need to add mgmtProcessMeterMetaMsg into tranQueue, which will be executed one-by-one.
+ */
+static bool mgmtCheckMeterMetaMsgType(void *pMsg) {
+  SMeterInfoMsg *pInfo = (SMeterInfoMsg *) pMsg;
+  int16_t autoCreate = htons(pInfo->createFlag);
+  STableInfo *pTable = mgmtGetTable(pInfo->meterId);
+
+  // If table does not exists and autoCreate flag is set, we add the handler into task queue
+  bool addIntoTranQueue = (pTable == NULL && autoCreate == 1);
+  if (addIntoTranQueue) {
+    mTrace("meter:%s auto created task added", pInfo->meterId);
+  }
+
+  return addIntoTranQueue;
+}
+
+static bool mgmtCheckMsgReadOnly(int8_t type, void *pCont) {
+  if ((type == TSDB_MSG_TYPE_TABLE_META && (!mgmtCheckMeterMetaMsgType(pCont)))  ||
+       type == TSDB_MSG_TYPE_STABLE_META || type == TSDB_MSG_TYPE_DNODE_RETRIEVE ||
+       type == TSDB_MSG_TYPE_SHOW || type == TSDB_MSG_TYPE_MULTI_TABLE_META      ||
+       type == TSDB_MSG_TYPE_CONNECT) {
+    return true;
+  }
+
+  return false;
+}
+
+static void mgmtProcessMsgFromShell(char type, void *pCont, int contLen, void *ahandle, int32_t code) {
+  if (sdbGetRunStatus() != SDB_STATUS_SERVING) {
+    mTrace("shell msg is ignored since SDB is not ready");
+    rpcSendResponse(ahandle, TSDB_CODE_NOT_READY, NULL, 0);
+    rpcFreeCont(pCont);
+    return;
+  }
+
+  if (mgmtCheckMsgReadOnly(type, pCont)) {
+    (*mgmtProcessShellMsg[(int8_t)type])(pCont, contLen, ahandle);
+  } else {
+    if (mgmtProcessShellMsg[(int8_t)type]) {
+      mgmtAddToTranRequest((int8_t)type, pCont, contLen, ahandle);
+    } else {
+      mError("%s from shell is not processed", taosMsg[(int8_t)type]);
+    }
+  }
+  rpcFreeCont(pCont);
 }
 
 void mgmtInitProcessShellMsg() {
@@ -1499,7 +1390,7 @@ void mgmtInitProcessShellMsg() {
   mgmtProcessShellMsg[TSDB_MSG_TYPE_DNODE_RETRIEVE] = mgmtProcessRetrieveMsg;
   mgmtProcessShellMsg[TSDB_MSG_TYPE_SHOW] = mgmtProcessShowMsg;
   mgmtProcessShellMsg[TSDB_MSG_TYPE_CONNECT] = mgmtProcessConnectMsg;
-//  mgmtProcessShellMsg[TSDB_MSG_TYPE_HEARTBEAT] = mgmtProcessHeartBeatMsg;
+  mgmtProcessShellMsg[TSDB_MSG_TYPE_HEARTBEAT] = mgmtProcessHeartBeatMsg;
   mgmtProcessShellMsg[TSDB_MSG_TYPE_CREATE_DNODE] = mgmtProcessCreateDnodeMsg;
   mgmtProcessShellMsg[TSDB_MSG_TYPE_DROP_DNODE] = mgmtProcessDropDnodeMsg;
   mgmtProcessShellMsg[TSDB_MSG_TYPE_CREATE_MNODE] = mgmtProcessCreateMnodeMsg;
@@ -1511,49 +1402,49 @@ void mgmtInitProcessShellMsg() {
   mgmtProcessShellMsg[TSDB_MSG_TYPE_KILL_CONNECTION] = mgmtProcessKillConnectionMsg;
 }
 
-int32_t mgmtCheckRedirectMsgImp(SConnObj *pConn, int32_t msgType) {
+int32_t mgmtCheckRedirectMsgImp(void *pConn, int32_t msgType) {
   return 0;
 }
-int32_t (*mgmtCheckRedirectMsg)(SConnObj *pConn, int32_t msgType) = mgmtCheckRedirectMsgImp;
+int32_t (*mgmtCheckRedirectMsg)(void *pConn, int32_t msgType) = mgmtCheckRedirectMsgImp;
 
-int32_t mgmtProcessAlterAcctMsgImp(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessAlterAcctMsgImp(void *pCont, int32_t contLen, void *ahandle) {
   //return taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_ALTER_ACCT_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
-int32_t (*mgmtProcessAlterAcctMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn) = mgmtProcessAlterAcctMsgImp;
+int32_t (*mgmtProcessAlterAcctMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessAlterAcctMsgImp;
 
-int32_t mgmtProcessCreateDnodeMsgImp(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCreateDnodeMsgImp(void *pCont, int32_t contLen, void *ahandle) {
   //return taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_CREATE_DNODE_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
-int32_t (*mgmtProcessCreateDnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn) = mgmtProcessCreateDnodeMsgImp;
+int32_t (*mgmtProcessCreateDnodeMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessCreateDnodeMsgImp;
 
-int32_t mgmtProcessCfgMnodeMsgImp(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCfgMnodeMsgImp(void *pCont, int32_t contLen, void *ahandle) {
   //return taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_CFG_MNODE_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
-int32_t (*mgmtProcessCfgMnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn) = mgmtProcessCfgMnodeMsgImp;
+int32_t (*mgmtProcessCfgMnodeMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessCfgMnodeMsgImp;
 
-int32_t mgmtProcessDropMnodeMsgImp(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessDropMnodeMsgImp(void *pCont, int32_t contLen, void *ahandle) {
   //return taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_DROP_MNODE_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
-int32_t (*mgmtProcessDropMnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn) = mgmtProcessDropMnodeMsgImp;
+int32_t (*mgmtProcessDropMnodeMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessDropMnodeMsgImp;
 
-int32_t mgmtProcessDropDnodeMsgImp(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessDropDnodeMsgImp(void *pCont, int32_t contLen, void *ahandle) {
   //return taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_DROP_DNODE_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
-int32_t (*mgmtProcessDropDnodeMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn) = mgmtProcessDropDnodeMsgImp;
+int32_t (*mgmtProcessDropDnodeMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessDropDnodeMsgImp;
 
-int32_t mgmtProcessDropAcctMsgImp(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessDropAcctMsgImp(void *pCont, int32_t contLen, void *ahandle) {
 //  return taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_DROP_ACCT_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
-int32_t (*mgmtProcessDropAcctMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn) = mgmtProcessDropAcctMsgImp;
+int32_t (*mgmtProcessDropAcctMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessDropAcctMsgImp;
 
-int32_t mgmtProcessCreateAcctMsgImp(char *pMsg, int32_t msgLen, SConnObj *pConn) {
+int32_t mgmtProcessCreateAcctMsgImp(void *pCont, int32_t contLen, void *ahandle) {
 //  return taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_CREATE_ACCT_RSP, TSDB_CODE_OPS_NOT_SUPPORT);
   return 0;
 }
-int32_t (*mgmtProcessCreateAcctMsg)(char *pMsg, int32_t msgLen, SConnObj *pConn) = mgmtProcessCreateAcctMsgImp;
\ No newline at end of file
+int32_t (*mgmtProcessCreateAcctMsg)(void *pCont, int32_t contLen, void *ahandle) = mgmtProcessCreateAcctMsgImp;
\ No newline at end of file
diff --git a/src/mnode/src/mgmtSuperTable.c b/src/mnode/src/mgmtSuperTable.c
index efdda6f22351db9646427f481a4f2d6480de9bd0..3b6c53bce2f13aacf68be78c9327d8a3167f1c46 100644
--- a/src/mnode/src/mgmtSuperTable.c
+++ b/src/mnode/src/mgmtSuperTable.c
@@ -457,130 +457,130 @@ int32_t mgmtDropSuperTableColumnByName(SSuperTableObj *pStable, char *colName) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtGetSuperTableMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
-  int32_t cols = 0;
-
-  SDbObj *pDb = NULL;
-  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
-
-  if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
-
-  SSchema *pSchema = tsGetSchema(pMeta);
-
-  pShow->bytes[cols] = TSDB_METER_NAME_LEN;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "created_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "columns");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "tags");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "tables");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htons(cols);
-  pShow->numOfColumns = cols;
-
-  pShow->offset[0] = 0;
-  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-
-  pShow->numOfRows = pDb->numOfMetrics;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+int32_t mgmtGetSuperTableMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
+//  int32_t cols = 0;
+//
+//  SDbObj *pDb = NULL;
+//  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+//
+//  if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
+//
+//  SSchema *pSchema = tsGetSchema(pMeta);
+//
+//  pShow->bytes[cols] = TSDB_METER_NAME_LEN;
+//  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//  strcpy(pSchema[cols].name, "name");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 8;
+//  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
+//  strcpy(pSchema[cols].name, "created_time");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 2;
+//  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
+//  strcpy(pSchema[cols].name, "columns");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 2;
+//  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
+//  strcpy(pSchema[cols].name, "tags");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 4;
+//  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+//  strcpy(pSchema[cols].name, "tables");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pMeta->numOfColumns = htons(cols);
+//  pShow->numOfColumns = cols;
+//
+//  pShow->offset[0] = 0;
+//  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
+//
+//  pShow->numOfRows = pDb->numOfMetrics;
+//  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
   return 0;
 }
 
-int32_t mgmtRetrieveSuperTables(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t         numOfRows = 0;
-  char *          pWrite;
-  int32_t         cols = 0;
-  SSuperTableObj *pTable = NULL;
-  char            prefix[20] = {0};
-  int32_t         prefixLen;
-
-  SDbObj *pDb = NULL;
-  if (pConn->pDb != NULL) {
-    pDb = mgmtGetDb(pConn->pDb->name);
-  }
-
-  if (pDb == NULL) {
-    return 0;
-  }
-
-  if (mgmtCheckIsMonitorDB(pDb->name, tsMonitorDbName)) {
-    if (strcmp(pConn->pUser->user, "root") != 0 && strcmp(pConn->pUser->user, "_root") != 0 && strcmp(pConn->pUser->user, "monitor") != 0 ) {
-      return 0;
-    }
-  }
-
-  strcpy(prefix, pDb->name);
-  strcat(prefix, TS_PATH_DELIMITER);
-  prefixLen = strlen(prefix);
-
-  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-  char metricName[TSDB_METER_NAME_LEN] = {0};
-
-  while (numOfRows < rows) {
-    pTable = (SSuperTableObj *)pShow->pNode;
-    if (pTable == NULL) break;
-    //pShow->pNode = (void *)pTable->next;
-
-    if (strncmp(pTable->tableId, prefix, prefixLen)) {
-      continue;
-    }
-
-    memset(metricName, 0, tListLen(metricName));
-    extractTableName(pTable->tableId, metricName);
-
-    if (pShow->payloadLen > 0 &&
-        patternMatch(pShow->payload, metricName, TSDB_METER_NAME_LEN, &info) != TSDB_PATTERN_MATCH)
-      continue;
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    extractTableName(pTable->tableId, pWrite);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pTable->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pTable->numOfColumns;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pTable->numOfTags;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pTable->numOfTables;
-    cols++;
-
-    numOfRows++;
-  }
-
-  pShow->numOfReads += numOfRows;
+//  char *          pWrite;
+//  int32_t         cols = 0;
+//  SSuperTableObj *pTable = NULL;
+//  char            prefix[20] = {0};
+//  int32_t         prefixLen;
+//
+//  SDbObj *pDb = NULL;
+//  if (pConn->pDb != NULL) {
+//    pDb = mgmtGetDb(pConn->pDb->name);
+//  }
+//
+//  if (pDb == NULL) {
+//    return 0;
+//  }
+//
+//  if (mgmtCheckIsMonitorDB(pDb->name, tsMonitorDbName)) {
+//    if (strcmp(pConn->pUser->user, "root") != 0 && strcmp(pConn->pUser->user, "_root") != 0 && strcmp(pConn->pUser->user, "monitor") != 0 ) {
+//      return 0;
+//    }
+//  }
+//
+//  strcpy(prefix, pDb->name);
+//  strcat(prefix, TS_PATH_DELIMITER);
+//  prefixLen = strlen(prefix);
+//
+//  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
+//  char metricName[TSDB_METER_NAME_LEN] = {0};
+//
+//  while (numOfRows < rows) {
+//    pTable = (SSuperTableObj *)pShow->pNode;
+//    if (pTable == NULL) break;
+//    //pShow->pNode = (void *)pTable->next;
+//
+//    if (strncmp(pTable->tableId, prefix, prefixLen)) {
+//      continue;
+//    }
+//
+//    memset(metricName, 0, tListLen(metricName));
+//    extractTableName(pTable->tableId, metricName);
+//
+//    if (pShow->payloadLen > 0 &&
+//        patternMatch(pShow->payload, metricName, TSDB_METER_NAME_LEN, &info) != TSDB_PATTERN_MATCH)
+//      continue;
+//
+//    cols = 0;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    extractTableName(pTable->tableId, pWrite);
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int64_t *)pWrite = pTable->createdTime;
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int16_t *)pWrite = pTable->numOfColumns;
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int16_t *)pWrite = pTable->numOfTags;
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int32_t *)pWrite = pTable->numOfTables;
+//    cols++;
+//
+//    numOfRows++;
+//  }
+//
+//  pShow->numOfReads += numOfRows;
   return numOfRows;
 }
 
diff --git a/src/mnode/src/mgmtTable.c b/src/mnode/src/mgmtTable.c
index f2a2e0cb9272fc2b8ca7473e5b79e75f3e56576f..c52b3c04dfa24d3014456ca7ca6f44a00d068246 100644
--- a/src/mnode/src/mgmtTable.c
+++ b/src/mnode/src/mgmtTable.c
@@ -229,54 +229,54 @@ void mgmtCleanUpMeters() {
   mgmtCleanUpSuperTables();
 }
 
-int32_t mgmtGetTableMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
-  int32_t cols = 0;
-
-  SDbObj *pDb = NULL;
-  if (pConn->pDb != NULL) {
-    pDb = mgmtGetDb(pConn->pDb->name);
-  }
-
-  if (pDb == NULL) {
-    return TSDB_CODE_DB_NOT_SELECTED;
-  }
-
-  SSchema *pSchema = tsGetSchema(pMeta);
-
-  pShow->bytes[cols] = TSDB_METER_NAME_LEN;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "table_name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "created_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "columns");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_METER_NAME_LEN;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "stable");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htons(cols);
-  pShow->numOfColumns = cols;
-
-  pShow->offset[0] = 0;
-  for (int32_t i = 1; i < cols; ++i) {
-    pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-  }
-
-  pShow->numOfRows = pDb->numOfTables;
-  pShow->rowSize   = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+int32_t mgmtGetTableMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
+//  int32_t cols = 0;
+//
+//  SDbObj *pDb = NULL;
+//  if (pConn->pDb != NULL) {
+//    pDb = mgmtGetDb(pConn->pDb->name);
+//  }
+//
+//  if (pDb == NULL) {
+//    return TSDB_CODE_DB_NOT_SELECTED;
+//  }
+//
+//  SSchema *pSchema = tsGetSchema(pMeta);
+//
+//  pShow->bytes[cols] = TSDB_METER_NAME_LEN;
+//  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//  strcpy(pSchema[cols].name, "table_name");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 8;
+//  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
+//  strcpy(pSchema[cols].name, "created_time");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 2;
+//  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
+//  strcpy(pSchema[cols].name, "columns");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = TSDB_METER_NAME_LEN;
+//  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//  strcpy(pSchema[cols].name, "stable");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pMeta->numOfColumns = htons(cols);
+//  pShow->numOfColumns = cols;
+//
+//  pShow->offset[0] = 0;
+//  for (int32_t i = 1; i < cols; ++i) {
+//    pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
+//  }
+//
+//  pShow->numOfRows = pDb->numOfTables;
+//  pShow->rowSize   = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
   return 0;
 }
@@ -292,117 +292,117 @@ static void mgmtVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_
   }
 }
 
-int32_t mgmtRetrieveTables(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows  = 0;
-  int32_t numOfRead  = 0;
-  int32_t cols       = 0;
-  void    *pTable    = NULL;
-  char    *pWrite    = NULL;
-
-  int16_t numOfColumns;
-  int64_t createdTime;
-  char    *tableId;
-  char    *superTableId;
-  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-
-  SDbObj *pDb = NULL;
-  if (pConn->pDb != NULL) {
-    pDb = mgmtGetDb(pConn->pDb->name);
-  }
-
-  if (pDb == NULL) {
-    return 0;
-  }
-
-  if (mgmtCheckIsMonitorDB(pDb->name, tsMonitorDbName)) {
-    if (strcmp(pConn->pUser->user, "root") != 0 && strcmp(pConn->pUser->user, "_root") != 0 &&
-        strcmp(pConn->pUser->user, "monitor") != 0) {
-      return 0;
-    }
-  }
-
-  char prefix[20] = {0};
-  strcpy(prefix, pDb->name);
-  strcat(prefix, TS_PATH_DELIMITER);
-  int32_t prefixLen = strlen(prefix);
-
-  while (numOfRows < rows) {
-    void *pNormalTableNode = sdbFetchRow(tsNormalTableSdb, pShow->pNode, (void **) &pTable);
-    if (pTable != NULL) {
-      SNormalTableObj *pNormalTable = (SNormalTableObj *) pTable;
-      pShow->pNode = pNormalTableNode;
-      tableId      = pNormalTable->tableId;
-      superTableId = NULL;
-      createdTime  = pNormalTable->createdTime;
-      numOfColumns = pNormalTable->numOfColumns;
-    } else {
-      void *pStreamTableNode = sdbFetchRow(tsStreamTableSdb, pShow->pNode, (void **) &pTable);
-      if (pTable != NULL) {
-        SStreamTableObj *pChildTable = (SStreamTableObj *) pTable;
-        pShow->pNode = pStreamTableNode;
-        tableId      = pChildTable->tableId;
-        superTableId = NULL;
-        createdTime  = pChildTable->createdTime;
-        numOfColumns = pChildTable->numOfColumns;
-      } else {
-        void *pChildTableNode = sdbFetchRow(tsChildTableSdb, pShow->pNode, (void **) &pTable);
-        if (pTable != NULL) {
-          SChildTableObj *pChildTable = (SChildTableObj *) pTable;
-          pShow->pNode = pChildTableNode;
-          tableId      = pChildTable->tableId;
-          superTableId = NULL;
-          createdTime  = pChildTable->createdTime;
-          numOfColumns = pChildTable->superTable->numOfColumns;
-        } else {
-          break;
-        }
-      }
-    }
-
-    // not belong to current db
-    if (strncmp(tableId, prefix, prefixLen)) {
-      continue;
-    }
-
-    char meterName[TSDB_METER_NAME_LEN] = {0};
-    memset(meterName, 0, tListLen(meterName));
-    numOfRead++;
-
-    // pattern compare for meter name
-    extractTableName(tableId, meterName);
-
-    if (pShow->payloadLen > 0 &&
-        patternMatch(pShow->payload, meterName, TSDB_METER_NAME_LEN, &info) != TSDB_PATTERN_MATCH) {
-      continue;
-    }
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    strncpy(pWrite, meterName, TSDB_METER_NAME_LEN);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *) pWrite = createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *) pWrite = numOfColumns;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (superTableId != NULL) {
-      extractTableName(superTableId, pWrite);
-    }
-    cols++;
-
-    numOfRows++;
-  }
-
-  pShow->numOfReads += numOfRead;
-  const int32_t NUM_OF_COLUMNS = 4;
-
-  mgmtVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow);
+//  int32_t numOfRead  = 0;
+//  int32_t cols       = 0;
+//  void    *pTable    = NULL;
+//  char    *pWrite    = NULL;
+//
+//  int16_t numOfColumns;
+//  int64_t createdTime;
+//  char    *tableId;
+//  char    *superTableId;
+//  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
+//
+//  SDbObj *pDb = NULL;
+//  if (pConn->pDb != NULL) {
+//    pDb = mgmtGetDb(pConn->pDb->name);
+//  }
+//
+//  if (pDb == NULL) {
+//    return 0;
+//  }
+//
+//  if (mgmtCheckIsMonitorDB(pDb->name, tsMonitorDbName)) {
+//    if (strcmp(pConn->pUser->user, "root") != 0 && strcmp(pConn->pUser->user, "_root") != 0 &&
+//        strcmp(pConn->pUser->user, "monitor") != 0) {
+//      return 0;
+//    }
+//  }
+//
+//  char prefix[20] = {0};
+//  strcpy(prefix, pDb->name);
+//  strcat(prefix, TS_PATH_DELIMITER);
+//  int32_t prefixLen = strlen(prefix);
+//
+//  while (numOfRows < rows) {
+//    void *pNormalTableNode = sdbFetchRow(tsNormalTableSdb, pShow->pNode, (void **) &pTable);
+//    if (pTable != NULL) {
+//      SNormalTableObj *pNormalTable = (SNormalTableObj *) pTable;
+//      pShow->pNode = pNormalTableNode;
+//      tableId      = pNormalTable->tableId;
+//      superTableId = NULL;
+//      createdTime  = pNormalTable->createdTime;
+//      numOfColumns = pNormalTable->numOfColumns;
+//    } else {
+//      void *pStreamTableNode = sdbFetchRow(tsStreamTableSdb, pShow->pNode, (void **) &pTable);
+//      if (pTable != NULL) {
+//        SStreamTableObj *pChildTable = (SStreamTableObj *) pTable;
+//        pShow->pNode = pStreamTableNode;
+//        tableId      = pChildTable->tableId;
+//        superTableId = NULL;
+//        createdTime  = pChildTable->createdTime;
+//        numOfColumns = pChildTable->numOfColumns;
+//      } else {
+//        void *pChildTableNode = sdbFetchRow(tsChildTableSdb, pShow->pNode, (void **) &pTable);
+//        if (pTable != NULL) {
+//          SChildTableObj *pChildTable = (SChildTableObj *) pTable;
+//          pShow->pNode = pChildTableNode;
+//          tableId      = pChildTable->tableId;
+//          superTableId = NULL;
+//          createdTime  = pChildTable->createdTime;
+//          numOfColumns = pChildTable->superTable->numOfColumns;
+//        } else {
+//          break;
+//        }
+//      }
+//    }
+//
+//    // not belong to current db
+//    if (strncmp(tableId, prefix, prefixLen)) {
+//      continue;
+//    }
+//
+//    char meterName[TSDB_METER_NAME_LEN] = {0};
+//    memset(meterName, 0, tListLen(meterName));
+//    numOfRead++;
+//
+//    // pattern compare for meter name
+//    extractTableName(tableId, meterName);
+//
+//    if (pShow->payloadLen > 0 &&
+//        patternMatch(pShow->payload, meterName, TSDB_METER_NAME_LEN, &info) != TSDB_PATTERN_MATCH) {
+//      continue;
+//    }
+//
+//    cols = 0;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    strncpy(pWrite, meterName, TSDB_METER_NAME_LEN);
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int64_t *) pWrite = createdTime;
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int16_t *) pWrite = numOfColumns;
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    if (superTableId != NULL) {
+//      extractTableName(superTableId, pWrite);
+//    }
+//    cols++;
+//
+//    numOfRows++;
+//  }
+//
+//  pShow->numOfReads += numOfRead;
+//  const int32_t NUM_OF_COLUMNS = 4;
+//
+//  mgmtVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow);
 
   return numOfRows;
 }
diff --git a/src/mnode/src/mgmtUser.c b/src/mnode/src/mgmtUser.c
index dde526f4e4621b4157bb3eec2a63beb81c198f89..e03325a922bc2929b16fd0aaed3d6a5369254eb6 100644
--- a/src/mnode/src/mgmtUser.c
+++ b/src/mnode/src/mgmtUser.c
@@ -153,75 +153,75 @@ void mgmtCleanUpUsers() {
   sdbCloseTable(tsUserSdb);
 }
 
-int32_t mgmtGetUserMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
-  int32_t      cols = 0;
-  SSchema *pSchema = tsGetSchema(pMeta);
-
-  pShow->bytes[cols] = TSDB_USER_LEN;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 6;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "privilege");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "created time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htons(cols);
-  pShow->numOfColumns = cols;
-
-  pShow->offset[0] = 0;
-  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-
-  pShow->numOfRows = pConn->pAcct->acctInfo.numOfUsers;
-  pShow->pNode = pConn->pAcct->pUser;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+int32_t mgmtGetUserMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
+//  int32_t      cols = 0;
+//  SSchema *pSchema = tsGetSchema(pMeta);
+//
+//  pShow->bytes[cols] = TSDB_USER_LEN;
+//  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//  strcpy(pSchema[cols].name, "name");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 6;
+//  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//  strcpy(pSchema[cols].name, "privilege");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 8;
+//  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
+//  strcpy(pSchema[cols].name, "created time");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pMeta->numOfColumns = htons(cols);
+//  pShow->numOfColumns = cols;
+//
+//  pShow->offset[0] = 0;
+//  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
+//
+//  pShow->numOfRows = pConn->pAcct->acctInfo.numOfUsers;
+//  pShow->pNode = pConn->pAcct->pUser;
+//  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
   return 0;
 }
 
-int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t       numOfRows = 0;
-  SUserObj *pUser = NULL;
-  char *    pWrite;
-  int32_t       cols = 0;
-
-  while (numOfRows < rows) {
-    pUser = (SUserObj *)pShow->pNode;
-    if (pUser == NULL) break;
-    pShow->pNode = (void *)pUser->next;
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    strcpy(pWrite, pUser->user);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (pUser->superAuth) {
-      strcpy(pWrite, "super");
-    } else if (pUser->writeAuth) {
-      strcpy(pWrite, "write");
-    } else {
-      strcpy(pWrite, "read");
-    }
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pUser->createdTime;
-    cols++;
-
-    numOfRows++;
-  }
-  pShow->numOfReads += numOfRows;
+//  SUserObj *pUser = NULL;
+//  char *    pWrite;
+//  int32_t       cols = 0;
+//
+//  while (numOfRows < rows) {
+//    pUser = (SUserObj *)pShow->pNode;
+//    if (pUser == NULL) break;
+//    pShow->pNode = (void *)pUser->next;
+//
+//    cols = 0;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    strcpy(pWrite, pUser->user);
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    if (pUser->superAuth) {
+//      strcpy(pWrite, "super");
+//    } else if (pUser->writeAuth) {
+//      strcpy(pWrite, "write");
+//    } else {
+//      strcpy(pWrite, "read");
+//    }
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int64_t *)pWrite = pUser->createdTime;
+//    cols++;
+//
+//    numOfRows++;
+//  }
+//  pShow->numOfReads += numOfRows;
   return numOfRows;
 }
 
@@ -279,3 +279,9 @@ void *mgmtUserActionDestroy(void *row, char *str, int32_t size, int32_t *ssize)
   tfree(row);
   return NULL;
 }
+
+SUserObj *mgmtGetUserFromConn(void *pConn) {
+  SRpcConnInfo connInfo;
+  rpcGetConnInfo(pConn, &connInfo);
+  return mgmtGetUser(connInfo.user);
+}
diff --git a/src/mnode/src/mgmtVgroup.c b/src/mnode/src/mgmtVgroup.c
index 701a1d66960f0ef3b8903a7107a165a76911ce4f..eae6987ec8e1e752589987651e87c2fb4a1a5be7 100644
--- a/src/mnode/src/mgmtVgroup.c
+++ b/src/mnode/src/mgmtVgroup.c
@@ -248,168 +248,168 @@ void mgmtSetVgroupIdPool() {
 
 void mgmtCleanUpVgroups() { sdbCloseTable(tsVgroupSdb); }
 
-int32_t mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
-  int32_t cols = 0;
-
-  SDbObj *pDb = NULL;
-  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
-
-  if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
-
-  SSchema *pSchema = tsGetSchema(pMeta);
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "vgId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "meters");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 9;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "vgroup status");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  int32_t maxReplica = 0;
-  SVgObj  *pVgroup   = NULL;
-  STableInfo *pTable = NULL;
-  if (pShow->payloadLen > 0 ) {
-    pTable = mgmtGetTable(pShow->payload);
-    if (NULL == pTable) {
-      return TSDB_CODE_INVALID_TABLE_ID;
-    }
-
-    pVgroup = mgmtGetVgroup(pTable->vgId);
-    if (NULL == pVgroup) return TSDB_CODE_INVALID_TABLE_ID;
-
-    maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
-  } else {
-    SVgObj *pVgroup = pDb->pHead;
-    while (pVgroup != NULL) {
-      maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
-      pVgroup = pVgroup->next;
-    }
-  }
-
-  for (int32_t i = 0; i < maxReplica; ++i) {
-    pShow->bytes[cols] = 16;
-    pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-    strcpy(pSchema[cols].name, "ip");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 2;
-    pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-    strcpy(pSchema[cols].name, "vnode");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 9;
-    pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-    strcpy(pSchema[cols].name, "vnode status");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 16;
-    pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-    strcpy(pSchema[cols].name, "public ip");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-  }
-
-  pMeta->numOfColumns = htons(cols);
-  pShow->numOfColumns = cols;
-
-  pShow->offset[0] = 0;
-  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  if (NULL == pTable) {
-    pShow->numOfRows = pDb->numOfVgroups;
-    pShow->pNode = pDb->pHead;
-  } else {
-    pShow->numOfRows = 1;
-    pShow->pNode = pVgroup;
-  }
+int32_t mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, void *pConn) {
+//  int32_t cols = 0;
+//
+//  SDbObj *pDb = NULL;
+//  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+//
+//  if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
+//
+//  SSchema *pSchema = tsGetSchema(pMeta);
+//
+//  pShow->bytes[cols] = 4;
+//  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+//  strcpy(pSchema[cols].name, "vgId");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 4;
+//  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+//  strcpy(pSchema[cols].name, "meters");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  pShow->bytes[cols] = 9;
+//  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//  strcpy(pSchema[cols].name, "vgroup status");
+//  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//  cols++;
+//
+//  int32_t maxReplica = 0;
+//  SVgObj  *pVgroup   = NULL;
+//  STableInfo *pTable = NULL;
+//  if (pShow->payloadLen > 0 ) {
+//    pTable = mgmtGetTable(pShow->payload);
+//    if (NULL == pTable) {
+//      return TSDB_CODE_INVALID_TABLE_ID;
+//    }
+//
+//    pVgroup = mgmtGetVgroup(pTable->vgId);
+//    if (NULL == pVgroup) return TSDB_CODE_INVALID_TABLE_ID;
+//
+//    maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
+//  } else {
+//    SVgObj *pVgroup = pDb->pHead;
+//    while (pVgroup != NULL) {
+//      maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
+//      pVgroup = pVgroup->next;
+//    }
+//  }
+//
+//  for (int32_t i = 0; i < maxReplica; ++i) {
+//    pShow->bytes[cols] = 16;
+//    pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//    strcpy(pSchema[cols].name, "ip");
+//    pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//    cols++;
+//
+//    pShow->bytes[cols] = 2;
+//    pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
+//    strcpy(pSchema[cols].name, "vnode");
+//    pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//    cols++;
+//
+//    pShow->bytes[cols] = 9;
+//    pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//    strcpy(pSchema[cols].name, "vnode status");
+//    pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//    cols++;
+//
+//    pShow->bytes[cols] = 16;
+//    pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+//    strcpy(pSchema[cols].name, "public ip");
+//    pSchema[cols].bytes = htons(pShow->bytes[cols]);
+//    cols++;
+//  }
+//
+//  pMeta->numOfColumns = htons(cols);
+//  pShow->numOfColumns = cols;
+//
+//  pShow->offset[0] = 0;
+//  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
+//
+//  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+//
+//  if (NULL == pTable) {
+//    pShow->numOfRows = pDb->numOfVgroups;
+//    pShow->pNode = pDb->pHead;
+//  } else {
+//    pShow->numOfRows = 1;
+//    pShow->pNode = pVgroup;
+//  }
 
   return 0;
 }
 
-int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, SConnObj *pConn) {
+int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows = 0;
-  SVgObj *pVgroup = NULL;
-  char *  pWrite;
-  int32_t cols = 0;
-  char    ipstr[20];
-
-  int32_t maxReplica = 0;
-
-  SDbObj *pDb = NULL;
-  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
-  assert(pDb != NULL);
-
-  pVgroup = pDb->pHead;
-  while (pVgroup != NULL) {
-    maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
-    pVgroup = pVgroup->next;
-  }
-
-  while (numOfRows < rows) {
-    //    pShow->pNode = sdbFetchRow(tsVgroupSdb, pShow->pNode, (void **)&pVgroup);
-    pVgroup = (SVgObj *)pShow->pNode;
-    if (pVgroup == NULL) break;
-    pShow->pNode = (void *)pVgroup->next;
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pVgroup->vgId;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pVgroup->numOfTables;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    strcpy(pWrite, taosGetVgroupLbStatusStr(pVgroup->lbStatus));
-    cols++;
-
-    for (int32_t i = 0; i < maxReplica; ++i) {
-      tinet_ntoa(ipstr, pVgroup->vnodeGid[i].ip);
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      strcpy(pWrite, ipstr);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int16_t *)pWrite = pVgroup->vnodeGid[i].vnode;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      if (pVgroup->vnodeGid[i].ip != 0) {
-        char *vnodeStatus = mgmtGetVnodeStatus(pVgroup, pVgroup->vnodeGid + i);
-        strcpy(pWrite, vnodeStatus);
-      } else {
-        strcpy(pWrite, "null");
-      }
-      cols++;
-
-      tinet_ntoa(ipstr, pVgroup->vnodeGid[i].publicIp);
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      strcpy(pWrite, ipstr);
-      cols++;
-    }
-
-    numOfRows++;
-  }
-
-  pShow->numOfReads += numOfRows;
+//  SVgObj *pVgroup = NULL;
+//  char *  pWrite;
+//  int32_t cols = 0;
+//  char    ipstr[20];
+//
+//  int32_t maxReplica = 0;
+//
+//  SDbObj *pDb = NULL;
+//  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+//  assert(pDb != NULL);
+//
+//  pVgroup = pDb->pHead;
+//  while (pVgroup != NULL) {
+//    maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
+//    pVgroup = pVgroup->next;
+//  }
+//
+//  while (numOfRows < rows) {
+//    //    pShow->pNode = sdbFetchRow(tsVgroupSdb, pShow->pNode, (void **)&pVgroup);
+//    pVgroup = (SVgObj *)pShow->pNode;
+//    if (pVgroup == NULL) break;
+//    pShow->pNode = (void *)pVgroup->next;
+//
+//    cols = 0;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int32_t *)pWrite = pVgroup->vgId;
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    *(int32_t *)pWrite = pVgroup->numOfTables;
+//    cols++;
+//
+//    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//    strcpy(pWrite, taosGetVgroupLbStatusStr(pVgroup->lbStatus));
+//    cols++;
+//
+//    for (int32_t i = 0; i < maxReplica; ++i) {
+//      tinet_ntoa(ipstr, pVgroup->vnodeGid[i].ip);
+//      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//      strcpy(pWrite, ipstr);
+//      cols++;
+//
+//      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//      *(int16_t *)pWrite = pVgroup->vnodeGid[i].vnode;
+//      cols++;
+//
+//      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//      if (pVgroup->vnodeGid[i].ip != 0) {
+//        char *vnodeStatus = mgmtGetVnodeStatus(pVgroup, pVgroup->vnodeGid + i);
+//        strcpy(pWrite, vnodeStatus);
+//      } else {
+//        strcpy(pWrite, "null");
+//      }
+//      cols++;
+//
+//      tinet_ntoa(ipstr, pVgroup->vnodeGid[i].publicIp);
+//      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+//      strcpy(pWrite, ipstr);
+//      cols++;
+//    }
+//
+//    numOfRows++;
+//  }
+//
+//  pShow->numOfReads += numOfRows;
   return numOfRows;
 }
 
diff --git a/src/plugins/monitor/src/monitorSystem.c b/src/plugins/monitor/src/monitorSystem.c
index f8653e4320ef12a8e26576240b3ecd8313e19d01..5a42d66493b56e6d3a252b2ededbc786b9445089 100644
--- a/src/plugins/monitor/src/monitorSystem.c
+++ b/src/plugins/monitor/src/monitorSystem.c
@@ -216,7 +216,8 @@ void monitorInitDatabaseCb(void *param, TAOS_RES *result, int code) {
   if (-code == TSDB_CODE_TABLE_ALREADY_EXIST || -code == TSDB_CODE_DB_ALREADY_EXIST || code >= 0) {
     monitorTrace("monitor:%p, sql success, code:%d, %s", monitor->conn, code, monitor->sql);
     if (monitor->cmdIndex == MONITOR_CMD_CREATE_TB_LOG) {
-      taosLogFp = monitorSaveLog;
+      //TODO
+      //taosLogFp = monitorSaveLog;
       taosLogSqlFp = monitorExecuteSQL;
       taosLogAcctFp = monitorSaveAcctLog;
       monitorLPrint("dnode:%s is started", tsPrivateIp);
diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index 8ce625f6fda441f5e362df0646e4861a0c73989f..caa1ea5c75f5d484eba3381dc389225089139685 100755
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -796,6 +796,7 @@ static void *rpcProcessMsgFromPeer(SRecvInfo *pRecv) {
 }
 
 static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead) {
+
   SRpcInfo *pRpc = pConn->pRpc;
 
   pHead = rpcDecompressRpcMsg(pHead);
diff --git a/src/sdb/src/sdbEngine.c b/src/sdb/src/sdbEngine.c
index fdf79607249f3721aa487fb0344ca0bafb2d2642..4b000a30ebd5406809dbe7d37575236d7af08162 100644
--- a/src/sdb/src/sdbEngine.c
+++ b/src/sdb/src/sdbEngine.c
@@ -24,8 +24,9 @@
 extern char   version[];
 const int16_t sdbFileVersion = 0;
 int           sdbExtConns = 0;
-SIpList      *pSdbIpList = NULL;
-SIpList      *pSdbPublicIpList = NULL;
+SRpcIpSet    *pSdbIpList = NULL;
+SRpcIpSet    *pSdbPublicIpList = NULL;
+SSdbPeer *    sdbPeer[SDB_MAX_PEERS];  // first slot for self
 
 #ifdef CLUSTER
 int           sdbMaster = 0;
@@ -57,6 +58,17 @@ int64_t sdbGetVersion() {
   return sdbVersion;
 };
 
+int32_t sdbGetRunStatus() {
+  if (!tsIsCluster) {
+    return SDB_STATUS_SERVING;
+  }
+
+  if (sdbInited == NULL) {
+    return SDB_STATUS_OFFLINE;
+  }
+  return sdbStatus;
+}
+
 void sdbFinishCommit(void *handle) {
   SSdbTable *pTable = (SSdbTable *)handle;
   uint32_t   sdbEcommit = SDB_ENDCOMMIT;