From 20f1e3f5e516fde2f0f2a388498da1ff5b219907 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 17:22:19 +0800
Subject: [PATCH 1/9] refact dnode

---
 include/libs/transport/trpc.h             |  7 +++++--
 source/dnode/mgmt/bm/src/bmWorker.c       |  2 +-
 source/dnode/mgmt/main/inc/dnd.h          |  2 --
 source/dnode/mgmt/main/src/dndExec.c      |  2 +-
 source/dnode/mgmt/main/src/dndMsg.c       |  2 +-
 source/dnode/mgmt/main/src/dndTransport.c | 25 ++++++++++-------------
 source/dnode/mgmt/mm/src/mmWorker.c       |  4 ++--
 source/dnode/mgmt/qm/src/qmWorker.c       |  2 +-
 source/dnode/mgmt/vm/src/vmWorker.c       |  4 ++--
 9 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/include/libs/transport/trpc.h b/include/libs/transport/trpc.h
index 157e0cb721..3e2f596784 100644
--- a/include/libs/transport/trpc.h
+++ b/include/libs/transport/trpc.h
@@ -58,6 +58,9 @@ typedef struct {
   void    *pNode;
 } SNodeMsg;
 
+typedef void (*RpcCfp)(void *parent, SRpcMsg *, SEpSet *);
+typedef int (*RpcAfp)(void *parent, char *tableId, char *spi, char *encrypt, char *secret, char *ckey);
+
 typedef struct SRpcInit {
   uint16_t localPort;     // local port
   char *   label;         // for debug purpose
@@ -74,10 +77,10 @@ typedef struct SRpcInit {
   char *ckey;     // ciphering key
 
   // call back to process incoming msg, code shall be ignored by server app
-  void (*cfp)(void *parent, SRpcMsg *, SEpSet *);
+  RpcCfp cfp;
 
   // call back to retrieve the client auth info, for server app only
-  int (*afp)(void *parent, char *tableId, char *spi, char *encrypt, char *secret, char *ckey);
+  RpcAfp afp;;
 
   void *parent;
 } SRpcInit;
diff --git a/source/dnode/mgmt/bm/src/bmWorker.c b/source/dnode/mgmt/bm/src/bmWorker.c
index 932c008e34..a5a97f6af0 100644
--- a/source/dnode/mgmt/bm/src/bmWorker.c
+++ b/source/dnode/mgmt/bm/src/bmWorker.c
@@ -18,7 +18,7 @@
 
 static void bmSendErrorRsp(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int32_t code) {
   SRpcMsg rpcRsp = {.handle = pMsg->rpcMsg.handle, .ahandle = pMsg->rpcMsg.ahandle, .code = code};
-  dndSendRsp(pWrapper, &rpcRsp);
+  tmsgSendRsp(&rpcRsp);
 
   dTrace("msg:%p, is freed", pMsg);
   rpcFreeCont(pMsg->rpcMsg.pCont);
diff --git a/source/dnode/mgmt/main/inc/dnd.h b/source/dnode/mgmt/main/inc/dnd.h
index f3a409f257..cf33787108 100644
--- a/source/dnode/mgmt/main/inc/dnd.h
+++ b/source/dnode/mgmt/main/inc/dnd.h
@@ -166,8 +166,6 @@ int32_t dndInitClient(SDnode *pDnode);
 void    dndCleanupClient(SDnode *pDnode);
 int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
 int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pMsg);
-void    dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp);
-void    dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
 SMsgCb  dndCreateMsgcb(SMgmtWrapper *pWrapper);
 
 #ifdef __cplusplus
diff --git a/source/dnode/mgmt/main/src/dndExec.c b/source/dnode/mgmt/main/src/dndExec.c
index 8837da6d48..3bbdb1a686 100644
--- a/source/dnode/mgmt/main/src/dndExec.c
+++ b/source/dnode/mgmt/main/src/dndExec.c
@@ -78,7 +78,7 @@ static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t
     dError("msg:%p, failed to process since code:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
     if (pRpc->msgType & 1U) {
       SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
-      dndSendRsp(pWrapper, &rsp);
+      tmsgSendRsp(&rsp);
     }
 
     dTrace("msg:%p, is freed", pMsg);
diff --git a/source/dnode/mgmt/main/src/dndMsg.c b/source/dnode/mgmt/main/src/dndMsg.c
index bb0f8ccb89..76b66467bf 100644
--- a/source/dnode/mgmt/main/src/dndMsg.c
+++ b/source/dnode/mgmt/main/src/dndMsg.c
@@ -86,7 +86,7 @@ _OVER:
     dError("msg:%p, failed to process since 0x%04x:%s", pMsg, code & 0XFFFF, terrstr());
     if (pRpc->msgType & 1U) {
       SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
-      dndSendRsp(pWrapper, &rsp);
+      tmsgSendRsp(&rsp);
     }
     dTrace("msg:%p, is freed", pMsg);
     taosFreeQitem(pMsg);
diff --git a/source/dnode/mgmt/main/src/dndTransport.c b/source/dnode/mgmt/main/src/dndTransport.c
index d463f2ba7a..f863db2a0c 100644
--- a/source/dnode/mgmt/main/src/dndTransport.c
+++ b/source/dnode/mgmt/main/src/dndTransport.c
@@ -36,8 +36,7 @@ static inline void dndProcessQMVnodeRpcMsg(SMsgHandle *pHandle, SRpcMsg *pMsg, S
   dndProcessRpcMsg(pWrapper, pMsg, pEpSet);
 }
 
-static void dndProcessResponse(void *parent, SRpcMsg *pRsp, SEpSet *pEpSet) {
-  SDnode     *pDnode = parent;
+static void dndProcessResponse(SDnode *pDnode, SRpcMsg *pRsp, SEpSet *pEpSet) {
   STransMgmt *pMgmt = &pDnode->trans;
   tmsg_t      msgType = pRsp->msgType;
 
@@ -69,7 +68,7 @@ int32_t dndInitClient(SDnode *pDnode) {
   memset(&rpcInit, 0, sizeof(rpcInit));
   rpcInit.label = "DND";
   rpcInit.numOfThreads = 1;
-  rpcInit.cfp = dndProcessResponse;
+  rpcInit.cfp = (RpcCfp)dndProcessResponse;
   rpcInit.sessions = 1024;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
@@ -101,8 +100,7 @@ void dndCleanupClient(SDnode *pDnode) {
   }
 }
 
-static void dndProcessRequest(void *param, SRpcMsg *pReq, SEpSet *pEpSet) {
-  SDnode     *pDnode = param;
+static void dndProcessRequest(SDnode *pDnode, SRpcMsg *pReq, SEpSet *pEpSet) {
   STransMgmt *pMgmt = &pDnode->trans;
   tmsg_t      msgType = pReq->msgType;
 
@@ -179,10 +177,8 @@ static int32_t dndGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *e
   return code;
 }
 
-static int32_t dndRetrieveUserAuthInfo(void *parent, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
-  SDnode *pDnode = parent;
-
-  if (dndGetHideUserAuth(parent, user, spi, encrypt, secret, ckey) == 0) {
+static int32_t dndRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+  if (dndGetHideUserAuth(pDnode, user, spi, encrypt, secret, ckey) == 0) {
     dTrace("user:%s, get auth from mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
     return 0;
   }
@@ -244,11 +240,11 @@ int32_t dndInitServer(SDnode *pDnode) {
   rpcInit.localPort = pDnode->serverPort;
   rpcInit.label = "DND";
   rpcInit.numOfThreads = numOfThreads;
-  rpcInit.cfp = dndProcessRequest;
+  rpcInit.cfp = (RpcCfp)dndProcessRequest;
   rpcInit.sessions = tsMaxShellConns;
   rpcInit.connType = TAOS_CONN_SERVER;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
-  rpcInit.afp = dndRetrieveUserAuthInfo;
+  rpcInit.afp = (RpcAfp)dndRetrieveUserAuthInfo;
   rpcInit.parent = pDnode;
 
   pMgmt->serverRpc = rpcOpen(&rpcInit);
@@ -363,6 +359,7 @@ int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq)
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
+
     memcpy(pHead, pReq, sizeof(SRpcMsg));
     memcpy(pHead + sizeof(SRpcMsg), pEpSet, sizeof(SEpSet));
 
@@ -372,7 +369,7 @@ int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq)
   }
 }
 
-void dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
+static void dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
   if (pWrapper->procType != PROC_CHILD) {
     dndSendRpcRsp(pWrapper, pRsp);
   } else {
@@ -380,7 +377,7 @@ void dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
   }
 }
 
-void dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
+static void dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
   if (pWrapper->procType != PROC_CHILD) {
     rpcRegisterBrokenLinkArg(pMsg);
   } else {
@@ -406,4 +403,4 @@ SMsgCb dndCreateMsgcb(SMgmtWrapper *pWrapper) {
       .releaseHandleFp = dndReleaseHandle,
   };
   return msgCb;
-}
\ No newline at end of file
+}
diff --git a/source/dnode/mgmt/mm/src/mmWorker.c b/source/dnode/mgmt/mm/src/mmWorker.c
index c4aafe05e4..cde4eb853a 100644
--- a/source/dnode/mgmt/mm/src/mmWorker.c
+++ b/source/dnode/mgmt/mm/src/mmWorker.c
@@ -37,7 +37,7 @@ static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
         dError("msg:%p, failed to process since %s", pMsg, terrstr());
       }
       SRpcMsg rsp = {.handle = pRpc->handle, .code = code, .contLen = pMsg->rspLen, .pCont = pMsg->pRsp};
-      dndSendRsp(pMgmt->pWrapper, &rsp);
+      tmsgSendRsp(&rsp);
     }
   }
 
@@ -60,7 +60,7 @@ static void mmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
     if (pRpc->handle != NULL && code != 0) {
       dError("msg:%p, failed to process since %s", pMsg, terrstr());
       SRpcMsg rsp = {.handle = pRpc->handle, .code = code, .ahandle = pRpc->ahandle};
-      dndSendRsp(pMgmt->pWrapper, &rsp);
+      tmsgSendRsp(&rsp);
     }
   }
 
diff --git a/source/dnode/mgmt/qm/src/qmWorker.c b/source/dnode/mgmt/qm/src/qmWorker.c
index 14efb311b1..5ceb9dbf88 100644
--- a/source/dnode/mgmt/qm/src/qmWorker.c
+++ b/source/dnode/mgmt/qm/src/qmWorker.c
@@ -18,7 +18,7 @@
 
 static void qmSendRsp(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int32_t code) {
   SRpcMsg rsp = {.handle = pMsg->rpcMsg.handle, .ahandle = pMsg->rpcMsg.ahandle, .code = code};
-  dndSendRsp(pWrapper, &rsp);
+  tmsgSendRsp(&rsp);
 }
 
 static void qmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
diff --git a/source/dnode/mgmt/vm/src/vmWorker.c b/source/dnode/mgmt/vm/src/vmWorker.c
index 4be6311cf8..c228e6e7dd 100644
--- a/source/dnode/mgmt/vm/src/vmWorker.c
+++ b/source/dnode/mgmt/vm/src/vmWorker.c
@@ -18,7 +18,7 @@
 
 static void vmSendRsp(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int32_t code) {
   SRpcMsg rsp = {.handle = pMsg->rpcMsg.handle, .ahandle = pMsg->rpcMsg.ahandle, .code = code};
-  dndSendRsp(pWrapper, &rsp);
+  tmsgSendRsp(&rsp);
 }
 
 static void vmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
@@ -116,7 +116,7 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
     int32_t code = vnodeApplyWMsg(pVnode->pImpl, pRpc, &pRsp);
     if (pRsp != NULL) {
       pRsp->ahandle = pRpc->ahandle;
-      dndSendRsp(pVnode->pWrapper, pRsp);
+      tmsgSendRsp(pRsp);
       taosMemoryFree(pRsp);
     } else {
       if (code != 0 && terrno != 0) code = terrno;

From 2eb30ee0f0a6e486a6b3c87471b2e4d7ca4f8b8c Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 18:08:38 +0800
Subject: [PATCH 2/9] refact transport

---
 source/dnode/mgmt/dm/inc/dmInt.h          |   1 +
 source/dnode/mgmt/dm/src/dmInt.c          |  14 +--
 source/dnode/mgmt/dm/src/dmMsg.c          |   4 +-
 source/dnode/mgmt/main/inc/dnd.h          |  12 +--
 source/dnode/mgmt/main/inc/dndInt.h       |   1 -
 source/dnode/mgmt/main/src/dndExec.c      |  63 -----------
 source/dnode/mgmt/main/src/dndInt.c       |   1 +
 source/dnode/mgmt/main/src/dndTransport.c | 125 ++++++++++++++++------
 8 files changed, 106 insertions(+), 115 deletions(-)

diff --git a/source/dnode/mgmt/dm/inc/dmInt.h b/source/dnode/mgmt/dm/inc/dmInt.h
index 3036d1f5ad..79d7e926ce 100644
--- a/source/dnode/mgmt/dm/inc/dmInt.h
+++ b/source/dnode/mgmt/dm/inc/dmInt.h
@@ -33,6 +33,7 @@ typedef struct SDnodeMgmt {
   SRWLatch      latch;
   SSingleWorker mgmtWorker;
   SSingleWorker statusWorker;
+  SMsgCb        msgCb;
   const char   *path;
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;
diff --git a/source/dnode/mgmt/dm/src/dmInt.c b/source/dnode/mgmt/dm/src/dmInt.c
index 3c5f394d5e..8c46c402ab 100644
--- a/source/dnode/mgmt/dm/src/dmInt.c
+++ b/source/dnode/mgmt/dm/src/dmInt.c
@@ -112,17 +112,14 @@ int32_t dmInit(SMgmtWrapper *pWrapper) {
     return -1;
   }
 
-  if (dndInitServer(pDnode) != 0) {
-    dError("failed to init trans server since %s", terrstr());
-    return -1;
-  }
-
-  if (dndInitClient(pDnode) != 0) {
-    dError("failed to init trans client since %s", terrstr());
+  if (dndInitTrans(pDnode) != 0) {
+    dError("failed to init transport since %s", terrstr());
     return -1;
   }
 
   pWrapper->pMgmt = pMgmt;
+  pMgmt->msgCb = dndCreateMsgcb(pWrapper);
+
   dInfo("dnode-mgmt is initialized");
   return 0;
 }
@@ -151,8 +148,7 @@ void dmCleanup(SMgmtWrapper *pWrapper) {
 
   taosMemoryFree(pMgmt);
   pWrapper->pMgmt = NULL;
-  dndCleanupServer(pDnode);
-  dndCleanupClient(pDnode);
+  dndCleanupTrans(pDnode);
 
   dInfo("dnode-mgmt is cleaned up");
 }
diff --git a/source/dnode/mgmt/dm/src/dmMsg.c b/source/dnode/mgmt/dm/src/dmMsg.c
index 3795cffbfa..02a288e2fd 100644
--- a/source/dnode/mgmt/dm/src/dmMsg.c
+++ b/source/dnode/mgmt/dm/src/dmMsg.c
@@ -57,7 +57,9 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
   pMgmt->statusSent = 1;
 
   dTrace("send req:%s to mnode, app:%p", TMSG_INFO(rpcMsg.msgType), rpcMsg.ahandle);
-  dndSendReqToMnode(pMgmt->pWrapper, &rpcMsg);
+  SEpSet epSet = {0};
+  dmGetMnodeEpSet(pMgmt, &epSet);
+  tmsgSendReq(&pMgmt->msgCb, &epSet, &rpcMsg);
 }
 
 static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) {
diff --git a/source/dnode/mgmt/main/inc/dnd.h b/source/dnode/mgmt/main/inc/dnd.h
index cf33787108..d948aa305c 100644
--- a/source/dnode/mgmt/main/inc/dnd.h
+++ b/source/dnode/mgmt/main/inc/dnd.h
@@ -92,6 +92,7 @@ typedef struct SMgmtWrapper {
   char       *path;
   int32_t     refCount;
   SRWLatch    latch;
+  ENodeType   ntype;
   bool        deployed;
   bool        required;
   EProcType   procType;
@@ -160,13 +161,10 @@ const char *dndNodeProcStr(ENodeType ntype);
 const char *dndEventStr(EDndEvent ev);
 
 // dndTransport.h
-int32_t dndInitServer(SDnode *pDnode);
-void    dndCleanupServer(SDnode *pDnode);
-int32_t dndInitClient(SDnode *pDnode);
-void    dndCleanupClient(SDnode *pDnode);
-int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
-int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pMsg);
-SMsgCb  dndCreateMsgcb(SMgmtWrapper *pWrapper);
+int32_t  dndInitTrans(SDnode *pDnode);
+void     dndCleanupTrans(SDnode *pDnode);
+SMsgCb   dndCreateMsgcb(SMgmtWrapper *pWrapper);
+SProcCfg dndGenProcCfg(SMgmtWrapper *pWrapper);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/mgmt/main/inc/dndInt.h b/source/dnode/mgmt/main/inc/dndInt.h
index 0c4ada1df3..b4d9de5184 100644
--- a/source/dnode/mgmt/main/inc/dndInt.h
+++ b/source/dnode/mgmt/main/inc/dndInt.h
@@ -49,7 +49,6 @@ void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg);
 
 // dndTransport.c
 int32_t dndInitMsgHandle(SDnode *pDnode);
-void    dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp);
 
 // dndFile.c
 TdFilePtr dndCheckRunning(const char *dataDir);
diff --git a/source/dnode/mgmt/main/src/dndExec.c b/source/dnode/mgmt/main/src/dndExec.c
index 3bbdb1a686..a98c0954fe 100644
--- a/source/dnode/mgmt/main/src/dndExec.c
+++ b/source/dnode/mgmt/main/src/dndExec.c
@@ -65,53 +65,6 @@ void dndCloseNode(SMgmtWrapper *pWrapper) {
   dDebug("node:%s, mgmt has been closed", pWrapper->name);
 }
 
-static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
-                                 ProcFuncType ftype) {
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
-  pRpc->pCont = pCont;
-  dTrace("msg:%p, get from child queue, handle:%p app:%p", pMsg, pRpc->handle, pRpc->ahandle);
-
-  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
-  int32_t   code = (*msgFp)(pWrapper, pMsg);
-
-  if (code != 0) {
-    dError("msg:%p, failed to process since code:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-    if (pRpc->msgType & 1U) {
-      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
-      tmsgSendRsp(&rsp);
-    }
-
-    dTrace("msg:%p, is freed", pMsg);
-    taosFreeQitem(pMsg);
-    rpcFreeCont(pCont);
-  }
-}
-
-static void dndConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
-                                  ProcFuncType ftype) {
-  pMsg->pCont = pCont;
-  dTrace("msg:%p, get from parent queue, ftype:%d handle:%p, app:%p", pMsg, ftype, pMsg->handle, pMsg->ahandle);
-
-  switch (ftype) {
-    case PROC_REGIST:
-      rpcRegisterBrokenLinkArg(pMsg);
-      break;
-    case PROC_RELEASE:
-      rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
-      rpcFreeCont(pCont);
-      break;
-    case PROC_REQ:
-      dndSendReqToMnode(pWrapper, pMsg);
-      // dndSendReq(pWrapper, (const SEpSet *)((char *)pMsg + sizeof(SRpcMsg)), pMsg);
-      break;
-    case PROC_RSP:
-      dndSendRpcRsp(pWrapper, pMsg);
-      break;
-    default:
-      break;
-  }
-  taosMemoryFree(pMsg);
-}
 
 static int32_t dndNewProc(SMgmtWrapper *pWrapper, ENodeType n) {
   char  tstr[8] = {0};
@@ -135,22 +88,6 @@ static int32_t dndNewProc(SMgmtWrapper *pWrapper, ENodeType n) {
   return 0;
 }
 
-static SProcCfg dndGenProcCfg(SMgmtWrapper *pWrapper) {
-  SProcCfg cfg = {.childConsumeFp = (ProcConsumeFp)dndConsumeChildQueue,
-                  .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
-                  .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
-                  .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-                  .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-                  .parentConsumeFp = (ProcConsumeFp)dndConsumeParentQueue,
-                  .parentMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
-                  .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
-                  .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-                  .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-                  .shm = pWrapper->shm,
-                  .pParent = pWrapper,
-                  .name = pWrapper->name};
-  return cfg;
-}
 
 static int32_t dndRunInSingleProcess(SDnode *pDnode) {
   dInfo("dnode run in single process");
diff --git a/source/dnode/mgmt/main/src/dndInt.c b/source/dnode/mgmt/main/src/dndInt.c
index 25e4d89c5b..5e4b0a1f7b 100644
--- a/source/dnode/mgmt/main/src/dndInt.c
+++ b/source/dnode/mgmt/main/src/dndInt.c
@@ -95,6 +95,7 @@ SDnode *dndCreate(const SDnodeOpt *pOption) {
     pWrapper->path = strdup(path);
     pWrapper->shm.id = -1;
     pWrapper->pDnode = pDnode;
+    pWrapper->ntype = n;
     if (pWrapper->path == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       goto _OVER;
diff --git a/source/dnode/mgmt/main/src/dndTransport.c b/source/dnode/mgmt/main/src/dndTransport.c
index f863db2a0c..cefa77890d 100644
--- a/source/dnode/mgmt/main/src/dndTransport.c
+++ b/source/dnode/mgmt/main/src/dndTransport.c
@@ -61,7 +61,7 @@ static void dndProcessResponse(SDnode *pDnode, SRpcMsg *pRsp, SEpSet *pEpSet) {
   }
 }
 
-int32_t dndInitClient(SDnode *pDnode) {
+static int32_t dndInitClient(SDnode *pDnode) {
   STransMgmt *pMgmt = &pDnode->trans;
 
   SRpcInit rpcInit;
@@ -91,7 +91,7 @@ int32_t dndInitClient(SDnode *pDnode) {
   return 0;
 }
 
-void dndCleanupClient(SDnode *pDnode) {
+static void dndCleanupClient(SDnode *pDnode) {
   STransMgmt *pMgmt = &pDnode->trans;
   if (pMgmt->clientRpc) {
     rpcClose(pMgmt->clientRpc);
@@ -227,7 +227,7 @@ static int32_t dndRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, ch
   return rpcRsp.code;
 }
 
-int32_t dndInitServer(SDnode *pDnode) {
+static int32_t dndInitServer(SDnode *pDnode) {
   STransMgmt *pMgmt = &pDnode->trans;
 
   int32_t numOfThreads = (int32_t)((tsNumOfCores * tsNumOfThreadsPerCore) / 2.0);
@@ -257,7 +257,7 @@ int32_t dndInitServer(SDnode *pDnode) {
   return 0;
 }
 
-void dndCleanupServer(SDnode *pDnode) {
+static void dndCleanupServer(SDnode *pDnode) {
   STransMgmt *pMgmt = &pDnode->trans;
   if (pMgmt->serverRpc) {
     rpcClose(pMgmt->serverRpc);
@@ -266,6 +266,17 @@ void dndCleanupServer(SDnode *pDnode) {
   }
 }
 
+int32_t dndInitTrans(SDnode *pDnode) {
+  if (dndInitServer(pDnode) != 0) return -1;
+  if (dndInitClient(pDnode) != 0) return -1;
+  return 0;
+}
+
+void dndCleanupTrans(SDnode *pDnode) {
+  dndCleanupServer(pDnode);
+  dndCleanupClient(pDnode);
+}
+
 int32_t dndInitMsgHandle(SDnode *pDnode) {
   STransMgmt *pMgmt = &pDnode->trans;
 
@@ -315,46 +326,28 @@ static int32_t dndSendRpcReq(STransMgmt *pMgmt, const SEpSet *pEpSet, SRpcMsg *p
   return 0;
 }
 
-int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pReq) {
-  SDnode     *pDnode = pWrapper->pDnode;
-  STransMgmt *pTrans = &pDnode->trans;
-  SEpSet      epSet = {0};
-
-  SMgmtWrapper *pWrapper2 = dndAcquireWrapper(pDnode, DNODE);
-  if (pWrapper2 != NULL) {
-    dmGetMnodeEpSet(pWrapper2->pMgmt, &epSet);
-    dndReleaseWrapper(pWrapper2);
-  }
-  return dndSendRpcReq(pTrans, &epSet, pReq);
-}
-
-void dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
+static void dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
   if (pRsp->code == TSDB_CODE_APP_NOT_READY) {
-    SMgmtWrapper *pDnodeWrapper = dndAcquireWrapper(pWrapper->pDnode, DNODE);
-    if (pDnodeWrapper != NULL) {
-      dmSendRedirectRsp(pDnodeWrapper->pMgmt, pRsp);
-      dndReleaseWrapper(pDnodeWrapper);
-    } else {
-      rpcSendResponse(pRsp);
+    if (pWrapper->ntype == MNODE) {
+      dmSendRedirectRsp(pWrapper->pMgmt, pRsp);
+      return;
     }
-  } else {
-    rpcSendResponse(pRsp);
   }
+
+  rpcSendResponse(pRsp);
 }
 
-int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq) {
-  SDnode *pDnode = pWrapper->pDnode;
-  if (dndGetStatus(pDnode) != DND_STAT_RUNNING) {
+static int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq) {
+  if (dndGetStatus(pWrapper->pDnode) != DND_STAT_RUNNING) {
     terrno = TSDB_CODE_DND_OFFLINE;
     dError("failed to send rpc msg since %s, handle:%p", terrstr(), pReq->handle);
     return -1;
   }
 
   if (pWrapper->procType != PROC_CHILD) {
-    return dndSendRpcReq(&pDnode->trans, pEpSet, pReq);
+    return dndSendRpcReq(&pWrapper->pDnode->trans, pEpSet, pReq);
   } else {
-    int32_t headLen = sizeof(SRpcMsg) + sizeof(SEpSet);
-    char   *pHead = taosMemoryMalloc(headLen);
+    char *pHead = taosMemoryMalloc(sizeof(SRpcMsg) + sizeof(SEpSet));
     if (pHead == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
@@ -362,8 +355,8 @@ int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq)
 
     memcpy(pHead, pReq, sizeof(SRpcMsg));
     memcpy(pHead + sizeof(SRpcMsg), pEpSet, sizeof(SEpSet));
-
-    taosProcPutToParentQ(pWrapper->pProc, pReq, headLen, pReq->pCont, pReq->contLen, PROC_REQ);
+    taosProcPutToParentQ(pWrapper->pProc, pHead, sizeof(SRpcMsg) + sizeof(SEpSet), pReq->pCont, pReq->contLen,
+                         PROC_REQ);
     taosMemoryFree(pHead);
     return 0;
   }
@@ -404,3 +397,67 @@ SMsgCb dndCreateMsgcb(SMgmtWrapper *pWrapper) {
   };
   return msgCb;
 }
+
+static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
+                                 ProcFuncType ftype) {
+  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  pRpc->pCont = pCont;
+  dTrace("msg:%p, get from child queue, handle:%p app:%p", pMsg, pRpc->handle, pRpc->ahandle);
+
+  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
+  int32_t   code = (*msgFp)(pWrapper, pMsg);
+
+  if (code != 0) {
+    dError("msg:%p, failed to process since code:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
+    if (pRpc->msgType & 1U) {
+      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
+      dndSendRsp(pWrapper, &rsp);
+    }
+
+    dTrace("msg:%p, is freed", pMsg);
+    taosFreeQitem(pMsg);
+    rpcFreeCont(pCont);
+  }
+}
+
+static void dndConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
+                                  ProcFuncType ftype) {
+  pMsg->pCont = pCont;
+  dTrace("msg:%p, get from parent queue, ftype:%d handle:%p, app:%p", pMsg, ftype, pMsg->handle, pMsg->ahandle);
+
+  switch (ftype) {
+    case PROC_REGIST:
+      rpcRegisterBrokenLinkArg(pMsg);
+      break;
+    case PROC_RELEASE:
+      rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
+      rpcFreeCont(pCont);
+      break;
+    case PROC_REQ:
+      dndSendRpcReq(&pWrapper->pDnode->trans, (SEpSet *)((char *)pMsg + sizeof(SRpcMsg)), pMsg);
+      break;
+    case PROC_RSP:
+      dndSendRpcRsp(pWrapper, pMsg);
+      break;
+    default:
+      break;
+  }
+  taosMemoryFree(pMsg);
+}
+
+SProcCfg dndGenProcCfg(SMgmtWrapper *pWrapper) {
+  SProcCfg cfg = {.childConsumeFp = (ProcConsumeFp)dndConsumeChildQueue,
+                  .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
+                  .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
+                  .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                  .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                  .parentConsumeFp = (ProcConsumeFp)dndConsumeParentQueue,
+                  .parentMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
+                  .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
+                  .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                  .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                  .shm = pWrapper->shm,
+                  .pParent = pWrapper,
+                  .name = pWrapper->name};
+  return cfg;
+}
\ No newline at end of file

From 745fa09bbb903f042755cefb446f3661cb1b793a Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 18:58:28 +0800
Subject: [PATCH 3/9] refact transport

---
 source/dnode/mgmt/bm/inc/bm.h             | 31 ---------------
 source/dnode/mgmt/bm/inc/bmInt.h          |  2 +-
 source/dnode/mgmt/dm/inc/dm.h             | 38 -------------------
 source/dnode/mgmt/dm/inc/dmInt.h          |  3 +-
 source/dnode/mgmt/dm/src/dmMsg.c          |  1 -
 source/dnode/mgmt/dm/src/dmWorker.c       |  5 ---
 source/dnode/mgmt/main/inc/dnd.h          | 30 +++++++++++++++
 source/dnode/mgmt/main/inc/dndInt.h       | 10 -----
 source/dnode/mgmt/main/src/dndStr.c       |  2 +-
 source/dnode/mgmt/main/src/dndTransport.c | 37 ++++--------------
 source/dnode/mgmt/mm/inc/mm.h             | 35 -----------------
 source/dnode/mgmt/mm/inc/mmInt.h          |  2 +-
 source/dnode/mgmt/mm/src/mmInt.c          |  8 ----
 source/dnode/mgmt/qm/inc/qm.h             | 31 ---------------
 source/dnode/mgmt/qm/inc/qmInt.h          |  2 +-
 source/dnode/mgmt/sm/inc/sm.h             | 31 ---------------
 source/dnode/mgmt/sm/inc/smInt.h          |  2 +-
 source/dnode/mgmt/vm/inc/vm.h             | 46 -----------------------
 source/dnode/mgmt/vm/inc/vmInt.h          |  2 +-
 19 files changed, 45 insertions(+), 273 deletions(-)
 delete mode 100644 source/dnode/mgmt/bm/inc/bm.h
 delete mode 100644 source/dnode/mgmt/dm/inc/dm.h
 delete mode 100644 source/dnode/mgmt/mm/inc/mm.h
 delete mode 100644 source/dnode/mgmt/qm/inc/qm.h
 delete mode 100644 source/dnode/mgmt/sm/inc/sm.h
 delete mode 100644 source/dnode/mgmt/vm/inc/vm.h

diff --git a/source/dnode/mgmt/bm/inc/bm.h b/source/dnode/mgmt/bm/inc/bm.h
deleted file mode 100644
index 79cf76d113..0000000000
--- a/source/dnode/mgmt/bm/inc/bm.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_BNODE_H_
-#define _TD_DND_BNODE_H_
-
-#include "dnd.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void bmGetMgmtFp(SMgmtWrapper *pWrapper);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_BNODE_H_*/
\ No newline at end of file
diff --git a/source/dnode/mgmt/bm/inc/bmInt.h b/source/dnode/mgmt/bm/inc/bmInt.h
index f19ba4e034..7a719633fa 100644
--- a/source/dnode/mgmt/bm/inc/bmInt.h
+++ b/source/dnode/mgmt/bm/inc/bmInt.h
@@ -16,7 +16,7 @@
 #ifndef _TD_DND_BNODE_INT_H_
 #define _TD_DND_BNODE_INT_H_
 
-#include "bm.h"
+#include "dnd.h"
 #include "bnode.h"
 
 #ifdef __cplusplus
diff --git a/source/dnode/mgmt/dm/inc/dm.h b/source/dnode/mgmt/dm/inc/dm.h
deleted file mode 100644
index 3984e6dbd4..0000000000
--- a/source/dnode/mgmt/dm/inc/dm.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_DNODE_H_
-#define _TD_DND_DNODE_H_
-
-#include "dnd.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SDnodeMgmt SDnodeMgmt;
-
-void dmGetMgmtFp(SMgmtWrapper *pWrapper);
-void dmInitMsgHandles(SMgmtWrapper *pWrapper);
-
-void    dmGetMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
-void    dmUpdateMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
-void    dmSendRedirectRsp(SDnodeMgmt *pMgmt, const SRpcMsg *pMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_DNODE_H_*/
\ No newline at end of file
diff --git a/source/dnode/mgmt/dm/inc/dmInt.h b/source/dnode/mgmt/dm/inc/dmInt.h
index 79d7e926ce..a8f46ef7e2 100644
--- a/source/dnode/mgmt/dm/inc/dmInt.h
+++ b/source/dnode/mgmt/dm/inc/dmInt.h
@@ -16,7 +16,7 @@
 #ifndef _TD_DND_DNODE_INT_H_
 #define _TD_DND_DNODE_INT_H_
 
-#include "dm.h"
+#include "dnd.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -45,6 +45,7 @@ int32_t dmWriteFile(SDnodeMgmt *pMgmt);
 void    dmUpdateDnodeEps(SDnodeMgmt *pMgmt, SArray *pDnodeEps);
 
 // dmMsg.c
+void    dmInitMsgHandles(SMgmtWrapper *pWrapper);
 void    dmSendStatusReq(SDnodeMgmt *pMgmt);
 int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t dmProcessStatusRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
diff --git a/source/dnode/mgmt/dm/src/dmMsg.c b/source/dnode/mgmt/dm/src/dmMsg.c
index 02a288e2fd..90117044f9 100644
--- a/source/dnode/mgmt/dm/src/dmMsg.c
+++ b/source/dnode/mgmt/dm/src/dmMsg.c
@@ -15,7 +15,6 @@
 
 #define _DEFAULT_SOURCE
 #include "dmInt.h"
-#include "vm.h"
 
 void dmSendStatusReq(SDnodeMgmt *pMgmt) {
   SDnode    *pDnode = pMgmt->pDnode;
diff --git a/source/dnode/mgmt/dm/src/dmWorker.c b/source/dnode/mgmt/dm/src/dmWorker.c
index 63b9704b78..9045a44232 100644
--- a/source/dnode/mgmt/dm/src/dmWorker.c
+++ b/source/dnode/mgmt/dm/src/dmWorker.c
@@ -14,12 +14,7 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "bm.h"
 #include "dmInt.h"
-#include "mm.h"
-#include "qm.h"
-#include "sm.h"
-#include "vm.h"
 
 static void *dmThreadRoutine(void *param) {
   SDnodeMgmt *pMgmt = param;
diff --git a/source/dnode/mgmt/main/inc/dnd.h b/source/dnode/mgmt/main/inc/dnd.h
index d948aa305c..b324a279bc 100644
--- a/source/dnode/mgmt/main/inc/dnd.h
+++ b/source/dnode/mgmt/main/inc/dnd.h
@@ -165,7 +165,37 @@ int32_t  dndInitTrans(SDnode *pDnode);
 void     dndCleanupTrans(SDnode *pDnode);
 SMsgCb   dndCreateMsgcb(SMgmtWrapper *pWrapper);
 SProcCfg dndGenProcCfg(SMgmtWrapper *pWrapper);
+int32_t  dndInitMsgHandle(SDnode *pDnode);
 
+// mgmt
+void dmGetMgmtFp(SMgmtWrapper *pWrapper);
+void bmGetMgmtFp(SMgmtWrapper *pWrapper);
+void qmGetMgmtFp(SMgmtWrapper *pMgmt);
+void smGetMgmtFp(SMgmtWrapper *pWrapper);
+void vmGetMgmtFp(SMgmtWrapper *pWrapper);
+void mmGetMgmtFp(SMgmtWrapper *pMgmt);
+
+void dmGetMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
+void dmUpdateMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
+void dmSendRedirectRsp(SDnodeMgmt *pMgmt, const SRpcMsg *pMsg);
+
+typedef struct {
+  int32_t openVnodes;
+  int32_t totalVnodes;
+  int32_t masterNum;
+  int64_t numOfSelectReqs;
+  int64_t numOfInsertReqs;
+  int64_t numOfInsertSuccessReqs;
+  int64_t numOfBatchInsertReqs;
+  int64_t numOfBatchInsertSuccessReqs;
+} SVnodesStat;
+
+void    vmMonitorVnodeLoads(SMgmtWrapper *pWrapper, SArray *pLoads);
+int32_t vmMonitorTfsInfo(SMgmtWrapper *pWrapper, SMonDiskInfo *pInfo);
+void    vmMonitorVnodeReqs(SMgmtWrapper *pWrapper, SMonDnodeInfo *pInfo);
+int32_t mmMonitorMnodeInfo(SMgmtWrapper *pWrapper, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
+                         SMonGrantInfo *pGrantInfo);
+                         
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/dnode/mgmt/main/inc/dndInt.h b/source/dnode/mgmt/main/inc/dndInt.h
index b4d9de5184..5ef52e3942 100644
--- a/source/dnode/mgmt/main/inc/dndInt.h
+++ b/source/dnode/mgmt/main/inc/dndInt.h
@@ -18,13 +18,6 @@
 
 #include "dnd.h"
 
-#include "bm.h"
-#include "dm.h"
-#include "mm.h"
-#include "qm.h"
-#include "sm.h"
-#include "vm.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -47,9 +40,6 @@ void    dndHandleEvent(SDnode *pDnode, EDndEvent event);
 void dndProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, SEpSet *pEpSet);
 void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg);
 
-// dndTransport.c
-int32_t dndInitMsgHandle(SDnode *pDnode);
-
 // dndFile.c
 TdFilePtr dndCheckRunning(const char *dataDir);
 int32_t   dndReadShmFile(SDnode *pDnode);
diff --git a/source/dnode/mgmt/main/src/dndStr.c b/source/dnode/mgmt/main/src/dndStr.c
index 8a5af68b4f..caaa96de59 100644
--- a/source/dnode/mgmt/main/src/dndStr.c
+++ b/source/dnode/mgmt/main/src/dndStr.c
@@ -25,7 +25,7 @@ const char *dndStatStr(EDndStatus status) {
     case DND_STAT_STOPPED:
       return "stopped";
     default:
-      return "unknown";
+      return "UNKNOWN";
   }
 }
 
diff --git a/source/dnode/mgmt/main/src/dndTransport.c b/source/dnode/mgmt/main/src/dndTransport.c
index cefa77890d..2be2da4e46 100644
--- a/source/dnode/mgmt/main/src/dndTransport.c
+++ b/source/dnode/mgmt/main/src/dndTransport.c
@@ -142,20 +142,14 @@ static void dndProcessRequest(SDnode *pDnode, SRpcMsg *pReq, SEpSet *pEpSet) {
   }
 }
 
-static void dndSendMsgToMnodeRecv(SDnode *pDnode, SRpcMsg *pRpcMsg, SRpcMsg *pRpcRsp) {
-  STransMgmt *pMgmt = &pDnode->trans;
-  SEpSet      epSet = {0};
-
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, DNODE);
-  if (pWrapper != NULL) {
-    dmGetMnodeEpSet(pWrapper->pMgmt, &epSet);
-    dndReleaseWrapper(pWrapper);
-  }
-
-  rpcSendRecv(pMgmt->clientRpc, &epSet, pRpcMsg, pRpcRsp);
+static inline void dndSendMsgToMnodeRecv(SDnode *pDnode, SRpcMsg *pReq, SRpcMsg *pRsp) {
+  SEpSet        epSet = {0};
+  SMgmtWrapper *pWrapper = &pDnode->wrappers[DNODE];
+  dmGetMnodeEpSet(pWrapper->pMgmt, &epSet);
+  rpcSendRecv(pDnode->trans.clientRpc, &epSet, pReq, pRsp);
 }
 
-static int32_t dndGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+static inline int32_t dndGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
   int32_t code = 0;
   char    pass[TSDB_PASSWORD_LEN + 1] = {0};
 
@@ -183,21 +177,6 @@ static int32_t dndRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, ch
     return 0;
   }
 
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, MNODE);
-  if (pWrapper != NULL) {
-    if (mmGetUserAuth(pWrapper, user, spi, encrypt, secret, ckey) == 0) {
-      dndReleaseWrapper(pWrapper);
-      dTrace("user:%s, get auth from mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
-      return 0;
-    }
-    dndReleaseWrapper(pWrapper);
-  }
-
-  if (terrno != TSDB_CODE_APP_NOT_READY) {
-    dTrace("failed to get user auth from mnode since %s", terrstr());
-    return -1;
-  }
-
   SAuthReq authReq = {0};
   tstrncpy(authReq.user, user, TSDB_USER_LEN);
   int32_t contLen = tSerializeSAuthReq(NULL, 0, &authReq);
@@ -285,11 +264,9 @@ int32_t dndInitMsgHandle(SDnode *pDnode) {
 
     for (int32_t msgIndex = 0; msgIndex < TDMT_MAX; ++msgIndex) {
       NodeMsgFp msgFp = pWrapper->msgFps[msgIndex];
-      int32_t   vgId = pWrapper->msgVgIds[msgIndex];
+      int8_t    vgId = pWrapper->msgVgIds[msgIndex];
       if (msgFp == NULL) continue;
 
-      // dTrace("msg:%s will be processed by %s, vgId:%d", tMsgInfo[msgIndex], pWrapper->name, vgId);
-
       SMsgHandle *pHandle = &pMgmt->msgHandles[msgIndex];
       if (vgId == QND_VGID) {
         if (pHandle->pQndWrapper != NULL) {
diff --git a/source/dnode/mgmt/mm/inc/mm.h b/source/dnode/mgmt/mm/inc/mm.h
deleted file mode 100644
index 6ed6c42d93..0000000000
--- a/source/dnode/mgmt/mm/inc/mm.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_MNODE_H_
-#define _TD_DND_MNODE_H_
-
-#include "dnd.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void mmGetMgmtFp(SMgmtWrapper *pMgmt);
-
-int32_t mmGetUserAuth(SMgmtWrapper *pWrapper, char *user, char *spi, char *encrypt, char *secret, char *ckey);
-int32_t mmMonitorMnodeInfo(SMgmtWrapper *pWrapper, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
-                         SMonGrantInfo *pGrantInfo);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_MNODE_H_*/
\ No newline at end of file
diff --git a/source/dnode/mgmt/mm/inc/mmInt.h b/source/dnode/mgmt/mm/inc/mmInt.h
index 86cba97a33..48c11ae8c4 100644
--- a/source/dnode/mgmt/mm/inc/mmInt.h
+++ b/source/dnode/mgmt/mm/inc/mmInt.h
@@ -16,7 +16,7 @@
 #ifndef _TD_DND_MNODE_INT_H_
 #define _TD_DND_MNODE_INT_H_
 
-#include "mm.h"
+#include "dnd.h"
 #include "mnode.h"
 
 #ifdef __cplusplus
diff --git a/source/dnode/mgmt/mm/src/mmInt.c b/source/dnode/mgmt/mm/src/mmInt.c
index 301ca598e6..bd7446780d 100644
--- a/source/dnode/mgmt/mm/src/mmInt.c
+++ b/source/dnode/mgmt/mm/src/mmInt.c
@@ -241,14 +241,6 @@ void mmGetMgmtFp(SMgmtWrapper *pWrapper) {
   pWrapper->fp = mgmtFp;
 }
 
-int32_t mmGetUserAuth(SMgmtWrapper *pWrapper, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-
-  int32_t code = mndRetriveAuth(pMgmt->pMnode, user, spi, encrypt, secret, ckey);
-  dTrace("user:%s, retrieve auth spi:%d encrypt:%d", user, *spi, *encrypt);
-  return code;
-}
-
 int32_t mmMonitorMnodeInfo(SMgmtWrapper *pWrapper, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
                            SMonGrantInfo *pGrantInfo) {
   SMnodeMgmt *pMgmt = pWrapper->pMgmt;
diff --git a/source/dnode/mgmt/qm/inc/qm.h b/source/dnode/mgmt/qm/inc/qm.h
deleted file mode 100644
index e28ea3e948..0000000000
--- a/source/dnode/mgmt/qm/inc/qm.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_QNODE_H_
-#define _TD_DND_QNODE_H_
-
-#include "dnd.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void qmGetMgmtFp(SMgmtWrapper *pMgmt);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_QNODE_H_*/
\ No newline at end of file
diff --git a/source/dnode/mgmt/qm/inc/qmInt.h b/source/dnode/mgmt/qm/inc/qmInt.h
index 3e975663d3..b4d57488ef 100644
--- a/source/dnode/mgmt/qm/inc/qmInt.h
+++ b/source/dnode/mgmt/qm/inc/qmInt.h
@@ -16,7 +16,7 @@
 #ifndef _TD_DND_QNODE_INT_H_
 #define _TD_DND_QNODE_INT_H_
 
-#include "qm.h"
+#include "dnd.h"
 #include "qnode.h"
 
 #ifdef __cplusplus
diff --git a/source/dnode/mgmt/sm/inc/sm.h b/source/dnode/mgmt/sm/inc/sm.h
deleted file mode 100644
index 82a52e5d1f..0000000000
--- a/source/dnode/mgmt/sm/inc/sm.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_SNODE_H_
-#define _TD_DND_SNODE_H_
-
-#include "dnd.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void smGetMgmtFp(SMgmtWrapper *pWrapper);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_SNODE_H_*/
diff --git a/source/dnode/mgmt/sm/inc/smInt.h b/source/dnode/mgmt/sm/inc/smInt.h
index 9290384cab..2c9a43cd98 100644
--- a/source/dnode/mgmt/sm/inc/smInt.h
+++ b/source/dnode/mgmt/sm/inc/smInt.h
@@ -16,7 +16,7 @@
 #ifndef _TD_DND_SNODE_INT_H_
 #define _TD_DND_SNODE_INT_H_
 
-#include "sm.h"
+#include "dnd.h"
 #include "snode.h"
 
 #ifdef __cplusplus
diff --git a/source/dnode/mgmt/vm/inc/vm.h b/source/dnode/mgmt/vm/inc/vm.h
deleted file mode 100644
index 60d9cfc3a1..0000000000
--- a/source/dnode/mgmt/vm/inc/vm.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_VNODES_H_
-#define _TD_DND_VNODES_H_
-
-#include "dnd.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-  int32_t openVnodes;
-  int32_t totalVnodes;
-  int32_t masterNum;
-  int64_t numOfSelectReqs;
-  int64_t numOfInsertReqs;
-  int64_t numOfInsertSuccessReqs;
-  int64_t numOfBatchInsertReqs;
-  int64_t numOfBatchInsertSuccessReqs;
-} SVnodesStat;
-
-void vmGetMgmtFp(SMgmtWrapper *pWrapper);
-
-void    vmMonitorVnodeLoads(SMgmtWrapper *pWrapper, SArray *pLoads);
-int32_t vmMonitorTfsInfo(SMgmtWrapper *pWrapper, SMonDiskInfo *pInfo);
-void    vmMonitorVnodeReqs(SMgmtWrapper *pWrapper, SMonDnodeInfo *pInfo);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_VNODES_H_*/
\ No newline at end of file
diff --git a/source/dnode/mgmt/vm/inc/vmInt.h b/source/dnode/mgmt/vm/inc/vmInt.h
index 6722fe1d65..9f8eac9e97 100644
--- a/source/dnode/mgmt/vm/inc/vmInt.h
+++ b/source/dnode/mgmt/vm/inc/vmInt.h
@@ -17,7 +17,7 @@
 #define _TD_DND_VNODES_INT_H_
 
 #include "sync.h"
-#include "vm.h"
+#include "dnd.h"
 #include "vnode.h"
 
 #ifdef __cplusplus

From 6abfd9fed3eb0d0274cde2f790d06a87fb158041 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 19:21:20 +0800
Subject: [PATCH 4/9] refact transport

---
 source/dnode/mgmt/main/inc/dndInt.h       |   1 -
 source/dnode/mgmt/main/src/dndEnv.c       |  60 +++++++
 source/dnode/mgmt/main/src/dndMsg.c       |  80 ---------
 source/dnode/mgmt/main/src/dndStr.c       |  77 ---------
 source/dnode/mgmt/main/src/dndTransport.c | 199 +++++++++++++---------
 5 files changed, 183 insertions(+), 234 deletions(-)
 delete mode 100644 source/dnode/mgmt/main/src/dndStr.c

diff --git a/source/dnode/mgmt/main/inc/dndInt.h b/source/dnode/mgmt/main/inc/dndInt.h
index 5ef52e3942..9477bd06b9 100644
--- a/source/dnode/mgmt/main/inc/dndInt.h
+++ b/source/dnode/mgmt/main/inc/dndInt.h
@@ -37,7 +37,6 @@ void    dndClose(SDnode *pDnode);
 void    dndHandleEvent(SDnode *pDnode, EDndEvent event);
 
 // dndMsg.c
-void dndProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, SEpSet *pEpSet);
 void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg);
 
 // dndFile.c
diff --git a/source/dnode/mgmt/main/src/dndEnv.c b/source/dnode/mgmt/main/src/dndEnv.c
index 9f75594335..8bdc2867d2 100644
--- a/source/dnode/mgmt/main/src/dndEnv.c
+++ b/source/dnode/mgmt/main/src/dndEnv.c
@@ -57,3 +57,63 @@ void dndCleanup() {
   taosStopCacheRefreshWorker();
   dInfo("dnode env is cleaned up");
 }
+
+const char *dndStatStr(EDndStatus status) {
+  switch (status) {
+    case DND_STAT_INIT:
+      return "init";
+    case DND_STAT_RUNNING:
+      return "running";
+    case DND_STAT_STOPPED:
+      return "stopped";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+const char *dndNodeLogStr(ENodeType ntype) {
+  switch (ntype) {
+    case VNODES:
+      return "vnode";
+    case QNODE:
+      return "qnode";
+    case SNODE:
+      return "snode";
+    case MNODE:
+      return "mnode";
+    case BNODE:
+      return "bnode";
+    default:
+      return "taosd";
+  }
+}
+
+const char *dndNodeProcStr(ENodeType ntype) {
+  switch (ntype) {
+    case VNODES:
+      return "taosv";
+    case QNODE:
+      return "taosq";
+    case SNODE:
+      return "taoss";
+    case MNODE:
+      return "taosm";
+    case BNODE:
+      return "taosb";
+    default:
+      return "taosd";
+  }
+}
+
+const char *dndEventStr(EDndEvent ev) {
+  switch (ev) {
+    case DND_EVENT_START:
+      return "start";
+    case DND_EVENT_STOP:
+      return "stop";
+    case DND_EVENT_CHILD:
+      return "child";
+    default:
+      return "UNKNOWN";
+  }
+}
\ No newline at end of file
diff --git a/source/dnode/mgmt/main/src/dndMsg.c b/source/dnode/mgmt/main/src/dndMsg.c
index 76b66467bf..5d739b7e15 100644
--- a/source/dnode/mgmt/main/src/dndMsg.c
+++ b/source/dnode/mgmt/main/src/dndMsg.c
@@ -16,86 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "dndInt.h"
 
-static void dndUpdateMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, DNODE);
-  if (pWrapper != NULL) {
-    dmUpdateMnodeEpSet(pWrapper->pMgmt, pEpSet);
-    dndReleaseWrapper(pWrapper);
-  }
-}
-
-static inline NodeMsgFp dndGetMsgFp(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
-  if (msgFp == NULL) {
-    terrno = TSDB_CODE_MSG_NOT_PROCESSED;
-  }
-
-  return msgFp;
-}
-
-static inline int32_t dndBuildMsg(SNodeMsg *pMsg, SRpcMsg *pRpc) {
-  SRpcConnInfo connInfo = {0};
-  if ((pRpc->msgType & 1U) && rpcGetConnInfo(pRpc->handle, &connInfo) != 0) {
-    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
-    dError("failed to build msg since %s, app:%p RPC:%p", terrstr(), pRpc->ahandle, pRpc->handle);
-    return -1;
-  }
-
-  memcpy(pMsg->user, connInfo.user, TSDB_USER_LEN);
-  pMsg->clientIp = connInfo.clientIp;
-  pMsg->clientPort = connInfo.clientPort;
-  memcpy(&pMsg->rpcMsg, pRpc, sizeof(SRpcMsg));
-  return 0;
-}
-
-void dndProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSet) {
-  int32_t   code = -1;
-  SNodeMsg *pMsg = NULL;
-  NodeMsgFp msgFp = NULL;
-
-  if (pEpSet && pEpSet->numOfEps > 0 && pRpc->msgType == TDMT_MND_STATUS_RSP) {
-    dndUpdateMnodeEpSet(pWrapper->pDnode, pEpSet);
-  }
-
-  if (dndMarkWrapper(pWrapper) != 0) goto _OVER;
-  if ((msgFp = dndGetMsgFp(pWrapper, pRpc)) == NULL) goto _OVER;
-  if ((pMsg = taosAllocateQitem(sizeof(SNodeMsg))) == NULL) goto _OVER;
-  if (dndBuildMsg(pMsg, pRpc) != 0) goto _OVER;
-
-  if (pWrapper->procType == PROC_SINGLE) {
-    dTrace("msg:%p, is created, handle:%p app:%p user:%s", pMsg, pRpc->handle, pRpc->ahandle, pMsg->user);
-    code = (*msgFp)(pWrapper, pMsg);
-  } else if (pWrapper->procType == PROC_PARENT) {
-    dTrace("msg:%p, is created and put into child queue, handle:%p app:%p user:%s", pMsg, pRpc->handle, pRpc->ahandle,
-           pMsg->user);
-    code = taosProcPutToChildQ(pWrapper->pProc, pMsg, sizeof(SNodeMsg), pRpc->pCont, pRpc->contLen, PROC_REQ);
-  } else {
-    dTrace("msg:%p, should not processed in child process, handle:%p app:%p user:%s", pMsg, pRpc->handle, pRpc->ahandle,
-           pMsg->user);
-    ASSERT(1);
-  }
-
-_OVER:
-  if (code == 0) {
-    if (pWrapper->procType == PROC_PARENT) {
-      dTrace("msg:%p, is freed in parent process", pMsg);
-      taosFreeQitem(pMsg);
-      rpcFreeCont(pRpc->pCont);
-    }
-  } else {
-    dError("msg:%p, failed to process since 0x%04x:%s", pMsg, code & 0XFFFF, terrstr());
-    if (pRpc->msgType & 1U) {
-      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
-      tmsgSendRsp(&rsp);
-    }
-    dTrace("msg:%p, is freed", pMsg);
-    taosFreeQitem(pMsg);
-    rpcFreeCont(pRpc->pCont);
-  }
-
-  dndReleaseWrapper(pWrapper);
-}
-
 static int32_t dndProcessCreateNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
   SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
   if (pWrapper != NULL) {
diff --git a/source/dnode/mgmt/main/src/dndStr.c b/source/dnode/mgmt/main/src/dndStr.c
deleted file mode 100644
index caaa96de59..0000000000
--- a/source/dnode/mgmt/main/src/dndStr.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "dndInt.h"
-
-const char *dndStatStr(EDndStatus status) {
-  switch (status) {
-    case DND_STAT_INIT:
-      return "init";
-    case DND_STAT_RUNNING:
-      return "running";
-    case DND_STAT_STOPPED:
-      return "stopped";
-    default:
-      return "UNKNOWN";
-  }
-}
-
-const char *dndNodeLogStr(ENodeType ntype) {
-  switch (ntype) {
-    case VNODES:
-      return "vnode";
-    case QNODE:
-      return "qnode";
-    case SNODE:
-      return "snode";
-    case MNODE:
-      return "mnode";
-    case BNODE:
-      return "bnode";
-    default:
-      return "taosd";
-  }
-}
-
-const char *dndNodeProcStr(ENodeType ntype) {
-  switch (ntype) {
-    case VNODES:
-      return "taosv";
-    case QNODE:
-      return "taosq";
-    case SNODE:
-      return "taoss";
-    case MNODE:
-      return "taosm";
-    case BNODE:
-      return "taosb";
-    default:
-      return "taosd";
-  }
-}
-
-const char *dndEventStr(EDndEvent ev) {
-  switch (ev) {
-    case DND_EVENT_START:
-      return "start";
-    case DND_EVENT_STOP:
-      return "stop";
-    case DND_EVENT_CHILD:
-      return "child";
-    default:
-      return "UNKNOWN";
-  }
-}
\ No newline at end of file
diff --git a/source/dnode/mgmt/main/src/dndTransport.c b/source/dnode/mgmt/main/src/dndTransport.c
index 2be2da4e46..38bc13fec0 100644
--- a/source/dnode/mgmt/main/src/dndTransport.c
+++ b/source/dnode/mgmt/main/src/dndTransport.c
@@ -20,45 +20,133 @@
 #define INTERNAL_CKEY   "_key"
 #define INTERNAL_SECRET "_pwd"
 
-static inline void dndProcessQMVnodeRpcMsg(SMsgHandle *pHandle, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SMsgHead *pHead = pMsg->pCont;
-  int32_t   vgId = htonl(pHead->vgId);
-
-  SMgmtWrapper *pWrapper = pHandle->pWrapper;
-  if (vgId == QND_VGID) {
-    pWrapper = pHandle->pQndWrapper;
-  } else if (vgId == MND_VGID) {
-    pWrapper = pHandle->pMndWrapper;
-  }
-
-  dTrace("msg:%s will be processed by %s, handle:%p app:%p vgId:%d", TMSG_INFO(pMsg->msgType), pWrapper->name,
-         pMsg->handle, pMsg->ahandle, vgId);
-  dndProcessRpcMsg(pWrapper, pMsg, pEpSet);
+static void dndUpdateMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
+  SMgmtWrapper *pWrapper = &pDnode->wrappers[DNODE];
+  dmUpdateMnodeEpSet(pWrapper->pMgmt, pEpSet);
 }
 
-static void dndProcessResponse(SDnode *pDnode, SRpcMsg *pRsp, SEpSet *pEpSet) {
-  STransMgmt *pMgmt = &pDnode->trans;
-  tmsg_t      msgType = pRsp->msgType;
+static inline NodeMsgFp dndGetMsgFp(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
+  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
+  if (msgFp == NULL) {
+    terrno = TSDB_CODE_MSG_NOT_PROCESSED;
+  }
 
-  if (dndGetStatus(pDnode) != DND_STAT_RUNNING) {
-    dTrace("rsp:%s ignored since dnode not running, handle:%p app:%p", TMSG_INFO(msgType), pRsp->handle, pRsp->ahandle);
-    rpcFreeCont(pRsp->pCont);
+  return msgFp;
+}
+
+static inline int32_t dndBuildMsg(SNodeMsg *pMsg, SRpcMsg *pRpc) {
+  SRpcConnInfo connInfo = {0};
+  if ((pRpc->msgType & 1U) && rpcGetConnInfo(pRpc->handle, &connInfo) != 0) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    dError("failed to build msg since %s, app:%p handle:%p", terrstr(), pRpc->ahandle, pRpc->handle);
+    return -1;
+  }
+
+  memcpy(pMsg->user, connInfo.user, TSDB_USER_LEN);
+  pMsg->clientIp = connInfo.clientIp;
+  pMsg->clientPort = connInfo.clientPort;
+  memcpy(&pMsg->rpcMsg, pRpc, sizeof(SRpcMsg));
+  return 0;
+}
+
+static void dndProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSet) {
+  int32_t   code = -1;
+  SNodeMsg *pMsg = NULL;
+  NodeMsgFp msgFp = NULL;
+
+  if (pEpSet && pEpSet->numOfEps > 0 && pRpc->msgType == TDMT_MND_STATUS_RSP) {
+    dndUpdateMnodeEpSet(pWrapper->pDnode, pEpSet);
+  }
+
+  if (dndMarkWrapper(pWrapper) != 0) goto _OVER;
+  if ((msgFp = dndGetMsgFp(pWrapper, pRpc)) == NULL) goto _OVER;
+  if ((pMsg = taosAllocateQitem(sizeof(SNodeMsg))) == NULL) goto _OVER;
+  if (dndBuildMsg(pMsg, pRpc) != 0) goto _OVER;
+
+  if (pWrapper->procType == PROC_SINGLE) {
+    dTrace("msg:%p, is created, handle:%p user:%s", pMsg, pRpc->handle, pMsg->user);
+    code = (*msgFp)(pWrapper, pMsg);
+  } else if (pWrapper->procType == PROC_PARENT) {
+    dTrace("msg:%p, is created and put into child queue, handle:%p user:%s", pMsg, pRpc->handle, pMsg->user);
+    code = taosProcPutToChildQ(pWrapper->pProc, pMsg, sizeof(SNodeMsg), pRpc->pCont, pRpc->contLen, PROC_REQ);
+  } else {
+    dTrace("msg:%p, should not processed in child process, handle:%p user:%s", pMsg, pRpc->handle, pMsg->user);
+    ASSERT(1);
+  }
+
+_OVER:
+  if (code == 0) {
+    if (pWrapper->procType == PROC_PARENT) {
+      dTrace("msg:%p, is freed in parent process", pMsg);
+      taosFreeQitem(pMsg);
+      rpcFreeCont(pRpc->pCont);
+    }
+  } else {
+    dError("msg:%p, failed to process since 0x%04x:%s", pMsg, code & 0XFFFF, terrstr());
+    if (pRpc->msgType & 1U) {
+      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
+      tmsgSendRsp(&rsp);
+    }
+    dTrace("msg:%p, is freed", pMsg);
+    taosFreeQitem(pMsg);
+    rpcFreeCont(pRpc->pCont);
+  }
+
+  dndReleaseWrapper(pWrapper);
+}
+
+static void dndProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  STransMgmt   *pMgmt = &pDnode->trans;
+  tmsg_t        msgType = pMsg->msgType;
+  bool          isReq = msgType & 1u;
+  SMsgHandle   *pHandle = &pMgmt->msgHandles[TMSG_INDEX(msgType)];
+  SMgmtWrapper *pWrapper = pHandle->pWrapper;
+
+  if (msgType == TDMT_DND_NETWORK_TEST) {
+    dTrace("network test req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
+    dndProcessStartupReq(pDnode, pMsg);
     return;
   }
 
-  SMsgHandle *pHandle = &pMgmt->msgHandles[TMSG_INDEX(msgType)];
-  if (pHandle->pWrapper != NULL) {
-    if (pHandle->pMndWrapper == NULL && pHandle->pQndWrapper == NULL) {
-      dTrace("rsp:%s will be processed by %s, handle:%p app:%p code:0x%04x:%s", TMSG_INFO(msgType),
-             pHandle->pWrapper->name, pRsp->handle, pRsp->ahandle, pRsp->code & 0XFFFF, tstrerror(pRsp->code));
-      dndProcessRpcMsg(pHandle->pWrapper, pRsp, pEpSet);
-    } else {
-      dndProcessQMVnodeRpcMsg(pHandle, pRsp, pEpSet);
+  if (dndGetStatus(pDnode) != DND_STAT_RUNNING) {
+    dError("msg:%s ignored since dnode not running, handle:%p app:%p", TMSG_INFO(msgType), pMsg->handle, pMsg->ahandle);
+    if (isReq) {
+      SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_APP_NOT_READY, .ahandle = pMsg->ahandle};
+      rpcSendResponse(&rspMsg);
     }
-  } else {
-    dError("rsp:%s not processed since no handle, handle:%p app:%p", TMSG_INFO(msgType), pRsp->handle, pRsp->ahandle);
-    rpcFreeCont(pRsp->pCont);
+    rpcFreeCont(pMsg->pCont);
+    return;
   }
+
+  if (isReq && pMsg->pCont == NULL) {
+    dError("req:%s not processed since its empty, handle:%p app:%p", TMSG_INFO(msgType), pMsg->handle, pMsg->ahandle);
+    SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_DND_INVALID_MSG_LEN, .ahandle = pMsg->ahandle};
+    rpcSendResponse(&rspMsg);
+    return;
+  }
+
+  if (pWrapper == NULL) {
+    dError("msg:%s not processed since no handle, handle:%p app:%p", TMSG_INFO(msgType), pMsg->handle, pMsg->ahandle);
+    if (isReq) {
+      SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED, .ahandle = pMsg->ahandle};
+      rpcSendResponse(&rspMsg);
+    }
+    rpcFreeCont(pMsg->pCont);
+  }
+
+  if (pHandle->pMndWrapper != NULL || pHandle->pQndWrapper != NULL) {
+    SMsgHead *pHead = pMsg->pCont;
+    int32_t   vgId = ntohl(pHead->vgId);
+    if (vgId == QND_VGID) {
+      pWrapper = pHandle->pQndWrapper;
+    } else if (vgId == MND_VGID) {
+      pWrapper = pHandle->pMndWrapper;
+    } else {
+    }
+  }
+
+  dTrace("msg:%s will be processed by %s, app:%p", TMSG_INFO(msgType), pWrapper->name, pMsg->ahandle);
+  dndProcessRpcMsg(pWrapper, pMsg, pEpSet);
 }
 
 static int32_t dndInitClient(SDnode *pDnode) {
@@ -68,7 +156,7 @@ static int32_t dndInitClient(SDnode *pDnode) {
   memset(&rpcInit, 0, sizeof(rpcInit));
   rpcInit.label = "DND";
   rpcInit.numOfThreads = 1;
-  rpcInit.cfp = (RpcCfp)dndProcessResponse;
+  rpcInit.cfp = (RpcCfp)dndProcessMsg;
   rpcInit.sessions = 1024;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
@@ -100,48 +188,6 @@ static void dndCleanupClient(SDnode *pDnode) {
   }
 }
 
-static void dndProcessRequest(SDnode *pDnode, SRpcMsg *pReq, SEpSet *pEpSet) {
-  STransMgmt *pMgmt = &pDnode->trans;
-  tmsg_t      msgType = pReq->msgType;
-
-  if (msgType == TDMT_DND_NETWORK_TEST) {
-    dTrace("network test req will be processed, handle:%p, app:%p", pReq->handle, pReq->ahandle);
-    dndProcessStartupReq(pDnode, pReq);
-    return;
-  }
-
-  if (dndGetStatus(pDnode) != DND_STAT_RUNNING) {
-    dError("req:%s ignored since dnode not running, handle:%p app:%p", TMSG_INFO(msgType), pReq->handle, pReq->ahandle);
-    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_APP_NOT_READY, .ahandle = pReq->ahandle};
-    rpcSendResponse(&rspMsg);
-    rpcFreeCont(pReq->pCont);
-    return;
-  }
-
-  if (pReq->pCont == NULL) {
-    dTrace("req:%s not processed since its empty, handle:%p app:%p", TMSG_INFO(msgType), pReq->handle, pReq->ahandle);
-    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_DND_INVALID_MSG_LEN, .ahandle = pReq->ahandle};
-    rpcSendResponse(&rspMsg);
-    return;
-  }
-
-  SMsgHandle *pHandle = &pMgmt->msgHandles[TMSG_INDEX(msgType)];
-  if (pHandle->pWrapper != NULL) {
-    if (pHandle->pMndWrapper == NULL && pHandle->pQndWrapper == NULL) {
-      dTrace("req:%s will be processed by %s, handle:%p app:%p", TMSG_INFO(msgType), pHandle->pWrapper->name,
-             pReq->handle, pReq->ahandle);
-      dndProcessRpcMsg(pHandle->pWrapper, pReq, pEpSet);
-    } else {
-      dndProcessQMVnodeRpcMsg(pHandle, pReq, pEpSet);
-    }
-  } else {
-    dError("req:%s not processed since no handle, handle:%p app:%p", TMSG_INFO(msgType), pReq->handle, pReq->ahandle);
-    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED, .ahandle = pReq->ahandle};
-    rpcSendResponse(&rspMsg);
-    rpcFreeCont(pReq->pCont);
-  }
-}
-
 static inline void dndSendMsgToMnodeRecv(SDnode *pDnode, SRpcMsg *pReq, SRpcMsg *pRsp) {
   SEpSet        epSet = {0};
   SMgmtWrapper *pWrapper = &pDnode->wrappers[DNODE];
@@ -149,7 +195,8 @@ static inline void dndSendMsgToMnodeRecv(SDnode *pDnode, SRpcMsg *pReq, SRpcMsg
   rpcSendRecv(pDnode->trans.clientRpc, &epSet, pReq, pRsp);
 }
 
-static inline int32_t dndGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+static inline int32_t dndGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret,
+                                         char *ckey) {
   int32_t code = 0;
   char    pass[TSDB_PASSWORD_LEN + 1] = {0};
 
@@ -219,7 +266,7 @@ static int32_t dndInitServer(SDnode *pDnode) {
   rpcInit.localPort = pDnode->serverPort;
   rpcInit.label = "DND";
   rpcInit.numOfThreads = numOfThreads;
-  rpcInit.cfp = (RpcCfp)dndProcessRequest;
+  rpcInit.cfp = (RpcCfp)dndProcessMsg;
   rpcInit.sessions = tsMaxShellConns;
   rpcInit.connType = TAOS_CONN_SERVER;
   rpcInit.idleTime = tsShellActivityTimer * 1000;

From b2bf8539527bf4c200faf63ca3bcfdf08f091d7b Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 19:22:59 +0800
Subject: [PATCH 5/9] rename file

---
 source/dnode/mgmt/dm/src/dmMsg.c    | 101 ++++++++++++++++++++++++
 source/dnode/mgmt/main/src/dndMsg.c | 117 ----------------------------
 2 files changed, 101 insertions(+), 117 deletions(-)
 delete mode 100644 source/dnode/mgmt/main/src/dndMsg.c

diff --git a/source/dnode/mgmt/dm/src/dmMsg.c b/source/dnode/mgmt/dm/src/dmMsg.c
index 90117044f9..979db7aac0 100644
--- a/source/dnode/mgmt/dm/src/dmMsg.c
+++ b/source/dnode/mgmt/dm/src/dmMsg.c
@@ -117,6 +117,107 @@ int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return TSDB_CODE_OPS_NOT_SUPPORT;
 }
 
+
+static int32_t dndProcessCreateNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
+  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
+  if (pWrapper != NULL) {
+    dndReleaseWrapper(pWrapper);
+    terrno = TSDB_CODE_NODE_ALREADY_DEPLOYED;
+    dError("failed to create node since %s", terrstr());
+    return -1;
+  }
+
+  pWrapper = &pDnode->wrappers[ntype];
+
+  if (taosMkDir(pWrapper->path) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to create dir:%s since %s", pWrapper->path, terrstr());
+    return -1;
+  }
+
+  int32_t code = (*pWrapper->fp.createMsgFp)(pWrapper, pMsg);
+  if (code != 0) {
+    dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
+  } else {
+    dDebug("node:%s, has been opened", pWrapper->name);
+    pWrapper->deployed = true;
+  }
+
+  return code;
+}
+
+static int32_t dndProcessDropNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
+  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
+  if (pWrapper == NULL) {
+    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
+    dError("failed to drop node since %s", terrstr());
+    return -1;
+  }
+
+  taosWLockLatch(&pWrapper->latch);
+  pWrapper->deployed = false;
+
+  int32_t code = (*pWrapper->fp.dropMsgFp)(pWrapper, pMsg);
+  if (code != 0) {
+    pWrapper->deployed = true;
+    dError("node:%s, failed to drop since %s", pWrapper->name, terrstr());
+  } else {
+    pWrapper->deployed = false;
+    dDebug("node:%s, has been dropped", pWrapper->name);
+  }
+
+  taosWUnLockLatch(&pWrapper->latch);
+  dndReleaseWrapper(pWrapper);
+  return code;
+}
+
+int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg) {
+  switch (pMsg->rpcMsg.msgType) {
+    case TDMT_DND_CREATE_MNODE:
+      return dndProcessCreateNodeMsg(pDnode, MNODE, pMsg);
+    case TDMT_DND_DROP_MNODE:
+      return dndProcessDropNodeMsg(pDnode, MNODE, pMsg);
+    case TDMT_DND_CREATE_QNODE:
+      return dndProcessCreateNodeMsg(pDnode, QNODE, pMsg);
+    case TDMT_DND_DROP_QNODE:
+      return dndProcessDropNodeMsg(pDnode, QNODE, pMsg);
+    case TDMT_DND_CREATE_SNODE:
+      return dndProcessCreateNodeMsg(pDnode, SNODE, pMsg);
+    case TDMT_DND_DROP_SNODE:
+      return dndProcessDropNodeMsg(pDnode, SNODE, pMsg);
+    case TDMT_DND_CREATE_BNODE:
+      return dndProcessCreateNodeMsg(pDnode, BNODE, pMsg);
+    case TDMT_DND_DROP_BNODE:
+      return dndProcessDropNodeMsg(pDnode, BNODE, pMsg);
+    default:
+      terrno = TSDB_CODE_MSG_NOT_PROCESSED;
+      return -1;
+  }
+}
+
+void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
+  SStartupReq *pStartup = &pDnode->startup;
+  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
+  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
+  pStartup->finished = 0;
+}
+
+void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
+  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
+  pStartup->finished = (dndGetStatus(pDnode) == DND_STAT_RUNNING);
+}
+
+void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
+  dDebug("startup req is received");
+  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
+  dndGetStartup(pDnode, pStartup);
+
+  dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
+  SRpcMsg rpcRsp = {
+      .handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq), .ahandle = pReq->ahandle};
+  rpcSendResponse(&rpcRsp);
+}
+
 void dmInitMsgHandles(SMgmtWrapper *pWrapper) {
   // Requests handled by DNODE
   dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE, dmProcessMgmtMsg, VND_VGID);
diff --git a/source/dnode/mgmt/main/src/dndMsg.c b/source/dnode/mgmt/main/src/dndMsg.c
deleted file mode 100644
index 5d739b7e15..0000000000
--- a/source/dnode/mgmt/main/src/dndMsg.c
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "dndInt.h"
-
-static int32_t dndProcessCreateNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
-  if (pWrapper != NULL) {
-    dndReleaseWrapper(pWrapper);
-    terrno = TSDB_CODE_NODE_ALREADY_DEPLOYED;
-    dError("failed to create node since %s", terrstr());
-    return -1;
-  }
-
-  pWrapper = &pDnode->wrappers[ntype];
-
-  if (taosMkDir(pWrapper->path) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to create dir:%s since %s", pWrapper->path, terrstr());
-    return -1;
-  }
-
-  int32_t code = (*pWrapper->fp.createMsgFp)(pWrapper, pMsg);
-  if (code != 0) {
-    dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
-  } else {
-    dDebug("node:%s, has been opened", pWrapper->name);
-    pWrapper->deployed = true;
-  }
-
-  return code;
-}
-
-static int32_t dndProcessDropNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
-  if (pWrapper == NULL) {
-    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
-    dError("failed to drop node since %s", terrstr());
-    return -1;
-  }
-
-  taosWLockLatch(&pWrapper->latch);
-  pWrapper->deployed = false;
-
-  int32_t code = (*pWrapper->fp.dropMsgFp)(pWrapper, pMsg);
-  if (code != 0) {
-    pWrapper->deployed = true;
-    dError("node:%s, failed to drop since %s", pWrapper->name, terrstr());
-  } else {
-    pWrapper->deployed = false;
-    dDebug("node:%s, has been dropped", pWrapper->name);
-  }
-
-  taosWUnLockLatch(&pWrapper->latch);
-  dndReleaseWrapper(pWrapper);
-  return code;
-}
-
-int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg) {
-  switch (pMsg->rpcMsg.msgType) {
-    case TDMT_DND_CREATE_MNODE:
-      return dndProcessCreateNodeMsg(pDnode, MNODE, pMsg);
-    case TDMT_DND_DROP_MNODE:
-      return dndProcessDropNodeMsg(pDnode, MNODE, pMsg);
-    case TDMT_DND_CREATE_QNODE:
-      return dndProcessCreateNodeMsg(pDnode, QNODE, pMsg);
-    case TDMT_DND_DROP_QNODE:
-      return dndProcessDropNodeMsg(pDnode, QNODE, pMsg);
-    case TDMT_DND_CREATE_SNODE:
-      return dndProcessCreateNodeMsg(pDnode, SNODE, pMsg);
-    case TDMT_DND_DROP_SNODE:
-      return dndProcessDropNodeMsg(pDnode, SNODE, pMsg);
-    case TDMT_DND_CREATE_BNODE:
-      return dndProcessCreateNodeMsg(pDnode, BNODE, pMsg);
-    case TDMT_DND_DROP_BNODE:
-      return dndProcessDropNodeMsg(pDnode, BNODE, pMsg);
-    default:
-      terrno = TSDB_CODE_MSG_NOT_PROCESSED;
-      return -1;
-  }
-}
-
-void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
-  SStartupReq *pStartup = &pDnode->startup;
-  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
-  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
-  pStartup->finished = 0;
-}
-
-void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
-  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
-  pStartup->finished = (dndGetStatus(pDnode) == DND_STAT_RUNNING);
-}
-
-void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
-  dDebug("startup req is received");
-  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
-  dndGetStartup(pDnode, pStartup);
-
-  dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
-  SRpcMsg rpcRsp = {
-      .handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq), .ahandle = pReq->ahandle};
-  rpcSendResponse(&rpcRsp);
-}

From a554bd7fe7ceb370a3d9e4deaf6d243434eeb94b Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 19:24:20 +0800
Subject: [PATCH 6/9] rename file

---
 source/dnode/mgmt/bm/src/{bmMsg.c => bmHandle.c} | 0
 source/dnode/mgmt/dm/src/{dmMsg.c => dmHandle.c} | 0
 source/dnode/mgmt/mm/src/{mmMsg.c => mmHandle.c} | 0
 source/dnode/mgmt/qm/src/{qmMsg.c => qmHandle.c} | 0
 source/dnode/mgmt/sm/src/{smMsg.c => smHandle.c} | 0
 source/dnode/mgmt/vm/src/{vmMsg.c => vmHandle.c} | 0
 6 files changed, 0 insertions(+), 0 deletions(-)
 rename source/dnode/mgmt/bm/src/{bmMsg.c => bmHandle.c} (100%)
 rename source/dnode/mgmt/dm/src/{dmMsg.c => dmHandle.c} (100%)
 rename source/dnode/mgmt/mm/src/{mmMsg.c => mmHandle.c} (100%)
 rename source/dnode/mgmt/qm/src/{qmMsg.c => qmHandle.c} (100%)
 rename source/dnode/mgmt/sm/src/{smMsg.c => smHandle.c} (100%)
 rename source/dnode/mgmt/vm/src/{vmMsg.c => vmHandle.c} (100%)

diff --git a/source/dnode/mgmt/bm/src/bmMsg.c b/source/dnode/mgmt/bm/src/bmHandle.c
similarity index 100%
rename from source/dnode/mgmt/bm/src/bmMsg.c
rename to source/dnode/mgmt/bm/src/bmHandle.c
diff --git a/source/dnode/mgmt/dm/src/dmMsg.c b/source/dnode/mgmt/dm/src/dmHandle.c
similarity index 100%
rename from source/dnode/mgmt/dm/src/dmMsg.c
rename to source/dnode/mgmt/dm/src/dmHandle.c
diff --git a/source/dnode/mgmt/mm/src/mmMsg.c b/source/dnode/mgmt/mm/src/mmHandle.c
similarity index 100%
rename from source/dnode/mgmt/mm/src/mmMsg.c
rename to source/dnode/mgmt/mm/src/mmHandle.c
diff --git a/source/dnode/mgmt/qm/src/qmMsg.c b/source/dnode/mgmt/qm/src/qmHandle.c
similarity index 100%
rename from source/dnode/mgmt/qm/src/qmMsg.c
rename to source/dnode/mgmt/qm/src/qmHandle.c
diff --git a/source/dnode/mgmt/sm/src/smMsg.c b/source/dnode/mgmt/sm/src/smHandle.c
similarity index 100%
rename from source/dnode/mgmt/sm/src/smMsg.c
rename to source/dnode/mgmt/sm/src/smHandle.c
diff --git a/source/dnode/mgmt/vm/src/vmMsg.c b/source/dnode/mgmt/vm/src/vmHandle.c
similarity index 100%
rename from source/dnode/mgmt/vm/src/vmMsg.c
rename to source/dnode/mgmt/vm/src/vmHandle.c

From 7e361ebcd09a9064fed94b65a3bfdff34f30bf8f Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 19:52:04 +0800
Subject: [PATCH 7/9] refact dm

---
 include/util/tdef.h                        |   6 +-
 source/dnode/mgmt/dm/inc/dmInt.h           |   7 +-
 source/dnode/mgmt/dm/src/dmHandle.c        |  37 ++---
 source/dnode/mgmt/dm/src/dmInt.c           |   2 +-
 source/dnode/mgmt/dm/src/dmWorker.c        |  53 +++----
 source/dnode/mgmt/main/src/dndInt.c        |   7 +
 source/dnode/mgmt/main/src/dndTransport.c  |   8 +-
 source/dnode/mgmt/mm/src/mmHandle.c        | 162 ++++++++++-----------
 source/dnode/mgmt/qm/src/qmHandle.c        |  18 +--
 source/dnode/mgmt/sm/src/smHandle.c        |   4 +-
 source/dnode/mgmt/vm/src/vmHandle.c        |  88 +++++------
 source/dnode/mnode/impl/src/mndQuery.c     |   2 +-
 source/libs/planner/src/planPhysiCreater.c |   2 +-
 13 files changed, 200 insertions(+), 196 deletions(-)

diff --git a/include/util/tdef.h b/include/util/tdef.h
index be88afcf66..f1af9eca1f 100644
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@@ -480,9 +480,9 @@ enum {
   SND_WORKER_TYPE__UNIQUE,
 };
 
-#define MND_VGID -1
-#define QND_VGID 1
-#define VND_VGID 0
+#define MNODE_HANDLE -1
+#define QNODE_HANDLE 1
+#define DEFAULT_HANDLE 0
 
 #define MAX_NUM_STR_SIZE 40
 
diff --git a/source/dnode/mgmt/dm/inc/dmInt.h b/source/dnode/mgmt/dm/inc/dmInt.h
index a8f46ef7e2..98abb8ef54 100644
--- a/source/dnode/mgmt/dm/inc/dmInt.h
+++ b/source/dnode/mgmt/dm/inc/dmInt.h
@@ -45,7 +45,7 @@ int32_t dmWriteFile(SDnodeMgmt *pMgmt);
 void    dmUpdateDnodeEps(SDnodeMgmt *pMgmt, SArray *pDnodeEps);
 
 // dmMsg.c
-void    dmInitMsgHandles(SMgmtWrapper *pWrapper);
+void    dmInitMsgHandle(SMgmtWrapper *pWrapper);
 void    dmSendStatusReq(SDnodeMgmt *pMgmt);
 int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t dmProcessStatusRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
@@ -53,10 +53,11 @@ int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 
 // dmWorker.c
+int32_t dmStartThread(SDnodeMgmt *pMgmt);
 int32_t dmStartWorker(SDnodeMgmt *pMgmt);
 void    dmStopWorker(SDnodeMgmt *pMgmt);
-int32_t dmStartThread(SDnodeMgmt *pMgmt);
-int32_t dmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+int32_t dmPutMsgToMgmtWorker(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+int32_t dmPutMsgToStatusWorker(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/mgmt/dm/src/dmHandle.c b/source/dnode/mgmt/dm/src/dmHandle.c
index 979db7aac0..07eca3f230 100644
--- a/source/dnode/mgmt/dm/src/dmHandle.c
+++ b/source/dnode/mgmt/dm/src/dmHandle.c
@@ -195,14 +195,7 @@ int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg) {
   }
 }
 
-void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
-  SStartupReq *pStartup = &pDnode->startup;
-  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
-  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
-  pStartup->finished = 0;
-}
-
-void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
+static void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
   memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
   pStartup->finished = (dndGetStatus(pDnode) == DND_STAT_RUNNING);
 }
@@ -218,21 +211,21 @@ void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
   rpcSendResponse(&rpcRsp);
 }
 
-void dmInitMsgHandles(SMgmtWrapper *pWrapper) {
+void dmInitMsgHandle(SMgmtWrapper *pWrapper) {
   // Requests handled by DNODE
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_NETWORK_TEST, dmProcessMgmtMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_NETWORK_TEST, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
 
   // Requests handled by MNODE
-  dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, dmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_AUTH_RSP, dmProcessMgmtMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, dmPutMsgToStatusWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_AUTH_RSP, dmPutMsgToMgmtWorker, DEFAULT_HANDLE);
 }
diff --git a/source/dnode/mgmt/dm/src/dmInt.c b/source/dnode/mgmt/dm/src/dmInt.c
index 8c46c402ab..1e38b8304d 100644
--- a/source/dnode/mgmt/dm/src/dmInt.c
+++ b/source/dnode/mgmt/dm/src/dmInt.c
@@ -165,7 +165,7 @@ void dmGetMgmtFp(SMgmtWrapper *pWrapper) {
   mgmtFp.startFp = dmStart;
   mgmtFp.requiredFp = dmRequire;
 
-  dmInitMsgHandles(pWrapper);
+  dmInitMsgHandle(pWrapper);
   pWrapper->name = "dnode";
   pWrapper->fp = mgmtFp;
 }
diff --git a/source/dnode/mgmt/dm/src/dmWorker.c b/source/dnode/mgmt/dm/src/dmWorker.c
index 9045a44232..6061189ca1 100644
--- a/source/dnode/mgmt/dm/src/dmWorker.c
+++ b/source/dnode/mgmt/dm/src/dmWorker.c
@@ -18,7 +18,7 @@
 
 static void *dmThreadRoutine(void *param) {
   SDnodeMgmt *pMgmt = param;
-  SDnode *    pDnode = pMgmt->pDnode;
+  SDnode     *pDnode = pMgmt->pDnode;
   int64_t     lastStatusTime = taosGetTimestampMs();
   int64_t     lastMonitorTime = lastStatusTime;
 
@@ -32,8 +32,7 @@ static void *dmThreadRoutine(void *param) {
     }
 
     int64_t curTime = taosGetTimestampMs();
-
-    float statusInterval = (curTime - lastStatusTime) / 1000.0f;
+    float   statusInterval = (curTime - lastStatusTime) / 1000.0f;
     if (statusInterval >= tsStatusInterval && !pMgmt->statusSent) {
       dmSendStatusReq(pMgmt);
       lastStatusTime = curTime;
@@ -47,10 +46,21 @@ static void *dmThreadRoutine(void *param) {
   }
 }
 
+int32_t dmStartThread(SDnodeMgmt *pMgmt) {
+  pMgmt->threadId = taosCreateThread(dmThreadRoutine, pMgmt);
+  if (pMgmt->threadId == NULL) {
+    dError("failed to init dnode thread");
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  return 0;
+}
+
 static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   SDnodeMgmt *pMgmt = pInfo->ahandle;
 
-  SDnode * pDnode = pMgmt->pDnode;
+  SDnode  *pDnode = pMgmt->pDnode;
   SRpcMsg *pRpc = &pMsg->rpcMsg;
   int32_t  code = -1;
   dTrace("msg:%p, will be processed in dnode queue", pMsg);
@@ -95,16 +105,14 @@ static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
 }
 
 int32_t dmStartWorker(SDnodeMgmt *pMgmt) {
-  SSingleWorkerCfg mgmtCfg = {
-      .min = 1, .max = 1, .name = "dnode-mgmt", .fp = (FItem)dmProcessQueue, .param = pMgmt};
-  if (tSingleWorkerInit(&pMgmt->mgmtWorker, &mgmtCfg) != 0) {
+  SSingleWorkerCfg mcfg = {.min = 1, .max = 1, .name = "dnode-mgmt", .fp = (FItem)dmProcessQueue, .param = pMgmt};
+  if (tSingleWorkerInit(&pMgmt->mgmtWorker, &mcfg) != 0) {
     dError("failed to start dnode mgmt worker since %s", terrstr());
     return -1;
   }
 
-  SSingleWorkerCfg statusCfg = {
-      .min = 1, .max = 1, .name = "dnode-status", .fp = (FItem)dmProcessQueue, .param = pMgmt};
-  if (tSingleWorkerInit(&pMgmt->statusWorker, &statusCfg) != 0) {
+  SSingleWorkerCfg scfg = {.min = 1, .max = 1, .name = "dnode-status", .fp = (FItem)dmProcessQueue, .param = pMgmt};
+  if (tSingleWorkerInit(&pMgmt->statusWorker, &scfg) != 0) {
     dError("failed to start dnode status worker since %s", terrstr());
     return -1;
   }
@@ -113,17 +121,6 @@ int32_t dmStartWorker(SDnodeMgmt *pMgmt) {
   return 0;
 }
 
-int32_t dmStartThread(SDnodeMgmt *pMgmt) {
-  pMgmt->threadId = taosCreateThread(dmThreadRoutine, pMgmt);
-  if (pMgmt->threadId == NULL) {
-    dError("failed to init dnode thread");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  return 0;
-}
-
 void dmStopWorker(SDnodeMgmt *pMgmt) {
   tSingleWorkerCleanup(&pMgmt->mgmtWorker);
   tSingleWorkerCleanup(&pMgmt->statusWorker);
@@ -135,12 +132,18 @@ void dmStopWorker(SDnodeMgmt *pMgmt) {
   dDebug("dnode workers are closed");
 }
 
-int32_t dmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
+int32_t dmPutMsgToMgmtWorker(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   SDnodeMgmt    *pMgmt = pWrapper->pMgmt;
   SSingleWorker *pWorker = &pMgmt->mgmtWorker;
-  if (pMsg->rpcMsg.msgType == TDMT_MND_STATUS_RSP) {
-    pWorker = &pMgmt->statusWorker;
-  }
+
+  dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
+  taosWriteQitem(pWorker->queue, pMsg);
+  return 0;
+}
+
+int32_t dmPutMsgToStatusWorker(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
+  SDnodeMgmt    *pMgmt = pWrapper->pMgmt;
+  SSingleWorker *pWorker = &pMgmt->statusWorker;
 
   dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
   taosWriteQitem(pWorker->queue, pMsg);
diff --git a/source/dnode/mgmt/main/src/dndInt.c b/source/dnode/mgmt/main/src/dndInt.c
index 5e4b0a1f7b..72feed7c62 100644
--- a/source/dnode/mgmt/main/src/dndInt.c
+++ b/source/dnode/mgmt/main/src/dndInt.c
@@ -204,3 +204,10 @@ void dndSetStatus(SDnode *pDnode, EDndStatus status) {
     pDnode->status = status;
   }
 }
+
+void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
+  SStartupReq *pStartup = &pDnode->startup;
+  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
+  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
+  pStartup->finished = 0;
+}
diff --git a/source/dnode/mgmt/main/src/dndTransport.c b/source/dnode/mgmt/main/src/dndTransport.c
index 38bc13fec0..babc6d1209 100644
--- a/source/dnode/mgmt/main/src/dndTransport.c
+++ b/source/dnode/mgmt/main/src/dndTransport.c
@@ -137,9 +137,9 @@ static void dndProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   if (pHandle->pMndWrapper != NULL || pHandle->pQndWrapper != NULL) {
     SMsgHead *pHead = pMsg->pCont;
     int32_t   vgId = ntohl(pHead->vgId);
-    if (vgId == QND_VGID) {
+    if (vgId == QNODE_HANDLE) {
       pWrapper = pHandle->pQndWrapper;
-    } else if (vgId == MND_VGID) {
+    } else if (vgId == MNODE_HANDLE) {
       pWrapper = pHandle->pMndWrapper;
     } else {
     }
@@ -315,13 +315,13 @@ int32_t dndInitMsgHandle(SDnode *pDnode) {
       if (msgFp == NULL) continue;
 
       SMsgHandle *pHandle = &pMgmt->msgHandles[msgIndex];
-      if (vgId == QND_VGID) {
+      if (vgId == QNODE_HANDLE) {
         if (pHandle->pQndWrapper != NULL) {
           dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
           return -1;
         }
         pHandle->pQndWrapper = pWrapper;
-      } else if (vgId == MND_VGID) {
+      } else if (vgId == MNODE_HANDLE) {
         if (pHandle->pMndWrapper != NULL) {
           dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
           return -1;
diff --git a/source/dnode/mgmt/mm/src/mmHandle.c b/source/dnode/mgmt/mm/src/mmHandle.c
index 6afcd249b3..666f9daa91 100644
--- a/source/dnode/mgmt/mm/src/mmHandle.c
+++ b/source/dnode/mgmt/mm/src/mmHandle.c
@@ -75,91 +75,91 @@ int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
 
 void mmInitMsgHandles(SMgmtWrapper *pWrapper) {
   // Requests handled by DNODE
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_MNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_VNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_SYNC_VNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_COMPACT_VNODE_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE_RSP, mmProcessWriteMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_MNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_SYNC_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_COMPACT_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
 
   // Requests handled by MNODE
-  dndSetMsgHandle(pWrapper, TDMT_MND_CONNECT, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_ACCT, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_ACCT, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_ACCT, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_USER, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_USER, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_USER, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_GET_USER_AUTH, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_DNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CONFIG_DNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_DNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_MNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_MNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_QNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_QNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_SNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_SNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_BNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_BNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_DB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_DB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_USE_DB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_DB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_SYNC_DB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_COMPACT_DB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_FUNC, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_RETRIEVE_FUNC, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_FUNC, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_STB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_STB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_STB, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_SMA, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_SMA, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_TABLE_META, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_VGROUP_LIST, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_KILL_QUERY, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_KILL_CONN, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_HEARTBEAT, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_SHOW, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_SHOW_RETRIEVE, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_SYSTABLE_RETRIEVE, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_STATUS, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_KILL_TRANS, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_GRANT, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_AUTH, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_MNODE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_TOPIC, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_TOPIC, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_TOPIC, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_SUBSCRIBE, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_MQ_COMMIT_OFFSET, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_GET_SUB_EP, mmProcessReadMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_STREAM, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY_RSP, mmProcessWriteMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CONNECT, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_ACCT, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_ACCT, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_ACCT, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_USER, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_USER, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_USER, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_GET_USER_AUTH, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_DNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CONFIG_DNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_DNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_MNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_MNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_QNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_QNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_SNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_SNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_BNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_BNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_USE_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_SYNC_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_COMPACT_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_RETRIEVE_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_STB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_STB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_STB, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_SMA, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_SMA, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_TABLE_META, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_VGROUP_LIST, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_KILL_QUERY, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_KILL_CONN, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_HEARTBEAT, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_SHOW, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_SHOW_RETRIEVE, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_SYSTABLE_RETRIEVE, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_STATUS, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_KILL_TRANS, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_GRANT, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_AUTH, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_MNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_TOPIC, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_ALTER_TOPIC, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_DROP_TOPIC, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_SUBSCRIBE, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_MQ_COMMIT_OFFSET, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_GET_SUB_EP, mmProcessReadMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_MND_CREATE_STREAM, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
 
   // Requests handled by VNODE
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_REB_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_STB_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA_RSP, mmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA_RSP, mmProcessWriteMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_REB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_STB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
 
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, mmProcessQueryMsg, MND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, mmProcessQueryMsg, MND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, mmProcessQueryMsg, MND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, mmProcessQueryMsg, MND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, mmProcessQueryMsg, MND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, mmProcessQueryMsg, MNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, mmProcessQueryMsg, MNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, mmProcessQueryMsg, MNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, mmProcessQueryMsg, MNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, mmProcessQueryMsg, MNODE_HANDLE);
 
 }
diff --git a/source/dnode/mgmt/qm/src/qmHandle.c b/source/dnode/mgmt/qm/src/qmHandle.c
index da5ba6472a..14ac08af05 100644
--- a/source/dnode/mgmt/qm/src/qmHandle.c
+++ b/source/dnode/mgmt/qm/src/qmHandle.c
@@ -56,14 +56,14 @@ int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
 
 void qmInitMsgHandles(SMgmtWrapper *pWrapper) {
   // Requests handled by VNODE
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, qmProcessQueryMsg, QND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, qmProcessQueryMsg, QND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, qmProcessFetchMsg, QND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, qmProcessFetchMsg, QND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, qmProcessQueryMsg, QNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, qmProcessQueryMsg, QNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, qmProcessFetchMsg, QNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, qmProcessFetchMsg, QNODE_HANDLE);
 
-  dndSetMsgHandle(pWrapper, TDMT_VND_RES_READY, qmProcessFetchMsg, QND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, qmProcessFetchMsg, QND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, qmProcessFetchMsg, QND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, qmProcessFetchMsg, QND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_SHOW_TABLES, qmProcessFetchMsg, QND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_RES_READY, qmProcessFetchMsg, QNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, qmProcessFetchMsg, QNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, qmProcessFetchMsg, QNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, qmProcessFetchMsg, QNODE_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_SHOW_TABLES, qmProcessFetchMsg, QNODE_HANDLE);
 }
diff --git a/source/dnode/mgmt/sm/src/smHandle.c b/source/dnode/mgmt/sm/src/smHandle.c
index c522ef7fc3..dc5ee1155a 100644
--- a/source/dnode/mgmt/sm/src/smHandle.c
+++ b/source/dnode/mgmt/sm/src/smHandle.c
@@ -56,6 +56,6 @@ int32_t smProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
 
 void smInitMsgHandles(SMgmtWrapper *pWrapper) {
   // Requests handled by SNODE
-  dndSetMsgHandle(pWrapper, TDMT_SND_TASK_DEPLOY, smProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_SND_TASK_EXEC, smProcessExecMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_SND_TASK_DEPLOY, smProcessMgmtMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_SND_TASK_EXEC, smProcessExecMsg, DEFAULT_HANDLE);
 }
diff --git a/source/dnode/mgmt/vm/src/vmHandle.c b/source/dnode/mgmt/vm/src/vmHandle.c
index c3ad74d246..6a51c9a77f 100644
--- a/source/dnode/mgmt/vm/src/vmHandle.c
+++ b/source/dnode/mgmt/vm/src/vmHandle.c
@@ -235,49 +235,49 @@ int32_t vmProcessCompactVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
 
 void vmInitMsgHandles(SMgmtWrapper *pWrapper) {
   // Requests handled by VNODE
-  dndSetMsgHandle(pWrapper, TDMT_VND_SUBMIT, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, (NodeMsgFp)vmProcessQueryMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, (NodeMsgFp)vmProcessQueryMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_UPDATE_TAG_VAL, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TABLE_META, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TABLES_META, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_CONSUME, (NodeMsgFp)vmProcessQueryMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_QUERY, (NodeMsgFp)vmProcessQueryMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_CONNECT, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_DISCONNECT, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_RES_READY, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_STB, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_TABLE, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TABLE, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CANCEL_SMA, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_SHOW_TABLES, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_SHOW_TABLES_FETCH, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_REB, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CONSUME, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_PIPE_EXEC, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_MERGE_EXEC, (NodeMsgFp)vmProcessMergeMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_WRITE_EXEC, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_STREAM_TRIGGER, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_SUBMIT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_UPDATE_TAG_VAL, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TABLE_META, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TABLES_META, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_CONSUME, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_QUERY, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_CONNECT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_DISCONNECT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_RES_READY, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CANCEL_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_SHOW_TABLES, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_SHOW_TABLES_FETCH, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_REB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_CONSUME, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_PIPE_EXEC, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_MERGE_EXEC, (NodeMsgFp)vmProcessMergeMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_WRITE_EXEC, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_VND_STREAM_TRIGGER, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
 
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE, vmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_VNODE, vmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE, vmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_SYNC_VNODE, vmProcessMgmtMsg, VND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_DND_COMPACT_VNODE, vmProcessMgmtMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_ALTER_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_SYNC_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
+  dndSetMsgHandle(pWrapper, TDMT_DND_COMPACT_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
 }
diff --git a/source/dnode/mnode/impl/src/mndQuery.c b/source/dnode/mnode/impl/src/mndQuery.c
index 40b4f60bd4..d184e354c4 100644
--- a/source/dnode/mnode/impl/src/mndQuery.c
+++ b/source/dnode/mnode/impl/src/mndQuery.c
@@ -52,7 +52,7 @@ int32_t mndProcessFetchMsg(SNodeMsg *pReq) {
 }
 
 int32_t mndInitQuery(SMnode *pMnode) {
-  if (qWorkerInit(NODE_TYPE_MNODE, MND_VGID, NULL, (void **)&pMnode->pQuery, &pMnode->msgCb) != 0) {
+  if (qWorkerInit(NODE_TYPE_MNODE, MNODE_HANDLE, NULL, (void **)&pMnode->pQuery, &pMnode->msgCb) != 0) {
     mError("failed to init qworker in mnode since %s", terrstr());
     return -1;
   }
diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c
index 11baeff04a..5e466c8cda 100644
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
@@ -419,7 +419,7 @@ static int32_t createSystemTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan*
     vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode);
     taosArrayPush(pCxt->pExecNodeList, &pSubplan->execNode);
   } else {
-    SQueryNodeAddr addr = { .nodeId = MND_VGID, .epSet = pCxt->pPlanCxt->mgmtEpSet };
+    SQueryNodeAddr addr = { .nodeId = MNODE_HANDLE, .epSet = pCxt->pPlanCxt->mgmtEpSet };
     taosArrayPush(pCxt->pExecNodeList, &addr);
   }
   pScan->mgmtEpSet = pCxt->pPlanCxt->mgmtEpSet;

From e00f74ccbc3f7f1b33e91c5a0ace429120d7b1b4 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 20:05:42 +0800
Subject: [PATCH 8/9] refact dm

---
 source/dnode/mgmt/bm/src/bmInt.c    |  2 +-
 source/dnode/mgmt/dm/inc/dmInt.h    |  9 +++-
 source/dnode/mgmt/dm/src/dmHandle.c | 22 +++++-----
 source/dnode/mgmt/dm/src/dmInt.c    |  8 ++--
 source/dnode/mgmt/dm/src/dmWorker.c | 14 +-----
 source/dnode/mgmt/main/inc/dnd.h    | 67 ++++++++++++++++++++---------
 source/dnode/mgmt/main/src/dndInt.c | 12 +++---
 source/dnode/mgmt/mm/src/mmInt.c    |  2 +-
 source/dnode/mgmt/qm/src/qmInt.c    |  2 +-
 source/dnode/mgmt/sm/src/smInt.c    |  2 +-
 source/dnode/mgmt/vm/src/vmInt.c    |  2 +-
 11 files changed, 83 insertions(+), 59 deletions(-)

diff --git a/source/dnode/mgmt/bm/src/bmInt.c b/source/dnode/mgmt/bm/src/bmInt.c
index 4ca7afbb6d..2cb0f50dfe 100644
--- a/source/dnode/mgmt/bm/src/bmInt.c
+++ b/source/dnode/mgmt/bm/src/bmInt.c
@@ -109,7 +109,7 @@ int32_t bmOpen(SMgmtWrapper *pWrapper) {
   return code;
 }
 
-void bmGetMgmtFp(SMgmtWrapper *pWrapper) {
+void bmSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = bmOpen;
   mgmtFp.closeFp = bmClose;
diff --git a/source/dnode/mgmt/dm/inc/dmInt.h b/source/dnode/mgmt/dm/inc/dmInt.h
index 98abb8ef54..e68f7ddb65 100644
--- a/source/dnode/mgmt/dm/inc/dmInt.h
+++ b/source/dnode/mgmt/dm/inc/dmInt.h
@@ -39,18 +39,25 @@ typedef struct SDnodeMgmt {
   SMgmtWrapper *pWrapper;
 } SDnodeMgmt;
 
+// dmInt.c
+void dmSetMgmtFp(SMgmtWrapper *pWrapper);
+void dmGetMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
+void dmUpdateMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
+void dmSendRedirectRsp(SDnodeMgmt *pMgmt, const SRpcMsg *pMsg);
+
 // dmFile.c
 int32_t dmReadFile(SDnodeMgmt *pMgmt);
 int32_t dmWriteFile(SDnodeMgmt *pMgmt);
 void    dmUpdateDnodeEps(SDnodeMgmt *pMgmt, SArray *pDnodeEps);
 
-// dmMsg.c
+// dmHandle.c
 void    dmInitMsgHandle(SMgmtWrapper *pWrapper);
 void    dmSendStatusReq(SDnodeMgmt *pMgmt);
 int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t dmProcessStatusRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessCDnodeMsg(SDnode *pDnode, SNodeMsg *pMsg);
 
 // dmWorker.c
 int32_t dmStartThread(SDnodeMgmt *pMgmt);
diff --git a/source/dnode/mgmt/dm/src/dmHandle.c b/source/dnode/mgmt/dm/src/dmHandle.c
index 07eca3f230..6492995c5c 100644
--- a/source/dnode/mgmt/dm/src/dmHandle.c
+++ b/source/dnode/mgmt/dm/src/dmHandle.c
@@ -118,7 +118,7 @@ int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
 }
 
 
-static int32_t dndProcessCreateNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
+static int32_t dmProcessCreateNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
   SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
   if (pWrapper != NULL) {
     dndReleaseWrapper(pWrapper);
@@ -146,7 +146,7 @@ static int32_t dndProcessCreateNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg
   return code;
 }
 
-static int32_t dndProcessDropNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
+static int32_t dmProcessDropNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *pMsg) {
   SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
   if (pWrapper == NULL) {
     terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
@@ -171,24 +171,24 @@ static int32_t dndProcessDropNodeMsg(SDnode *pDnode, ENodeType ntype, SNodeMsg *
   return code;
 }
 
-int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg) {
+int32_t dmProcessCDnodeMsg(SDnode *pDnode, SNodeMsg *pMsg) {
   switch (pMsg->rpcMsg.msgType) {
     case TDMT_DND_CREATE_MNODE:
-      return dndProcessCreateNodeMsg(pDnode, MNODE, pMsg);
+      return dmProcessCreateNodeMsg(pDnode, MNODE, pMsg);
     case TDMT_DND_DROP_MNODE:
-      return dndProcessDropNodeMsg(pDnode, MNODE, pMsg);
+      return dmProcessDropNodeMsg(pDnode, MNODE, pMsg);
     case TDMT_DND_CREATE_QNODE:
-      return dndProcessCreateNodeMsg(pDnode, QNODE, pMsg);
+      return dmProcessCreateNodeMsg(pDnode, QNODE, pMsg);
     case TDMT_DND_DROP_QNODE:
-      return dndProcessDropNodeMsg(pDnode, QNODE, pMsg);
+      return dmProcessDropNodeMsg(pDnode, QNODE, pMsg);
     case TDMT_DND_CREATE_SNODE:
-      return dndProcessCreateNodeMsg(pDnode, SNODE, pMsg);
+      return dmProcessCreateNodeMsg(pDnode, SNODE, pMsg);
     case TDMT_DND_DROP_SNODE:
-      return dndProcessDropNodeMsg(pDnode, SNODE, pMsg);
+      return dmProcessDropNodeMsg(pDnode, SNODE, pMsg);
     case TDMT_DND_CREATE_BNODE:
-      return dndProcessCreateNodeMsg(pDnode, BNODE, pMsg);
+      return dmProcessCreateNodeMsg(pDnode, BNODE, pMsg);
     case TDMT_DND_DROP_BNODE:
-      return dndProcessDropNodeMsg(pDnode, BNODE, pMsg);
+      return dmProcessDropNodeMsg(pDnode, BNODE, pMsg);
     default:
       terrno = TSDB_CODE_MSG_NOT_PROCESSED;
       return -1;
diff --git a/source/dnode/mgmt/dm/src/dmInt.c b/source/dnode/mgmt/dm/src/dmInt.c
index 1e38b8304d..c710af9006 100644
--- a/source/dnode/mgmt/dm/src/dmInt.c
+++ b/source/dnode/mgmt/dm/src/dmInt.c
@@ -78,7 +78,7 @@ static int32_t dmStart(SMgmtWrapper *pWrapper) {
   return dmStartThread(pWrapper->pMgmt);
 }
 
-int32_t dmInit(SMgmtWrapper *pWrapper) {
+static int32_t dmInit(SMgmtWrapper *pWrapper) {
   SDnode     *pDnode = pWrapper->pDnode;
   SDnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SDnodeMgmt));
   dInfo("dnode-mgmt start to init");
@@ -124,7 +124,7 @@ int32_t dmInit(SMgmtWrapper *pWrapper) {
   return 0;
 }
 
-void dmCleanup(SMgmtWrapper *pWrapper) {
+static void dmCleanup(SMgmtWrapper *pWrapper) {
   SDnodeMgmt *pMgmt = pWrapper->pMgmt;
   if (pMgmt == NULL) return;
 
@@ -153,12 +153,12 @@ void dmCleanup(SMgmtWrapper *pWrapper) {
   dInfo("dnode-mgmt is cleaned up");
 }
 
-int32_t dmRequire(SMgmtWrapper *pWrapper, bool *required) {
+static int32_t dmRequire(SMgmtWrapper *pWrapper, bool *required) {
   *required = true;
   return 0;
 }
 
-void dmGetMgmtFp(SMgmtWrapper *pWrapper) {
+void dmSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = dmInit;
   mgmtFp.closeFp = dmCleanup;
diff --git a/source/dnode/mgmt/dm/src/dmWorker.c b/source/dnode/mgmt/dm/src/dmWorker.c
index 6061189ca1..40ca858183 100644
--- a/source/dnode/mgmt/dm/src/dmWorker.c
+++ b/source/dnode/mgmt/dm/src/dmWorker.c
@@ -66,16 +66,6 @@ static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   dTrace("msg:%p, will be processed in dnode queue", pMsg);
 
   switch (pRpc->msgType) {
-    case TDMT_DND_CREATE_MNODE:
-    case TDMT_DND_CREATE_QNODE:
-    case TDMT_DND_CREATE_SNODE:
-    case TDMT_DND_CREATE_BNODE:
-    case TDMT_DND_DROP_MNODE:
-    case TDMT_DND_DROP_QNODE:
-    case TDMT_DND_DROP_SNODE:
-    case TDMT_DND_DROP_BNODE:
-      code = dndProcessNodeMsg(pMgmt->pDnode, pMsg);
-      break;
     case TDMT_DND_CONFIG_DNODE:
       code = dmProcessConfigReq(pMgmt, pMsg);
       break;
@@ -89,8 +79,8 @@ static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
       code = dmProcessGrantRsp(pMgmt, pMsg);
       break;
     default:
-      terrno = TSDB_CODE_MSG_NOT_PROCESSED;
-      dError("msg:%p, type:%s not processed in dnode queue", pRpc->handle, TMSG_INFO(pRpc->msgType));
+      code = dmProcessCDnodeMsg(pMgmt->pDnode, pMsg);
+      break;
   }
 
   if (pRpc->msgType & 1u) {
diff --git a/source/dnode/mgmt/main/inc/dnd.h b/source/dnode/mgmt/main/inc/dnd.h
index b324a279bc..449c4399db 100644
--- a/source/dnode/mgmt/main/inc/dnd.h
+++ b/source/dnode/mgmt/main/inc/dnd.h
@@ -27,13 +27,13 @@
 #include "tlockfree.h"
 #include "tlog.h"
 #include "tmsg.h"
+#include "tmsgcb.h"
 #include "tprocess.h"
 #include "tqueue.h"
 #include "trpc.h"
 #include "tthread.h"
 #include "ttime.h"
 #include "tworker.h"
-#include "tmsgcb.h"
 
 #include "dnode.h"
 #include "monitor.h"
@@ -42,12 +42,42 @@
 extern "C" {
 #endif
 
-#define dFatal(...) { if (dDebugFlag & DEBUG_FATAL) { taosPrintLog("DND FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }}
-#define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("DND ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }}
-#define dWarn(...)  { if (dDebugFlag & DEBUG_WARN)  { taosPrintLog("DND WARN ", DEBUG_WARN, 255, __VA_ARGS__); }}
-#define dInfo(...)  { if (dDebugFlag & DEBUG_INFO)  { taosPrintLog("DND ", DEBUG_INFO, 255, __VA_ARGS__); }}
-#define dDebug(...) { if (dDebugFlag & DEBUG_DEBUG) { taosPrintLog("DND ", DEBUG_DEBUG, dDebugFlag, __VA_ARGS__); }}
-#define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", DEBUG_TRACE, dDebugFlag, __VA_ARGS__); }}
+#define dFatal(...)                                              \
+  {                                                              \
+    if (dDebugFlag & DEBUG_FATAL) {                              \
+      taosPrintLog("DND FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); \
+    }                                                            \
+  }
+#define dError(...)                                              \
+  {                                                              \
+    if (dDebugFlag & DEBUG_ERROR) {                              \
+      taosPrintLog("DND ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); \
+    }                                                            \
+  }
+#define dWarn(...)                                             \
+  {                                                            \
+    if (dDebugFlag & DEBUG_WARN) {                             \
+      taosPrintLog("DND WARN ", DEBUG_WARN, 255, __VA_ARGS__); \
+    }                                                          \
+  }
+#define dInfo(...)                                        \
+  {                                                       \
+    if (dDebugFlag & DEBUG_INFO) {                        \
+      taosPrintLog("DND ", DEBUG_INFO, 255, __VA_ARGS__); \
+    }                                                     \
+  }
+#define dDebug(...)                                               \
+  {                                                               \
+    if (dDebugFlag & DEBUG_DEBUG) {                               \
+      taosPrintLog("DND ", DEBUG_DEBUG, dDebugFlag, __VA_ARGS__); \
+    }                                                             \
+  }
+#define dTrace(...)                                               \
+  {                                                               \
+    if (dDebugFlag & DEBUG_TRACE) {                               \
+      taosPrintLog("DND ", DEBUG_TRACE, dDebugFlag, __VA_ARGS__); \
+    }                                                             \
+  }
 
 typedef enum { DNODE, VNODES, QNODE, SNODE, MNODE, BNODE, NODE_MAX } ENodeType;
 typedef enum { DND_STAT_INIT, DND_STAT_RUNNING, DND_STAT_STOPPED } EDndStatus;
@@ -73,7 +103,7 @@ typedef int32_t (*DropNodeFp)(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 typedef int32_t (*RequireNodeFp)(SMgmtWrapper *pWrapper, bool *required);
 
 typedef struct SMsgHandle {
-  SMgmtWrapper *pQndWrapper; 
+  SMgmtWrapper *pQndWrapper;
   SMgmtWrapper *pMndWrapper;
   SMgmtWrapper *pWrapper;
 } SMsgHandle;
@@ -146,14 +176,11 @@ void          dndSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp
 SMgmtWrapper *dndAcquireWrapper(SDnode *pDnode, ENodeType nodeType);
 int32_t       dndMarkWrapper(SMgmtWrapper *pWrapper);
 void          dndReleaseWrapper(SMgmtWrapper *pWrapper);
+void          dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
 
 // dndMonitor.h
 void dndSendMonitorReport(SDnode *pDnode);
 
-// dndMsg.h
-void    dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
-int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg);
-
 // dndStr.h
 const char *dndStatStr(EDndStatus stat);
 const char *dndNodeLogStr(ENodeType ntype);
@@ -168,12 +195,12 @@ SProcCfg dndGenProcCfg(SMgmtWrapper *pWrapper);
 int32_t  dndInitMsgHandle(SDnode *pDnode);
 
 // mgmt
-void dmGetMgmtFp(SMgmtWrapper *pWrapper);
-void bmGetMgmtFp(SMgmtWrapper *pWrapper);
-void qmGetMgmtFp(SMgmtWrapper *pMgmt);
-void smGetMgmtFp(SMgmtWrapper *pWrapper);
-void vmGetMgmtFp(SMgmtWrapper *pWrapper);
-void mmGetMgmtFp(SMgmtWrapper *pMgmt);
+void dmSetMgmtFp(SMgmtWrapper *pWrapper);
+void bmSetMgmtFp(SMgmtWrapper *pWrapper);
+void qmSetMgmtFp(SMgmtWrapper *pMgmt);
+void smSetMgmtFp(SMgmtWrapper *pWrapper);
+void vmSetMgmtFp(SMgmtWrapper *pWrapper);
+void mmSetMgmtFp(SMgmtWrapper *pMgmt);
 
 void dmGetMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
 void dmUpdateMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
@@ -194,8 +221,8 @@ void    vmMonitorVnodeLoads(SMgmtWrapper *pWrapper, SArray *pLoads);
 int32_t vmMonitorTfsInfo(SMgmtWrapper *pWrapper, SMonDiskInfo *pInfo);
 void    vmMonitorVnodeReqs(SMgmtWrapper *pWrapper, SMonDnodeInfo *pInfo);
 int32_t mmMonitorMnodeInfo(SMgmtWrapper *pWrapper, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
-                         SMonGrantInfo *pGrantInfo);
-                         
+                           SMonGrantInfo *pGrantInfo);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/dnode/mgmt/main/src/dndInt.c b/source/dnode/mgmt/main/src/dndInt.c
index 72feed7c62..80fefdb3ef 100644
--- a/source/dnode/mgmt/main/src/dndInt.c
+++ b/source/dnode/mgmt/main/src/dndInt.c
@@ -82,12 +82,12 @@ SDnode *dndCreate(const SDnodeOpt *pOption) {
   }
 
   dndSetStatus(pDnode, DND_STAT_INIT);
-  dmGetMgmtFp(&pDnode->wrappers[DNODE]);
-  mmGetMgmtFp(&pDnode->wrappers[MNODE]);
-  vmGetMgmtFp(&pDnode->wrappers[VNODES]);
-  qmGetMgmtFp(&pDnode->wrappers[QNODE]);
-  smGetMgmtFp(&pDnode->wrappers[SNODE]);
-  bmGetMgmtFp(&pDnode->wrappers[BNODE]);
+  dmSetMgmtFp(&pDnode->wrappers[DNODE]);
+  mmSetMgmtFp(&pDnode->wrappers[MNODE]);
+  vmSetMgmtFp(&pDnode->wrappers[VNODES]);
+  qmSetMgmtFp(&pDnode->wrappers[QNODE]);
+  smSetMgmtFp(&pDnode->wrappers[SNODE]);
+  bmSetMgmtFp(&pDnode->wrappers[BNODE]);
 
   for (ENodeType n = 0; n < NODE_MAX; ++n) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
diff --git a/source/dnode/mgmt/mm/src/mmInt.c b/source/dnode/mgmt/mm/src/mmInt.c
index bd7446780d..97fdafe139 100644
--- a/source/dnode/mgmt/mm/src/mmInt.c
+++ b/source/dnode/mgmt/mm/src/mmInt.c
@@ -227,7 +227,7 @@ static int32_t mmStart(SMgmtWrapper *pWrapper) {
   return mndStart(pMgmt->pMnode);
 }
 
-void mmGetMgmtFp(SMgmtWrapper *pWrapper) {
+void mmSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = mmOpen;
   mgmtFp.closeFp = mmClose;
diff --git a/source/dnode/mgmt/qm/src/qmInt.c b/source/dnode/mgmt/qm/src/qmInt.c
index 8079859b96..53c43bf841 100644
--- a/source/dnode/mgmt/qm/src/qmInt.c
+++ b/source/dnode/mgmt/qm/src/qmInt.c
@@ -112,7 +112,7 @@ int32_t qmOpen(SMgmtWrapper *pWrapper) {
   return code;
 }
 
-void qmGetMgmtFp(SMgmtWrapper *pWrapper) {
+void qmSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = qmOpen;
   mgmtFp.closeFp = qmClose;
diff --git a/source/dnode/mgmt/sm/src/smInt.c b/source/dnode/mgmt/sm/src/smInt.c
index 6d2e2aaefd..a279655609 100644
--- a/source/dnode/mgmt/sm/src/smInt.c
+++ b/source/dnode/mgmt/sm/src/smInt.c
@@ -109,7 +109,7 @@ int32_t smOpen(SMgmtWrapper *pWrapper) {
   return code;
 }
 
-void smGetMgmtFp(SMgmtWrapper *pWrapper) {
+void smSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = smOpen;
   mgmtFp.closeFp = smClose;
diff --git a/source/dnode/mgmt/vm/src/vmInt.c b/source/dnode/mgmt/vm/src/vmInt.c
index d9ef7b5ae6..d78a567b69 100644
--- a/source/dnode/mgmt/vm/src/vmInt.c
+++ b/source/dnode/mgmt/vm/src/vmInt.c
@@ -333,7 +333,7 @@ static int32_t vmRequire(SMgmtWrapper *pWrapper, bool *required) {
   return 0;
 }
 
-void vmGetMgmtFp(SMgmtWrapper *pWrapper) {
+void vmSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = vmInit;
   mgmtFp.closeFp = vmCleanup;

From 1839793b143b0c81844d0e15a595b46a2d41af2a Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 2 Apr 2022 20:31:11 +0800
Subject: [PATCH 9/9] rename files

---
 source/dnode/mgmt/CMakeLists.txt              | 26 +++++++------------
 source/dnode/mgmt/bm/{src => }/bmHandle.c     |  0
 source/dnode/mgmt/bm/{src => }/bmInt.c        |  0
 source/dnode/mgmt/bm/{src => }/bmWorker.c     |  0
 source/dnode/mgmt/dm/{src => }/dmFile.c       |  0
 source/dnode/mgmt/dm/{src => }/dmHandle.c     |  0
 source/dnode/mgmt/dm/{src => }/dmInt.c        |  0
 source/dnode/mgmt/dm/{src => }/dmWorker.c     |  0
 source/dnode/mgmt/{main => }/exe/dndMain.c    |  0
 source/dnode/mgmt/{bm => }/inc/bmInt.h        |  0
 source/dnode/mgmt/{dm => }/inc/dmInt.h        |  0
 source/dnode/mgmt/{main => }/inc/dnd.h        |  0
 source/dnode/mgmt/{main => }/inc/dndInt.h     |  0
 source/dnode/mgmt/{mm => }/inc/mmInt.h        |  0
 source/dnode/mgmt/{qm => }/inc/qmInt.h        |  0
 source/dnode/mgmt/{sm => }/inc/smInt.h        |  0
 source/dnode/mgmt/{vm => }/inc/vmInt.h        |  0
 source/dnode/mgmt/main/{src => }/dndEnv.c     |  0
 source/dnode/mgmt/main/{src => }/dndExec.c    |  0
 source/dnode/mgmt/main/{src => }/dndFile.c    |  0
 source/dnode/mgmt/main/{src => }/dndInt.c     |  0
 source/dnode/mgmt/main/{src => }/dndMonitor.c |  0
 .../dnode/mgmt/main/{src => }/dndTransport.c  |  0
 source/dnode/mgmt/mm/{src => }/mmFile.c       |  0
 source/dnode/mgmt/mm/{src => }/mmHandle.c     |  0
 source/dnode/mgmt/mm/{src => }/mmInt.c        |  0
 source/dnode/mgmt/mm/{src => }/mmWorker.c     |  0
 source/dnode/mgmt/qm/{src => }/qmHandle.c     |  0
 source/dnode/mgmt/qm/{src => }/qmInt.c        |  0
 source/dnode/mgmt/qm/{src => }/qmWorker.c     |  0
 source/dnode/mgmt/sm/{src => }/smHandle.c     |  0
 source/dnode/mgmt/sm/{src => }/smInt.c        |  0
 source/dnode/mgmt/sm/{src => }/smWorker.c     |  0
 source/dnode/mgmt/vm/{src => }/vmFile.c       |  0
 source/dnode/mgmt/vm/{src => }/vmHandle.c     |  0
 source/dnode/mgmt/vm/{src => }/vmInt.c        |  0
 source/dnode/mgmt/vm/{src => }/vmWorker.c     |  0
 37 files changed, 10 insertions(+), 16 deletions(-)
 rename source/dnode/mgmt/bm/{src => }/bmHandle.c (100%)
 rename source/dnode/mgmt/bm/{src => }/bmInt.c (100%)
 rename source/dnode/mgmt/bm/{src => }/bmWorker.c (100%)
 rename source/dnode/mgmt/dm/{src => }/dmFile.c (100%)
 rename source/dnode/mgmt/dm/{src => }/dmHandle.c (100%)
 rename source/dnode/mgmt/dm/{src => }/dmInt.c (100%)
 rename source/dnode/mgmt/dm/{src => }/dmWorker.c (100%)
 rename source/dnode/mgmt/{main => }/exe/dndMain.c (100%)
 rename source/dnode/mgmt/{bm => }/inc/bmInt.h (100%)
 rename source/dnode/mgmt/{dm => }/inc/dmInt.h (100%)
 rename source/dnode/mgmt/{main => }/inc/dnd.h (100%)
 rename source/dnode/mgmt/{main => }/inc/dndInt.h (100%)
 rename source/dnode/mgmt/{mm => }/inc/mmInt.h (100%)
 rename source/dnode/mgmt/{qm => }/inc/qmInt.h (100%)
 rename source/dnode/mgmt/{sm => }/inc/smInt.h (100%)
 rename source/dnode/mgmt/{vm => }/inc/vmInt.h (100%)
 rename source/dnode/mgmt/main/{src => }/dndEnv.c (100%)
 rename source/dnode/mgmt/main/{src => }/dndExec.c (100%)
 rename source/dnode/mgmt/main/{src => }/dndFile.c (100%)
 rename source/dnode/mgmt/main/{src => }/dndInt.c (100%)
 rename source/dnode/mgmt/main/{src => }/dndMonitor.c (100%)
 rename source/dnode/mgmt/main/{src => }/dndTransport.c (100%)
 rename source/dnode/mgmt/mm/{src => }/mmFile.c (100%)
 rename source/dnode/mgmt/mm/{src => }/mmHandle.c (100%)
 rename source/dnode/mgmt/mm/{src => }/mmInt.c (100%)
 rename source/dnode/mgmt/mm/{src => }/mmWorker.c (100%)
 rename source/dnode/mgmt/qm/{src => }/qmHandle.c (100%)
 rename source/dnode/mgmt/qm/{src => }/qmInt.c (100%)
 rename source/dnode/mgmt/qm/{src => }/qmWorker.c (100%)
 rename source/dnode/mgmt/sm/{src => }/smHandle.c (100%)
 rename source/dnode/mgmt/sm/{src => }/smInt.c (100%)
 rename source/dnode/mgmt/sm/{src => }/smWorker.c (100%)
 rename source/dnode/mgmt/vm/{src => }/vmFile.c (100%)
 rename source/dnode/mgmt/vm/{src => }/vmHandle.c (100%)
 rename source/dnode/mgmt/vm/{src => }/vmInt.c (100%)
 rename source/dnode/mgmt/vm/{src => }/vmWorker.c (100%)

diff --git a/source/dnode/mgmt/CMakeLists.txt b/source/dnode/mgmt/CMakeLists.txt
index 81c434eb27..0c9a3733a2 100644
--- a/source/dnode/mgmt/CMakeLists.txt
+++ b/source/dnode/mgmt/CMakeLists.txt
@@ -1,10 +1,10 @@
-aux_source_directory(dm/src DNODE_SRC)
-aux_source_directory(qm/src DNODE_SRC)
-aux_source_directory(bm/src DNODE_SRC)
-aux_source_directory(sm/src DNODE_SRC)
-aux_source_directory(vm/src DNODE_SRC)
-aux_source_directory(mm/src DNODE_SRC)
-aux_source_directory(main/src DNODE_SRC)
+aux_source_directory(dm DNODE_SRC)
+aux_source_directory(qm DNODE_SRC)
+aux_source_directory(bm DNODE_SRC)
+aux_source_directory(sm DNODE_SRC)
+aux_source_directory(vm DNODE_SRC)
+aux_source_directory(mm DNODE_SRC)
+aux_source_directory(main DNODE_SRC)
 add_library(dnode STATIC ${DNODE_SRC})
 target_link_libraries(
     dnode cjson mnode vnode qnode snode bnode wal sync taos tfs monitor
@@ -12,20 +12,14 @@ target_link_libraries(
 target_include_directories(
     dnode
     PUBLIC "${CMAKE_SOURCE_DIR}/include/dnode/mgmt"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/dm/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/qm/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/bm/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/sm/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/vm/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/mm/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/main/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 
-aux_source_directory(main/exe EXEC_SRC)
+aux_source_directory(exe EXEC_SRC)
 add_executable(taosd ${EXEC_SRC})
 target_include_directories(
     taosd
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/main/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(taosd dnode)
 
diff --git a/source/dnode/mgmt/bm/src/bmHandle.c b/source/dnode/mgmt/bm/bmHandle.c
similarity index 100%
rename from source/dnode/mgmt/bm/src/bmHandle.c
rename to source/dnode/mgmt/bm/bmHandle.c
diff --git a/source/dnode/mgmt/bm/src/bmInt.c b/source/dnode/mgmt/bm/bmInt.c
similarity index 100%
rename from source/dnode/mgmt/bm/src/bmInt.c
rename to source/dnode/mgmt/bm/bmInt.c
diff --git a/source/dnode/mgmt/bm/src/bmWorker.c b/source/dnode/mgmt/bm/bmWorker.c
similarity index 100%
rename from source/dnode/mgmt/bm/src/bmWorker.c
rename to source/dnode/mgmt/bm/bmWorker.c
diff --git a/source/dnode/mgmt/dm/src/dmFile.c b/source/dnode/mgmt/dm/dmFile.c
similarity index 100%
rename from source/dnode/mgmt/dm/src/dmFile.c
rename to source/dnode/mgmt/dm/dmFile.c
diff --git a/source/dnode/mgmt/dm/src/dmHandle.c b/source/dnode/mgmt/dm/dmHandle.c
similarity index 100%
rename from source/dnode/mgmt/dm/src/dmHandle.c
rename to source/dnode/mgmt/dm/dmHandle.c
diff --git a/source/dnode/mgmt/dm/src/dmInt.c b/source/dnode/mgmt/dm/dmInt.c
similarity index 100%
rename from source/dnode/mgmt/dm/src/dmInt.c
rename to source/dnode/mgmt/dm/dmInt.c
diff --git a/source/dnode/mgmt/dm/src/dmWorker.c b/source/dnode/mgmt/dm/dmWorker.c
similarity index 100%
rename from source/dnode/mgmt/dm/src/dmWorker.c
rename to source/dnode/mgmt/dm/dmWorker.c
diff --git a/source/dnode/mgmt/main/exe/dndMain.c b/source/dnode/mgmt/exe/dndMain.c
similarity index 100%
rename from source/dnode/mgmt/main/exe/dndMain.c
rename to source/dnode/mgmt/exe/dndMain.c
diff --git a/source/dnode/mgmt/bm/inc/bmInt.h b/source/dnode/mgmt/inc/bmInt.h
similarity index 100%
rename from source/dnode/mgmt/bm/inc/bmInt.h
rename to source/dnode/mgmt/inc/bmInt.h
diff --git a/source/dnode/mgmt/dm/inc/dmInt.h b/source/dnode/mgmt/inc/dmInt.h
similarity index 100%
rename from source/dnode/mgmt/dm/inc/dmInt.h
rename to source/dnode/mgmt/inc/dmInt.h
diff --git a/source/dnode/mgmt/main/inc/dnd.h b/source/dnode/mgmt/inc/dnd.h
similarity index 100%
rename from source/dnode/mgmt/main/inc/dnd.h
rename to source/dnode/mgmt/inc/dnd.h
diff --git a/source/dnode/mgmt/main/inc/dndInt.h b/source/dnode/mgmt/inc/dndInt.h
similarity index 100%
rename from source/dnode/mgmt/main/inc/dndInt.h
rename to source/dnode/mgmt/inc/dndInt.h
diff --git a/source/dnode/mgmt/mm/inc/mmInt.h b/source/dnode/mgmt/inc/mmInt.h
similarity index 100%
rename from source/dnode/mgmt/mm/inc/mmInt.h
rename to source/dnode/mgmt/inc/mmInt.h
diff --git a/source/dnode/mgmt/qm/inc/qmInt.h b/source/dnode/mgmt/inc/qmInt.h
similarity index 100%
rename from source/dnode/mgmt/qm/inc/qmInt.h
rename to source/dnode/mgmt/inc/qmInt.h
diff --git a/source/dnode/mgmt/sm/inc/smInt.h b/source/dnode/mgmt/inc/smInt.h
similarity index 100%
rename from source/dnode/mgmt/sm/inc/smInt.h
rename to source/dnode/mgmt/inc/smInt.h
diff --git a/source/dnode/mgmt/vm/inc/vmInt.h b/source/dnode/mgmt/inc/vmInt.h
similarity index 100%
rename from source/dnode/mgmt/vm/inc/vmInt.h
rename to source/dnode/mgmt/inc/vmInt.h
diff --git a/source/dnode/mgmt/main/src/dndEnv.c b/source/dnode/mgmt/main/dndEnv.c
similarity index 100%
rename from source/dnode/mgmt/main/src/dndEnv.c
rename to source/dnode/mgmt/main/dndEnv.c
diff --git a/source/dnode/mgmt/main/src/dndExec.c b/source/dnode/mgmt/main/dndExec.c
similarity index 100%
rename from source/dnode/mgmt/main/src/dndExec.c
rename to source/dnode/mgmt/main/dndExec.c
diff --git a/source/dnode/mgmt/main/src/dndFile.c b/source/dnode/mgmt/main/dndFile.c
similarity index 100%
rename from source/dnode/mgmt/main/src/dndFile.c
rename to source/dnode/mgmt/main/dndFile.c
diff --git a/source/dnode/mgmt/main/src/dndInt.c b/source/dnode/mgmt/main/dndInt.c
similarity index 100%
rename from source/dnode/mgmt/main/src/dndInt.c
rename to source/dnode/mgmt/main/dndInt.c
diff --git a/source/dnode/mgmt/main/src/dndMonitor.c b/source/dnode/mgmt/main/dndMonitor.c
similarity index 100%
rename from source/dnode/mgmt/main/src/dndMonitor.c
rename to source/dnode/mgmt/main/dndMonitor.c
diff --git a/source/dnode/mgmt/main/src/dndTransport.c b/source/dnode/mgmt/main/dndTransport.c
similarity index 100%
rename from source/dnode/mgmt/main/src/dndTransport.c
rename to source/dnode/mgmt/main/dndTransport.c
diff --git a/source/dnode/mgmt/mm/src/mmFile.c b/source/dnode/mgmt/mm/mmFile.c
similarity index 100%
rename from source/dnode/mgmt/mm/src/mmFile.c
rename to source/dnode/mgmt/mm/mmFile.c
diff --git a/source/dnode/mgmt/mm/src/mmHandle.c b/source/dnode/mgmt/mm/mmHandle.c
similarity index 100%
rename from source/dnode/mgmt/mm/src/mmHandle.c
rename to source/dnode/mgmt/mm/mmHandle.c
diff --git a/source/dnode/mgmt/mm/src/mmInt.c b/source/dnode/mgmt/mm/mmInt.c
similarity index 100%
rename from source/dnode/mgmt/mm/src/mmInt.c
rename to source/dnode/mgmt/mm/mmInt.c
diff --git a/source/dnode/mgmt/mm/src/mmWorker.c b/source/dnode/mgmt/mm/mmWorker.c
similarity index 100%
rename from source/dnode/mgmt/mm/src/mmWorker.c
rename to source/dnode/mgmt/mm/mmWorker.c
diff --git a/source/dnode/mgmt/qm/src/qmHandle.c b/source/dnode/mgmt/qm/qmHandle.c
similarity index 100%
rename from source/dnode/mgmt/qm/src/qmHandle.c
rename to source/dnode/mgmt/qm/qmHandle.c
diff --git a/source/dnode/mgmt/qm/src/qmInt.c b/source/dnode/mgmt/qm/qmInt.c
similarity index 100%
rename from source/dnode/mgmt/qm/src/qmInt.c
rename to source/dnode/mgmt/qm/qmInt.c
diff --git a/source/dnode/mgmt/qm/src/qmWorker.c b/source/dnode/mgmt/qm/qmWorker.c
similarity index 100%
rename from source/dnode/mgmt/qm/src/qmWorker.c
rename to source/dnode/mgmt/qm/qmWorker.c
diff --git a/source/dnode/mgmt/sm/src/smHandle.c b/source/dnode/mgmt/sm/smHandle.c
similarity index 100%
rename from source/dnode/mgmt/sm/src/smHandle.c
rename to source/dnode/mgmt/sm/smHandle.c
diff --git a/source/dnode/mgmt/sm/src/smInt.c b/source/dnode/mgmt/sm/smInt.c
similarity index 100%
rename from source/dnode/mgmt/sm/src/smInt.c
rename to source/dnode/mgmt/sm/smInt.c
diff --git a/source/dnode/mgmt/sm/src/smWorker.c b/source/dnode/mgmt/sm/smWorker.c
similarity index 100%
rename from source/dnode/mgmt/sm/src/smWorker.c
rename to source/dnode/mgmt/sm/smWorker.c
diff --git a/source/dnode/mgmt/vm/src/vmFile.c b/source/dnode/mgmt/vm/vmFile.c
similarity index 100%
rename from source/dnode/mgmt/vm/src/vmFile.c
rename to source/dnode/mgmt/vm/vmFile.c
diff --git a/source/dnode/mgmt/vm/src/vmHandle.c b/source/dnode/mgmt/vm/vmHandle.c
similarity index 100%
rename from source/dnode/mgmt/vm/src/vmHandle.c
rename to source/dnode/mgmt/vm/vmHandle.c
diff --git a/source/dnode/mgmt/vm/src/vmInt.c b/source/dnode/mgmt/vm/vmInt.c
similarity index 100%
rename from source/dnode/mgmt/vm/src/vmInt.c
rename to source/dnode/mgmt/vm/vmInt.c
diff --git a/source/dnode/mgmt/vm/src/vmWorker.c b/source/dnode/mgmt/vm/vmWorker.c
similarity index 100%
rename from source/dnode/mgmt/vm/src/vmWorker.c
rename to source/dnode/mgmt/vm/vmWorker.c