Merge branch '3.0' of github.com:taosdata/TDengine into feature/vnode

include/common/tmsg.h

@@ -345,18 +345,18 @@ typedef struct {
   int32_t maxStreams;
   int32_t accessState;  // Configured only by command
   int64_t maxStorage;   // In unit of GB
-} SCreateAcctMsg, SAlterAcctMsg;
+} SCreateAcctReq, SAlterAcctReq;
 
 typedef struct {
   char user[TSDB_USER_LEN];
-} SDropUserMsg, SDropAcctMsg;
+} SDropUserReq, SDropAcctReq;
 
 typedef struct {
   int8_t type;
   char   user[TSDB_USER_LEN];
   char   pass[TSDB_PASSWORD_LEN];
   int8_t superUser;  // denote if it is a super user or not
-} SCreateUserMsg, SAlterUserMsg;
+} SCreateUserReq, SAlterUserReq;
 
 typedef struct {
   int32_t  contLen;
@@ -851,15 +851,15 @@ typedef struct {
 
 typedef struct {
   int32_t dnodeId;
-} SMCreateQnodeMsg, SMDropQnodeMsg, SDCreateQnodeMsg, SDDropQnodeMsg;
+} SMCreateQnodeReq, SMDropQnodeReq, SDCreateQnodeReq, SDDropQnodeReq;
 
 typedef struct {
   int32_t dnodeId;
-} SMCreateSnodeMsg, SMDropSnodeMsg, SDCreateSnodeMsg, SDDropSnodeMsg;
+} SMCreateSnodeReq, SMDropSnodeReq, SDCreateSnodeReq, SDDropSnodeReq;
 
 typedef struct {
   int32_t dnodeId;
-} SMCreateBnodeMsg, SMDropBnodeMsg, SDCreateBnodeMsg, SDDropBnodeMsg;
+} SMCreateBnodeReq, SMDropBnodeReq, SDCreateBnodeReq, SDDropBnodeReq;
 
 typedef struct {
   int32_t dnodeId;

include/dnode/bnode/bnode.h

@@ -23,9 +23,9 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ------------------------ */
 typedef struct SDnode SDnode;
 typedef struct SBnode SBnode;
-typedef void (*SendMsgToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
-typedef void (*SendMsgToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
-typedef void (*SendRedirectMsgFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 
 typedef struct {
   int64_t numOfErrors;
@@ -40,9 +40,9 @@ typedef struct {
   int64_t           clusterId;
   SBnodeCfg         cfg;
   SDnode           *pDnode;
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
 } SBnodeOpt;
 
 /* ------------------------ SBnode ------------------------ */

include/dnode/mnode/mnode.h

@@ -24,9 +24,10 @@ extern "C" {
 typedef struct SDnode    SDnode;
 typedef struct SMnode    SMnode;
 typedef struct SMnodeMsg SMnodeMsg;
-typedef void (*SendMsgToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
-typedef void (*SendMsgToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
-typedef void (*SendRedirectMsgFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*PutReqToMWriteQFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 
 typedef struct SMnodeLoad {
   int64_t numOfDnode;
@@ -62,9 +63,10 @@ typedef struct {
   SReplica          replicas[TSDB_MAX_REPLICA];
   SMnodeCfg         cfg;
   SDnode           *pDnode;
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  PutReqToMWriteQFp putReqToMWriteQFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
 } SMnodeOpt;
 
 /* ------------------------ SMnode ------------------------ */

include/dnode/qnode/qnode.h

@@ -23,9 +23,9 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ------------------------ */
 typedef struct SDnode SDnode;
 typedef struct SQnode SQnode;
-typedef void (*SendMsgToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
-typedef void (*SendMsgToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
-typedef void (*SendRedirectMsgFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 
 typedef struct {
   int64_t numOfStartTask;
@@ -47,9 +47,9 @@ typedef struct {
   int64_t           clusterId;
   SQnodeCfg         cfg;
   SDnode           *pDnode;
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
 } SQnodeOpt;
 
 /* ------------------------ SQnode ------------------------ */

include/dnode/snode/snode.h

@@ -23,9 +23,9 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ------------------------ */
 typedef struct SDnode SDnode;
 typedef struct SSnode SSnode;
-typedef void (*SendMsgToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
-typedef void (*SendMsgToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
-typedef void (*SendRedirectMsgFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 
 typedef struct {
   int64_t numOfErrors;
@@ -40,9 +40,9 @@ typedef struct {
   int64_t           clusterId;
   SSnodeCfg         cfg;
   SDnode           *pDnode;
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
 } SSnodeOpt;
 
 /* ------------------------ SSnode ------------------------ */

include/util/taoserror.h

@@ -253,7 +253,7 @@ int32_t* taosGetErrno();
 
 // dnode
 #define TSDB_CODE_DND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0400)
-#define TSDB_CODE_DND_EXITING                   TAOS_DEF_ERROR_CODE(0, 0x0401)
+#define TSDB_CODE_DND_OFFLINE                   TAOS_DEF_ERROR_CODE(0, 0x0401)
 #define TSDB_CODE_DND_INVALID_MSG_LEN           TAOS_DEF_ERROR_CODE(0, 0x0402)
 #define TSDB_CODE_DND_DNODE_READ_FILE_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0410)
 #define TSDB_CODE_DND_DNODE_WRITE_FILE_ERROR    TAOS_DEF_ERROR_CODE(0, 0x0411)

source/dnode/bnode/inc/bndInt.h

@@ -33,9 +33,9 @@ typedef struct SBnode {
   int32_t           dnodeId;
   int64_t           clusterId;
   SBnodeCfg         cfg;
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
 } SBnode;
 
 #ifdef __cplusplus

source/dnode/mgmt/impl/inc/dndDnode.h

@@ -29,8 +29,8 @@ int64_t dndGetClusterId(SDnode *pDnode);
 void    dndGetDnodeEp(SDnode *pDnode, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort);
 void    dndGetMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet);
 
-void dndSendRedirectMsg(SDnode *pDnode, SRpcMsg *pMsg);
-void dndSendStatusMsg(SDnode *pDnode);
+void dndSendRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg);
+void dndSendStatusReq(SDnode *pDnode);
 void dndProcessMgmtMsg(SDnode *pDnode, SRpcMsg *pRpcMsg, SEpSet *pEpSet);
 void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg);
 

source/dnode/mgmt/impl/inc/dndTransport.h

@@ -23,8 +23,8 @@ extern "C" {
 
 int32_t dndInitTrans(SDnode *pDnode);
 void    dndCleanupTrans(SDnode *pDnode);
-void    dndSendMsgToMnode(SDnode *pDnode, SRpcMsg *pRpcMsg);
-void    dndSendMsgToDnode(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pRpcMsg);
+int32_t dndSendReqToMnode(SDnode *pDnode, SRpcMsg *pRpcMsg);
+int32_t dndSendReqToDnode(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pRpcMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/impl/src/dndBnode.c

@@ -27,7 +27,7 @@ static SBnode *dndAcquireBnode(SDnode *pDnode) {
   int32_t     refCount = 0;
 
   taosRLockLatch(&pMgmt->latch);
-  if (pMgmt->deployed && !pMgmt->dropped) {
+  if (pMgmt->deployed && !pMgmt->dropped && pMgmt->pBnode != NULL) {
     refCount = atomic_add_fetch_32(&pMgmt->refCount, 1);
     pBnode = pMgmt->pBnode;
   } else {
@@ -60,7 +60,7 @@ static int32_t dndReadBnodeFile(SDnode *pDnode) {
   SBnodeMgmt *pMgmt = &pDnode->bmgmt;
   int32_t     code = TSDB_CODE_DND_BNODE_READ_FILE_ERROR;
   int32_t     len = 0;
-  int32_t     maxLen = 4096;
+  int32_t     maxLen = 1024;
   char       *content = calloc(1, maxLen + 1);
   cJSON      *root = NULL;
 
@@ -127,7 +127,7 @@ static int32_t dndWriteBnodeFile(SDnode *pDnode) {
   }
 
   int32_t len = 0;
-  int32_t maxLen = 4096;
+  int32_t maxLen = 1024;
   char   *content = calloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
@@ -170,7 +170,7 @@ static void dndStopBnodeWorker(SDnode *pDnode) {
   pMgmt->deployed = 0;
   taosWUnLockLatch(&pMgmt->latch);
 
-  while (pMgmt->refCount > 1) {
+  while (pMgmt->refCount > 0) {
     taosMsleep(10);
   }
 
@@ -179,9 +179,9 @@ static void dndStopBnodeWorker(SDnode *pDnode) {
 
 static void dndBuildBnodeOption(SDnode *pDnode, SBnodeOpt *pOption) {
   pOption->pDnode = pDnode;
-  pOption->sendMsgToDnodeFp = dndSendMsgToDnode;
-  pOption->sendMsgToMnodeFp = dndSendMsgToMnode;
-  pOption->sendRedirectMsgFp = dndSendRedirectMsg;
+  pOption->sendReqToDnodeFp = dndSendReqToDnode;
+  pOption->sendReqToMnodeFp = dndSendReqToMnode;
+  pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
   pOption->cfg.sver = pDnode->opt.sver;
@@ -189,10 +189,18 @@ static void dndBuildBnodeOption(SDnode *pDnode, SBnodeOpt *pOption) {
 
 static int32_t dndOpenBnode(SDnode *pDnode) {
   SBnodeMgmt *pMgmt = &pDnode->bmgmt;
-  SBnodeOpt   option = {0};
+  SBnode     *pBnode = dndAcquireBnode(pDnode);
+  if (pBnode != NULL) {
+    dndReleaseBnode(pDnode, pBnode);
+    terrno = TSDB_CODE_DND_BNODE_ALREADY_DEPLOYED;
+    dError("failed to create bnode since %s", terrstr());
+    return -1;
+  }
+
+  SBnodeOpt option = {0};
   dndBuildBnodeOption(pDnode, &option);
 
-  SBnode *pBnode = bndOpen(pDnode->dir.bnode, &option);
+  pBnode = bndOpen(pDnode->dir.bnode, &option);
   if (pBnode == NULL) {
     dError("failed to open bnode since %s", terrstr());
     return -1;
@@ -256,11 +264,12 @@ static int32_t dndDropBnode(SDnode *pDnode) {
 }
 
 int32_t dndProcessCreateBnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
-  SDCreateBnodeMsg *pMsg = pRpcMsg->pCont;
+  SDCreateBnodeReq *pMsg = pRpcMsg->pCont;
   pMsg->dnodeId = htonl(pMsg->dnodeId);
 
   if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
     terrno = TSDB_CODE_DND_BNODE_ID_INVALID;
+    dError("failed to create bnode since %s", terrstr());
     return -1;
   } else {
     return dndOpenBnode(pDnode);
@@ -268,11 +277,12 @@ int32_t dndProcessCreateBnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
 }
 
 int32_t dndProcessDropBnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
-  SDDropBnodeMsg *pMsg = pRpcMsg->pCont;
+  SDDropBnodeReq *pMsg = pRpcMsg->pCont;
   pMsg->dnodeId = htonl(pMsg->dnodeId);
 
   if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
     terrno = TSDB_CODE_DND_BNODE_ID_INVALID;
+    dError("failed to drop bnode since %s", terrstr());
     return -1;
   } else {
     return dndDropBnode(pDnode);

source/dnode/mgmt/impl/src/dndDnode.c

@@ -80,7 +80,7 @@ void dndGetMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
   taosRUnLockLatch(&pMgmt->latch);
 }
 
-void dndSendRedirectMsg(SDnode *pDnode, SRpcMsg *pMsg) {
+void dndSendRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) {
   tmsg_t msgType = pMsg->msgType;
 
   SEpSet epSet = {0};
@@ -354,7 +354,7 @@ static int32_t dndWriteDnodes(SDnode *pDnode) {
   return 0;
 }
 
-void dndSendStatusMsg(SDnode *pDnode) {
+void dndSendStatusReq(SDnode *pDnode) {
   int32_t contLen = sizeof(SStatusMsg) + TSDB_MAX_VNODES * sizeof(SVnodeLoad);
 
   SStatusMsg *pStatus = rpcMallocCont(contLen);
@@ -391,7 +391,7 @@ void dndSendStatusMsg(SDnode *pDnode) {
   pMgmt->statusSent = 1;
 
   dTrace("pDnode:%p, send status msg to mnode", pDnode);
-  dndSendMsgToMnode(pDnode, &rpcMsg);
+  dndSendReqToMnode(pDnode, &rpcMsg);
 }
 
 static void dndUpdateDnodeCfg(SDnode *pDnode, SDnodeCfg *pCfg) {
@@ -491,7 +491,7 @@ static void *dnodeThreadRoutine(void *param) {
     taosMsleep(ms);
 
     if (dndGetStat(pDnode) == DND_STAT_RUNNING && !pMgmt->statusSent && !pMgmt->dropped) {
-      dndSendStatusMsg(pDnode);
+      dndSendStatusReq(pDnode);
     }
   }
 }

source/dnode/mgmt/impl/src/dndMnode.c

@@ -19,6 +19,7 @@
 #include "dndTransport.h"
 #include "dndWorker.h"
 
+static void dndWriteMnodeMsgToWorker(SDnode *pDnode, SDnodeWorker *pWorker, SRpcMsg *pRpcMsg);
 static void dndProcessMnodeQueue(SDnode *pDnode, SMnodeMsg *pMsg);
 
 static SMnode *dndAcquireMnode(SDnode *pDnode) {
@@ -258,11 +259,16 @@ static bool dndNeedDeployMnode(SDnode *pDnode) {
   return true;
 }
 
+static int32_t dndPutMsgToMWriteQ(SDnode *pDnode, SRpcMsg *pRpcMsg) {
+  dndWriteMnodeMsgToWorker(pDnode, &pDnode->mmgmt.writeWorker, pRpcMsg);
+}
+
 static void dndInitMnodeOption(SDnode *pDnode, SMnodeOpt *pOption) {
   pOption->pDnode = pDnode;
-  pOption->sendMsgToDnodeFp = dndSendMsgToDnode;
-  pOption->sendMsgToMnodeFp = dndSendMsgToMnode;
-  pOption->sendRedirectMsgFp = dndSendRedirectMsg;
+  pOption->sendReqToDnodeFp = dndSendReqToDnode;
+  pOption->sendReqToMnodeFp = dndSendReqToMnode;
+  pOption->sendRedirectRspFp = dndSendRedirectRsp;
+  pOption->putReqToMWriteQFp = dndPutMsgToMWriteQ;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
   pOption->cfg.sver = pDnode->opt.sver;

source/dnode/mgmt/impl/src/dndQnode.c

@@ -27,7 +27,7 @@ static SQnode *dndAcquireQnode(SDnode *pDnode) {
   int32_t     refCount = 0;
 
   taosRLockLatch(&pMgmt->latch);
-  if (pMgmt->deployed && !pMgmt->dropped) {
+  if (pMgmt->deployed && !pMgmt->dropped && pMgmt->pQnode != NULL) {
     refCount = atomic_add_fetch_32(&pMgmt->refCount, 1);
     pQnode = pMgmt->pQnode;
   } else {
@@ -60,7 +60,7 @@ static int32_t dndReadQnodeFile(SDnode *pDnode) {
   SQnodeMgmt *pMgmt = &pDnode->qmgmt;
   int32_t     code = TSDB_CODE_DND_QNODE_READ_FILE_ERROR;
   int32_t     len = 0;
-  int32_t     maxLen = 4096;
+  int32_t     maxLen = 1024;
   char       *content = calloc(1, maxLen + 1);
   cJSON      *root = NULL;
 
@@ -127,7 +127,7 @@ static int32_t dndWriteQnodeFile(SDnode *pDnode) {
   }
 
   int32_t len = 0;
-  int32_t maxLen = 4096;
+  int32_t maxLen = 1024;
   char   *content = calloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
@@ -175,7 +175,7 @@ static void dndStopQnodeWorker(SDnode *pDnode) {
   pMgmt->deployed = 0;
   taosWUnLockLatch(&pMgmt->latch);
 
-  while (pMgmt->refCount > 1) {
+  while (pMgmt->refCount > 0) {
     taosMsleep(10);
   }
 
@@ -185,9 +185,9 @@ static void dndStopQnodeWorker(SDnode *pDnode) {
 
 static void dndBuildQnodeOption(SDnode *pDnode, SQnodeOpt *pOption) {
   pOption->pDnode = pDnode;
-  pOption->sendMsgToDnodeFp = dndSendMsgToDnode;
-  pOption->sendMsgToMnodeFp = dndSendMsgToMnode;
-  pOption->sendRedirectMsgFp = dndSendRedirectMsg;
+  pOption->sendReqToDnodeFp = dndSendReqToDnode;
+  pOption->sendReqToMnodeFp = dndSendReqToMnode;
+  pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
   pOption->cfg.sver = pDnode->opt.sver;
@@ -195,10 +195,19 @@ static void dndBuildQnodeOption(SDnode *pDnode, SQnodeOpt *pOption) {
 
 static int32_t dndOpenQnode(SDnode *pDnode) {
   SQnodeMgmt *pMgmt = &pDnode->qmgmt;
-  SQnodeOpt   option = {0};
+
+  SQnode *pQnode = dndAcquireQnode(pDnode);
+  if (pQnode != NULL) {
+    dndReleaseQnode(pDnode, pQnode);
+    terrno = TSDB_CODE_DND_QNODE_ALREADY_DEPLOYED;
+    dError("failed to create qnode since %s", terrstr());
+    return -1;
+  }
+
+  SQnodeOpt option = {0};
   dndBuildQnodeOption(pDnode, &option);
 
-  SQnode *pQnode = qndOpen(&option);
+  pQnode = qndOpen(&option);
   if (pQnode == NULL) {
     dError("failed to open qnode since %s", terrstr());
     return -1;
@@ -261,11 +270,12 @@ static int32_t dndDropQnode(SDnode *pDnode) {
 }
 
 int32_t dndProcessCreateQnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
-  SDCreateQnodeMsg *pMsg = pRpcMsg->pCont;
+  SDCreateQnodeReq *pMsg = pRpcMsg->pCont;
   pMsg->dnodeId = htonl(pMsg->dnodeId);
 
   if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
     terrno = TSDB_CODE_DND_QNODE_ID_INVALID;
+    dError("failed to create qnode since %s", terrstr());
     return -1;
   } else {
     return dndOpenQnode(pDnode);
@@ -273,11 +283,12 @@ int32_t dndProcessCreateQnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
 }
 
 int32_t dndProcessDropQnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
-  SDDropQnodeMsg *pMsg = pRpcMsg->pCont;
+  SDDropQnodeReq *pMsg = pRpcMsg->pCont;
   pMsg->dnodeId = htonl(pMsg->dnodeId);
 
   if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
     terrno = TSDB_CODE_DND_QNODE_ID_INVALID;
+    dError("failed to drop qnode since %s", terrstr());
     return -1;
   } else {
     return dndDropQnode(pDnode);
@@ -293,6 +304,7 @@ static void dndProcessQnodeQueue(SDnode *pDnode, SRpcMsg *pMsg) {
   if (pQnode != NULL) {
     code = qndProcessMsg(pQnode, pMsg, &pRsp);
   }
+  dndReleaseQnode(pDnode, pQnode);
 
   if (pRsp != NULL) {
     pRsp->ahandle = pMsg->ahandle;

source/dnode/mgmt/impl/src/dndSnode.c

@@ -27,7 +27,7 @@ static SSnode *dndAcquireSnode(SDnode *pDnode) {
   int32_t     refCount = 0;
 
   taosRLockLatch(&pMgmt->latch);
-  if (pMgmt->deployed && !pMgmt->dropped) {
+  if (pMgmt->deployed && !pMgmt->dropped && pMgmt->pSnode != NULL) {
     refCount = atomic_add_fetch_32(&pMgmt->refCount, 1);
     pSnode = pMgmt->pSnode;
   } else {
@@ -60,7 +60,7 @@ static int32_t dndReadSnodeFile(SDnode *pDnode) {
   SSnodeMgmt *pMgmt = &pDnode->smgmt;
   int32_t     code = TSDB_CODE_DND_SNODE_READ_FILE_ERROR;
   int32_t     len = 0;
-  int32_t     maxLen = 4096;
+  int32_t     maxLen = 1024;
   char       *content = calloc(1, maxLen + 1);
   cJSON      *root = NULL;
 
@@ -127,7 +127,7 @@ static int32_t dndWriteSnodeFile(SDnode *pDnode) {
   }
 
   int32_t len = 0;
-  int32_t maxLen = 4096;
+  int32_t maxLen = 1024;
   char   *content = calloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
@@ -170,18 +170,18 @@ static void dndStopSnodeWorker(SDnode *pDnode) {
   pMgmt->deployed = 0;
   taosWUnLockLatch(&pMgmt->latch);
 
-  while (pMgmt->refCount > 1) {
+  while (pMgmt->refCount > 0) {
     taosMsleep(10);
-  }
+  } 
 
   dndCleanupWorker(&pMgmt->writeWorker);
 }
 
 static void dndBuildSnodeOption(SDnode *pDnode, SSnodeOpt *pOption) {
   pOption->pDnode = pDnode;
-  pOption->sendMsgToDnodeFp = dndSendMsgToDnode;
-  pOption->sendMsgToMnodeFp = dndSendMsgToMnode;
-  pOption->sendRedirectMsgFp = dndSendRedirectMsg;
+  pOption->sendReqToDnodeFp = dndSendReqToDnode;
+  pOption->sendReqToMnodeFp = dndSendReqToMnode;
+  pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
   pOption->cfg.sver = pDnode->opt.sver;
@@ -189,10 +189,18 @@ static void dndBuildSnodeOption(SDnode *pDnode, SSnodeOpt *pOption) {
 
 static int32_t dndOpenSnode(SDnode *pDnode) {
   SSnodeMgmt *pMgmt = &pDnode->smgmt;
-  SSnodeOpt   option = {0};
+  SSnode     *pSnode = dndAcquireSnode(pDnode);
+  if (pSnode != NULL) {
+    dndReleaseSnode(pDnode, pSnode);
+    terrno = TSDB_CODE_DND_SNODE_ALREADY_DEPLOYED;
+    dError("failed to create snode since %s", terrstr());
+    return -1;
+  }
+
+  SSnodeOpt option = {0};
   dndBuildSnodeOption(pDnode, &option);
 
-  SSnode *pSnode = sndOpen(pDnode->dir.snode, &option);
+  pSnode = sndOpen(pDnode->dir.snode, &option);
   if (pSnode == NULL) {
     dError("failed to open snode since %s", terrstr());
     return -1;
@@ -256,11 +264,12 @@ static int32_t dndDropSnode(SDnode *pDnode) {
 }
 
 int32_t dndProcessCreateSnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
-  SDCreateSnodeMsg *pMsg = pRpcMsg->pCont;
+  SDCreateSnodeReq *pMsg = pRpcMsg->pCont;
   pMsg->dnodeId = htonl(pMsg->dnodeId);
 
   if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
     terrno = TSDB_CODE_DND_SNODE_ID_INVALID;
+    dError("failed to create snode since %s", terrstr());
     return -1;
   } else {
     return dndOpenSnode(pDnode);
@@ -268,11 +277,12 @@ int32_t dndProcessCreateSnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
 }
 
 int32_t dndProcessDropSnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
-  SDDropSnodeMsg *pMsg = pRpcMsg->pCont;
+  SDDropSnodeReq *pMsg = pRpcMsg->pCont;
   pMsg->dnodeId = htonl(pMsg->dnodeId);
 
   if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
     terrno = TSDB_CODE_DND_SNODE_ID_INVALID;
+    dError("failed to drop snode since %s", terrstr());
     return -1;
   } else {
     return dndDropSnode(pDnode);
@@ -288,6 +298,7 @@ static void dndProcessSnodeQueue(SDnode *pDnode, SRpcMsg *pMsg) {
   if (pSnode != NULL) {
     code = sndProcessMsg(pSnode, pMsg, &pRsp);
   }
+  dndReleaseSnode(pDnode, pSnode);
 
   if (pRsp != NULL) {
     pRsp->ahandle = pMsg->ahandle;

source/dnode/mgmt/impl/src/dndTransport.c

@@ -105,8 +105,6 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_SHOW_RETRIEVE)] = dndProcessMnodeReadMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_STATUS)] = dndProcessMnodeReadMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_STATUS_RSP)] = dndProcessMgmtMsg;
-  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_TRANS)] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_TRANS_RSP)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_GRANT)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_GRANT_RSP)] = dndProcessMgmtMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_AUTH)] = dndProcessMnodeReadMsg;
@@ -216,7 +214,7 @@ static void dndProcessRequest(void *param, SRpcMsg *pMsg, SEpSet *pEpSet) {
 
   if (dndGetStat(pDnode) == DND_STAT_STOPPED) {
     dError("RPC %p, req:%s app:%p is ignored since dnode exiting", pMsg->handle, TMSG_INFO(msgType), pMsg->ahandle);
-    SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_DND_EXITING};
+    SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_DND_OFFLINE};
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
     return;
@@ -383,14 +381,19 @@ void dndCleanupTrans(SDnode *pDnode) {
   dInfo("dnode-transport is cleaned up");
 }
 
-void dndSendMsgToDnode(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pMsg) {
+int32_t dndSendReqToDnode(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pMsg) {
   STransMgmt *pMgmt = &pDnode->tmgmt;
-  if (pMgmt->clientRpc == NULL) return;
+  if (pMgmt->clientRpc == NULL) {
+    terrno = TSDB_CODE_DND_OFFLINE;
+    return -1;
+  }
+
   rpcSendRequest(pMgmt->clientRpc, pEpSet, pMsg, NULL);
+  return 0;
 }
 
-void dndSendMsgToMnode(SDnode *pDnode, SRpcMsg *pMsg) {
+int32_t dndSendReqToMnode(SDnode *pDnode, SRpcMsg *pMsg) {
   SEpSet epSet = {0};
   dndGetMnodeEpSet(pDnode, &epSet);
-  dndSendMsgToDnode(pDnode, &epSet, pMsg);
+  return dndSendReqToDnode(pDnode, &epSet, pMsg);
 }

source/dnode/mgmt/impl/src/dnode.c

@@ -14,8 +14,11 @@
  */
 
 #define _DEFAULT_SOURCE
+#include "dndBnode.h"
 #include "dndDnode.h"
 #include "dndMnode.h"
+#include "dndQnode.h"
+#include "dndSnode.h"
 #include "dndTransport.h"
 #include "dndVnodes.h"
 #include "sync.h"
@@ -200,6 +203,24 @@ SDnode *dndInit(SDnodeOpt *pOption) {
     return NULL;
   }
 
+  if (dndInitQnode(pDnode) != 0) {
+    dError("failed to init qnode");
+    dndCleanup(pDnode);
+    return NULL;
+  }
+
+  if (dndInitSnode(pDnode) != 0) {
+    dError("failed to init snode");
+    dndCleanup(pDnode);
+    return NULL;
+  }
+
+  if (dndInitBnode(pDnode) != 0) {
+    dError("failed to init bnode");
+    dndCleanup(pDnode);
+    return NULL;
+  }
+
   if (dndInitMnode(pDnode) != 0) {
     dError("failed to init mnode");
     dndCleanup(pDnode);
@@ -213,7 +234,7 @@ SDnode *dndInit(SDnodeOpt *pOption) {
   }
 
   dndSetStat(pDnode, DND_STAT_RUNNING);
-  dndSendStatusMsg(pDnode);
+  dndSendStatusReq(pDnode);
   dndReportStartup(pDnode, "TDengine", "initialized successfully");
   dInfo("TDengine is initialized successfully, pDnode:%p", pDnode);
 
@@ -232,6 +253,9 @@ void dndCleanup(SDnode *pDnode) {
   dndSetStat(pDnode, DND_STAT_STOPPED);
   dndCleanupTrans(pDnode);
   dndCleanupMnode(pDnode);
+  dndCleanupBnode(pDnode);
+  dndCleanupSnode(pDnode);
+  dndCleanupQnode(pDnode);
   dndCleanupVnodes(pDnode);
   dndCleanupDnode(pDnode);
   vnodeClear();

source/dnode/mgmt/impl/test/CMakeLists.txt

 enable_testing()
 
+add_subdirectory(qnode)
+
 # add_subdirectory(auth)
 # add_subdirectory(balance)
 add_subdirectory(cluster)
@@ -7,9 +9,6 @@ add_subdirectory(db)
 add_subdirectory(dnode)
 # add_subdirectory(func)
 add_subdirectory(mnode)
-add_subdirectory(qnode)
-add_subdirectory(snode)
-add_subdirectory(bnode)
 add_subdirectory(profile)
 add_subdirectory(show)
 add_subdirectory(stb)

source/dnode/mgmt/impl/test/bnode/bnode.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestBnode : public ::testing::Test {
  public:
@@ -52,9 +52,9 @@ TEST_F(DndTestBnode, 01_ShowBnode) {
 
 TEST_F(DndTestBnode, 02_Create_Bnode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateBnodeMsg);
+    int32_t contLen = sizeof(SMCreateBnodeReq);
 
-    SMCreateBnodeMsg* pReq = (SMCreateBnodeMsg*)rpcMallocCont(contLen);
+    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(1);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_BNODE, pReq, contLen);
@@ -79,9 +79,9 @@ TEST_F(DndTestBnode, 02_Create_Bnode_Invalid_Id) {
 
 TEST_F(DndTestBnode, 03_Create_Bnode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateBnodeMsg);
+    int32_t contLen = sizeof(SMCreateBnodeReq);
 
-    SMCreateBnodeMsg* pReq = (SMCreateBnodeMsg*)rpcMallocCont(contLen);
+    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_BNODE, pReq, contLen);
@@ -111,9 +111,9 @@ TEST_F(DndTestBnode, 04_Create_Bnode) {
 
   {
     // create bnode
-    int32_t contLen = sizeof(SMCreateBnodeMsg);
+    int32_t contLen = sizeof(SMCreateBnodeReq);
 
-    SMCreateBnodeMsg* pReq = (SMCreateBnodeMsg*)rpcMallocCont(contLen);
+    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_BNODE, pReq, contLen);
@@ -134,9 +134,9 @@ TEST_F(DndTestBnode, 04_Create_Bnode) {
 
   {
     // drop bnode
-    int32_t contLen = sizeof(SMDropBnodeMsg);
+    int32_t contLen = sizeof(SMDropBnodeReq);
 
-    SMDropBnodeMsg* pReq = (SMDropBnodeMsg*)rpcMallocCont(contLen);
+    SMDropBnodeReq* pReq = (SMDropBnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_BNODE, pReq, contLen);

source/dnode/mgmt/impl/test/cluster/cluster.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestCluster : public ::testing::Test {
  protected:

source/dnode/mgmt/impl/test/db/db.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestDb : public ::testing::Test {
  protected:

source/dnode/mgmt/impl/test/dnode/dnode.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestDnode : public ::testing::Test {
  public:

source/dnode/mgmt/impl/test/mnode/mnode.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestMnode : public ::testing::Test {
  public:

source/dnode/mgmt/impl/test/profile/profile.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestProfile : public ::testing::Test {
  protected:

source/dnode/mgmt/impl/test/qnode/CMakeLists.txt

-aux_source_directory(. QTEST_SRC)
-add_executable(dnode_test_qnode ${QTEST_SRC})
+aux_source_directory(. DQTEST_SRC)
+add_executable(dnode_test_qnode ${DQTEST_SRC})
 target_link_libraries(
     dnode_test_qnode
     PUBLIC sut

source/dnode/mgmt/impl/test/qnode/dqnode.cpp

+/**
+ * @file dqnode.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module qnode tests
+ * @version 1.0
+ * @date 2022-01-05
+ *
+ * @copyright Copyright (c) 2022
+ *
+ */
+
+#include "sut.h"
+
+class DndTestQnode : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_qnode", 9111); }
+  static void TearDownTestSuite() { test.Cleanup(); }
+
+  static Testbase test;
+
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+};
+
+Testbase DndTestQnode::test;
+
+TEST_F(DndTestQnode, 01_Create_Qnode_Invalid) {
+  {
+    int32_t contLen = sizeof(SDCreateQnodeReq);
+
+    SDCreateQnodeReq* pReq = (SDCreateQnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(2);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_DND_CREATE_QNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, TSDB_CODE_DND_QNODE_ID_INVALID);
+  }
+
+  {
+    int32_t contLen = sizeof(SDCreateQnodeReq);
+
+    SDCreateQnodeReq* pReq = (SDCreateQnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(1);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_DND_CREATE_QNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  {
+    int32_t contLen = sizeof(SDCreateQnodeReq);
+
+    SDCreateQnodeReq* pReq = (SDCreateQnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(1);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_DND_CREATE_QNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, TSDB_CODE_DND_QNODE_ALREADY_DEPLOYED);
+  }
+
+  test.Restart();
+
+  {
+    int32_t contLen = sizeof(SDCreateQnodeReq);
+
+    SDCreateQnodeReq* pReq = (SDCreateQnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(1);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_DND_CREATE_QNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, TSDB_CODE_DND_QNODE_ALREADY_DEPLOYED);
+  }
+}
\ No newline at end of file

source/dnode/mgmt/impl/test/show/show.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestShow : public ::testing::Test {
  protected:

source/dnode/mgmt/impl/test/stb/stb.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestStb : public ::testing::Test {
  protected:

source/dnode/mgmt/impl/test/sut/src/client.cpp

@@ -13,7 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "base.h"
+#include "sut.h"
 
 static void processClientRsp(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
   TestClient* client = (TestClient*)parent;

source/dnode/mgmt/impl/test/sut/src/server.cpp

@@ -13,7 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "base.h"
+#include "sut.h"
 
 void* serverLoop(void* param) {
   while (1) {

source/dnode/mgmt/impl/test/sut/src/base.cpp → source/dnode/mgmt/impl/test/sut/src/sut.cpp

@@ -13,7 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "base.h"
+#include "sut.h"
 
 void Testbase::InitLog(const char* path) {
   dDebugFlag = 0;

source/dnode/mgmt/impl/test/vgroup/vgroup.cpp

@@ -9,7 +9,7 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
 class DndTestVgroup : public ::testing::Test {
  protected:

source/dnode/mnode/impl/inc/mndInt.h

@@ -91,15 +91,16 @@ typedef struct SMnode {
   STelemMgmt        telemMgmt;
   SSyncMgmt         syncMgmt;
   MndMsgFp          msgFp[TDMT_MAX];
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
+  PutReqToMWriteQFp putReqToMWriteQFp;
 } SMnode;
 
-void mndSendMsgToDnode(SMnode *pMnode, SEpSet *pEpSet, SRpcMsg *rpcMsg);
-void mndSendMsgToMnode(SMnode *pMnode, SRpcMsg *pMsg);
-void mndSendRedirectMsg(SMnode *pMnode, SRpcMsg *pMsg);
-void mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp);
+int32_t mndSendReqToDnode(SMnode *pMnode, SEpSet *pEpSet, SRpcMsg *rpcMsg);
+int32_t mndSendReqToMnode(SMnode *pMnode, SRpcMsg *pMsg);
+void    mndSendRedirectRsp(SMnode *pMnode, SRpcMsg *pMsg);
+void    mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp);
 
 uint64_t mndGenerateUid(char *name, int32_t len) ;
 

source/dnode/mnode/impl/inc/mndTrans.h

@@ -45,6 +45,7 @@ int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction);
 
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
 void    mndTransProcessRsp(SMnodeMsg *pMsg);
+void    mndTransPullup(SMnode *pMnode);
 
 #ifdef __cplusplus
 }

source/dnode/mnode/impl/src/mndAcct.c

@@ -25,10 +25,10 @@ static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct);
 static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw);
 static int32_t  mndAcctActionInsert(SSdb *pSdb, SAcctObj *pAcct);
 static int32_t  mndAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct);
-static int32_t  mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOldAcct, SAcctObj *pNewAcct);
-static int32_t  mndProcessCreateAcctMsg(SMnodeMsg *pMnodeMsg);
-static int32_t  mndProcessAlterAcctMsg(SMnodeMsg *pMnodeMsg);
-static int32_t  mndProcessDropAcctMsg(SMnodeMsg *pMnodeMsg);
+static int32_t  mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOld, SAcctObj *pNew);
+static int32_t  mndProcessCreateAcctReq(SMnodeMsg *pMsg);
+static int32_t  mndProcessAlterAcctReq(SMnodeMsg *pMsg);
+static int32_t  mndProcessDropAcctReq(SMnodeMsg *pMsg);
 
 int32_t mndInitAcct(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_ACCT,
@@ -40,9 +40,9 @@ int32_t mndInitAcct(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndAcctActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndAcctActionDelete};
 
-  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_ACCT, mndProcessCreateAcctMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_ACCT, mndProcessAlterAcctMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_DROP_ACCT, mndProcessDropAcctMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_ACCT, mndProcessCreateAcctReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_ACCT, mndProcessAlterAcctReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_ACCT, mndProcessDropAcctReq);
 
   return sdbSetTable(pMnode->pSdb, table);
 }
@@ -176,29 +176,29 @@ static int32_t mndAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct) {
   return 0;
 }
 
-static int32_t mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOldAcct, SAcctObj *pNewAcct) {
-  mTrace("acct:%s, perform update action, old_row:%p new_row:%p", pOldAcct->acct, pOldAcct, pNewAcct);
+static int32_t mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOld, SAcctObj *pNew) {
+  mTrace("acct:%s, perform update action, old_row:%p new_row:%p", pOld->acct, pOld, pNew);
 
-  pOldAcct->updateTime = pNewAcct->updateTime;
-  pOldAcct->status = pNewAcct->status;
-  memcpy(&pOldAcct->cfg, &pNewAcct->cfg, sizeof(SAcctCfg));
+  pOld->updateTime = pNew->updateTime;
+  pOld->status = pNew->status;
+  memcpy(&pOld->cfg, &pNew->cfg, sizeof(SAcctCfg));
   return 0;
 }
 
-static int32_t mndProcessCreateAcctMsg(SMnodeMsg *pMnodeMsg) {
+static int32_t mndProcessCreateAcctReq(SMnodeMsg *pMsg) {
   terrno = TSDB_CODE_MND_MSG_NOT_PROCESSED;
-  mError("failed to process create acct msg since %s", terrstr());
+  mError("failed to process create acct request since %s", terrstr());
   return -1;
 }
 
-static int32_t mndProcessAlterAcctMsg(SMnodeMsg *pMnodeMsg) {
+static int32_t mndProcessAlterAcctReq(SMnodeMsg *pMsg) {
   terrno = TSDB_CODE_MND_MSG_NOT_PROCESSED;
-  mError("failed to process create acct msg since %s", terrstr());
+  mError("failed to process create acct request since %s", terrstr());
   return -1;
 }
 
-static int32_t mndProcessDropAcctMsg(SMnodeMsg *pMnodeMsg) {
+static int32_t mndProcessDropAcctReq(SMnodeMsg *pMsg) {
   terrno = TSDB_CODE_MND_MSG_NOT_PROCESSED;
-  mError("failed to process create acct msg since %s", terrstr());
+  mError("failed to process create acct request since %s", terrstr());
   return -1;
 }
\ No newline at end of file

source/dnode/mnode/impl/src/mndBnode.c

@@ -178,7 +178,7 @@ static int32_t mndSetCreateBnodeCommitLogs(STrans *pTrans, SBnodeObj *pObj) {
 }
 
 static int32_t mndSetCreateBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBnodeObj *pObj) {
-  SDCreateBnodeMsg *pMsg = malloc(sizeof(SDCreateBnodeMsg));
+  SDCreateBnodeReq *pMsg = malloc(sizeof(SDCreateBnodeReq));
   if (pMsg == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -188,7 +188,7 @@ static int32_t mndSetCreateBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
   action.pCont = pMsg;
-  action.contLen = sizeof(SDCreateBnodeMsg);
+  action.contLen = sizeof(SDCreateBnodeReq);
   action.msgType = TDMT_DND_CREATE_BNODE;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
@@ -199,7 +199,7 @@ static int32_t mndSetCreateBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   return 0;
 }
 
-static int32_t mndCreateBnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SMCreateBnodeMsg *pCreate) {
+static int32_t mndCreateBnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SMCreateBnodeReq *pCreate) {
   SBnodeObj bnodeObj = {0};
   bnodeObj.id = pDnode->id;
   bnodeObj.createdTime = taosGetTimestampMs();
@@ -242,7 +242,7 @@ CREATE_BNODE_OVER:
 
 static int32_t mndProcessCreateBnodeReq(SMnodeMsg *pMsg) {
   SMnode           *pMnode = pMsg->pMnode;
-  SMCreateBnodeMsg *pCreate = pMsg->rpcMsg.pCont;
+  SMCreateBnodeReq *pCreate = pMsg->rpcMsg.pCont;
 
   pCreate->dnodeId = htonl(pCreate->dnodeId);
 
@@ -290,7 +290,7 @@ static int32_t mndSetDropBnodeCommitLogs(STrans *pTrans, SBnodeObj *pObj) {
 }
 
 static int32_t mndSetDropBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBnodeObj *pObj) {
-  SDDropBnodeMsg *pMsg = malloc(sizeof(SDDropBnodeMsg));
+  SDDropBnodeReq *pMsg = malloc(sizeof(SDDropBnodeReq));
   if (pMsg == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -300,7 +300,7 @@ static int32_t mndSetDropBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBn
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
   action.pCont = pMsg;
-  action.contLen = sizeof(SDDropBnodeMsg);
+  action.contLen = sizeof(SDDropBnodeReq);
   action.msgType = TDMT_DND_DROP_BNODE;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
@@ -350,7 +350,7 @@ DROP_BNODE_OVER:
 
 static int32_t mndProcessDropBnodeReq(SMnodeMsg *pMsg) {
   SMnode         *pMnode = pMsg->pMnode;
-  SMDropBnodeMsg *pDrop = pMsg->rpcMsg.pCont;
+  SMDropBnodeReq *pDrop = pMsg->rpcMsg.pCont;
   pDrop->dnodeId = htonl(pDrop->dnodeId);
 
   mDebug("bnode:%d, start to drop", pDrop->dnodeId);

source/dnode/mnode/impl/src/mndDnode.c

@@ -557,7 +557,7 @@ static int32_t mndProcessConfigDnodeMsg(SMnodeMsg *pMsg) {
                     .ahandle = pMsg->rpcMsg.ahandle};
 
   mInfo("dnode:%d, app:%p config:%s req send to dnode", pCfg->dnodeId, rpcMsg.ahandle, pCfg->config);
-  mndSendMsgToDnode(pMnode, &epSet, &rpcMsg);
+  mndSendReqToDnode(pMnode, &epSet, &rpcMsg);
 
   return 0;
 }

source/dnode/mnode/impl/src/mndQnode.c

@@ -178,7 +178,7 @@ static int32_t mndSetCreateQnodeCommitLogs(STrans *pTrans, SQnodeObj *pObj) {
 }
 
 static int32_t mndSetCreateQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQnodeObj *pObj) {
-  SDCreateQnodeMsg *pMsg = malloc(sizeof(SDCreateQnodeMsg));
+  SDCreateQnodeReq *pMsg = malloc(sizeof(SDCreateQnodeReq));
   if (pMsg == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -188,7 +188,7 @@ static int32_t mndSetCreateQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
   action.pCont = pMsg;
-  action.contLen = sizeof(SDCreateQnodeMsg);
+  action.contLen = sizeof(SDCreateQnodeReq);
   action.msgType = TDMT_DND_CREATE_QNODE;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
@@ -199,7 +199,7 @@ static int32_t mndSetCreateQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   return 0;
 }
 
-static int32_t mndCreateQnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SMCreateQnodeMsg *pCreate) {
+static int32_t mndCreateQnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SMCreateQnodeReq *pCreate) {
   SQnodeObj qnodeObj = {0};
   qnodeObj.id = pDnode->id;
   qnodeObj.createdTime = taosGetTimestampMs();
@@ -242,7 +242,7 @@ CREATE_QNODE_OVER:
 
 static int32_t mndProcessCreateQnodeReq(SMnodeMsg *pMsg) {
   SMnode           *pMnode = pMsg->pMnode;
-  SMCreateQnodeMsg *pCreate = pMsg->rpcMsg.pCont;
+  SMCreateQnodeReq *pCreate = pMsg->rpcMsg.pCont;
 
   pCreate->dnodeId = htonl(pCreate->dnodeId);
 
@@ -290,7 +290,7 @@ static int32_t mndSetDropQnodeCommitLogs(STrans *pTrans, SQnodeObj *pObj) {
 }
 
 static int32_t mndSetDropQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQnodeObj *pObj) {
-  SDDropQnodeMsg *pMsg = malloc(sizeof(SDDropQnodeMsg));
+  SDDropQnodeReq *pMsg = malloc(sizeof(SDDropQnodeReq));
   if (pMsg == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -300,7 +300,7 @@ static int32_t mndSetDropQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQn
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
   action.pCont = pMsg;
-  action.contLen = sizeof(SDDropQnodeMsg);
+  action.contLen = sizeof(SDDropQnodeReq);
   action.msgType = TDMT_DND_DROP_QNODE;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
@@ -350,7 +350,7 @@ DROP_QNODE_OVER:
 
 static int32_t mndProcessDropQnodeReq(SMnodeMsg *pMsg) {
   SMnode         *pMnode = pMsg->pMnode;
-  SMDropQnodeMsg *pDrop = pMsg->rpcMsg.pCont;
+  SMDropQnodeReq *pDrop = pMsg->rpcMsg.pCont;
   pDrop->dnodeId = htonl(pDrop->dnodeId);
 
   mDebug("qnode:%d, start to drop", pDrop->dnodeId);

source/dnode/mnode/impl/src/mndSnode.c

@@ -178,7 +178,7 @@ static int32_t mndSetCreateSnodeCommitLogs(STrans *pTrans, SSnodeObj *pObj) {
 }
 
 static int32_t mndSetCreateSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SSnodeObj *pObj) {
-  SDCreateSnodeMsg *pMsg = malloc(sizeof(SDCreateSnodeMsg));
+  SDCreateSnodeReq *pMsg = malloc(sizeof(SDCreateSnodeReq));
   if (pMsg == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -188,7 +188,7 @@ static int32_t mndSetCreateSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
   action.pCont = pMsg;
-  action.contLen = sizeof(SDCreateSnodeMsg);
+  action.contLen = sizeof(SDCreateSnodeReq);
   action.msgType = TDMT_DND_CREATE_SNODE;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
@@ -199,7 +199,7 @@ static int32_t mndSetCreateSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   return 0;
 }
 
-static int32_t mndCreateSnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SMCreateSnodeMsg *pCreate) {
+static int32_t mndCreateSnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SMCreateSnodeReq *pCreate) {
   SSnodeObj snodeObj = {0};
   snodeObj.id = pDnode->id;
   snodeObj.createdTime = taosGetTimestampMs();
@@ -242,7 +242,7 @@ CREATE_SNODE_OVER:
 
 static int32_t mndProcessCreateSnodeReq(SMnodeMsg *pMsg) {
   SMnode           *pMnode = pMsg->pMnode;
-  SMCreateSnodeMsg *pCreate = pMsg->rpcMsg.pCont;
+  SMCreateSnodeReq *pCreate = pMsg->rpcMsg.pCont;
 
   pCreate->dnodeId = htonl(pCreate->dnodeId);
 
@@ -290,7 +290,7 @@ static int32_t mndSetDropSnodeCommitLogs(STrans *pTrans, SSnodeObj *pObj) {
 }
 
 static int32_t mndSetDropSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SSnodeObj *pObj) {
-  SDDropSnodeMsg *pMsg = malloc(sizeof(SDDropSnodeMsg));
+  SDDropSnodeReq *pMsg = malloc(sizeof(SDDropSnodeReq));
   if (pMsg == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -300,7 +300,7 @@ static int32_t mndSetDropSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SSn
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
   action.pCont = pMsg;
-  action.contLen = sizeof(SDDropSnodeMsg);
+  action.contLen = sizeof(SDDropSnodeReq);
   action.msgType = TDMT_DND_DROP_SNODE;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
@@ -350,7 +350,7 @@ DROP_SNODE_OVER:
 
 static int32_t mndProcessDropSnodeReq(SMnodeMsg *pMsg) {
   SMnode         *pMnode = pMsg->pMnode;
-  SMDropSnodeMsg *pDrop = pMsg->rpcMsg.pCont;
+  SMDropSnodeReq *pDrop = pMsg->rpcMsg.pCont;
   pDrop->dnodeId = htonl(pDrop->dnodeId);
 
   mDebug("snode:%d, start to drop", pDrop->dnodeId);

source/dnode/mnode/impl/src/mndSync.c

@@ -83,6 +83,8 @@ static int32_t mndRestoreWal(SMnode *pMnode) {
   int64_t sdbVer = sdbUpdateVer(pSdb, 0);
   mDebug("restore sdb wal finished, sdb ver:%" PRId64, sdbVer);
 
+  mndTransPullup(pMnode);
+
   if (walBeginSnapshot(pWal, sdbVer) < 0) {
     goto WAL_RESTORE_OVER;
   }

source/dnode/mnode/impl/src/mndTrans.c

@@ -52,7 +52,6 @@ static bool    mndTransPerfromFinishedStage(SMnode *pMnode, STrans *pTrans);
 static void    mndTransExecute(SMnode *pMnode, STrans *pTrans);
 static void    mndTransSendRpcRsp(STrans *pTrans);
 static int32_t mndProcessTransMsg(SMnodeMsg *pMsg);
-static int32_t mndProcessTransRsp(SMnodeMsg *pMsg);
 
 int32_t mndInitTrans(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_TRANS,
@@ -64,7 +63,6 @@ int32_t mndInitTrans(SMnode *pMnode) {
                      .deleteFp = (SdbDeleteFp)mndTransActionDelete};
 
   mndSetMsgHandle(pMnode, TDMT_MND_TRANS, mndProcessTransMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_TRANS_RSP, mndProcessTransRsp);
   return sdbSetTable(pMnode->pSdb, table);
 }
 
@@ -615,12 +613,15 @@ static int32_t mndTransSendActionMsg(SMnode *pMnode, STrans *pTrans, SArray *pAr
     }
     memcpy(rpcMsg.pCont, pAction->pCont, pAction->contLen);
 
-    pAction->msgSent = 1;
-    pAction->msgReceived = 0;
-    pAction->errCode = 0;
-
-    mDebug("trans:%d, action:%d is sent", pTrans->id, action);
-    mndSendMsgToDnode(pMnode, &pAction->epSet, &rpcMsg);
+    if (mndSendReqToDnode(pMnode, &pAction->epSet, &rpcMsg) == 0) {
+      mDebug("trans:%d, action:%d is sent", pTrans->id, action);
+      pAction->msgSent = 1;
+      pAction->msgReceived = 0;
+      pAction->errCode = 0;
+    } else {
+      mDebug("trans:%d, action:%d not sent since %s", pTrans->id, action, terrstr());
+      return -1;
+    }
   }
 
   return 0;
@@ -885,7 +886,11 @@ static void mndTransExecute(SMnode *pMnode, STrans *pTrans) {
 }
 
 static int32_t mndProcessTransMsg(SMnodeMsg *pMsg) {
-  SMnode *pMnode = pMsg->pMnode;
+  mndTransPullup(pMsg->pMnode);
+  return 0;
+}
+
+void mndTransPullup(SMnode *pMnode) {
   STrans *pTrans = NULL;
   void   *pIter = NULL;
 
@@ -897,5 +902,3 @@ static int32_t mndProcessTransMsg(SMnodeMsg *pMsg) {
     sdbRelease(pMnode->pSdb, pTrans);
   }
 }
-
-static int32_t mndProcessTransRsp(SMnodeMsg *pMsg) { return 0; }
\ No newline at end of file

source/dnode/mnode/impl/src/mndUser.c

@@ -28,11 +28,11 @@ static SSdbRaw *mndUserActionEncode(SUserObj *pUser);
 static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw);
 static int32_t  mndUserActionInsert(SSdb *pSdb, SUserObj *pUser);
 static int32_t  mndUserActionDelete(SSdb *pSdb, SUserObj *pUser);
-static int32_t  mndUserActionUpdate(SSdb *pSdb, SUserObj *pOldUser, SUserObj *pNewUser);
+static int32_t  mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew);
 static int32_t  mndCreateUser(SMnode *pMnode, char *acct, char *user, char *pass, SMnodeMsg *pMsg);
-static int32_t  mndProcessCreateUserMsg(SMnodeMsg *pMsg);
-static int32_t  mndProcessAlterUserMsg(SMnodeMsg *pMsg);
-static int32_t  mndProcessDropUserMsg(SMnodeMsg *pMsg);
+static int32_t  mndProcessCreateUserReq(SMnodeMsg *pMsg);
+static int32_t  mndProcessAlterUserReq(SMnodeMsg *pMsg);
+static int32_t  mndProcessDropUserReq(SMnodeMsg *pMsg);
 static int32_t  mndGetUserMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
 static int32_t  mndRetrieveUsers(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextUser(SMnode *pMnode, void *pIter);
@@ -47,9 +47,9 @@ int32_t mndInitUser(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndUserActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndUserActionDelete};
 
-  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_USER, mndProcessCreateUserMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_USER, mndProcessAlterUserMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_DROP_USER, mndProcessDropUserMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_USER, mndProcessCreateUserReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_USER, mndProcessAlterUserReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_USER, mndProcessDropUserReq);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_USER, mndGetUserMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_USER, mndRetrieveUsers);
@@ -192,10 +192,10 @@ static int32_t mndUserActionDelete(SSdb *pSdb, SUserObj *pUser) {
   return 0;
 }
 
-static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOldUser, SUserObj *pNewUser) {
-  mTrace("user:%s, perform update action, old_row:%p new_row:%p", pOldUser->user, pOldUser, pNewUser);
-  memcpy(pOldUser->pass, pNewUser->pass, TSDB_PASSWORD_LEN);
-  pOldUser->updateTime = pNewUser->updateTime;
+static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew) {
+  mTrace("user:%s, perform update action, old_row:%p new_row:%p", pOld->user, pOld, pNew);
+  memcpy(pOld->pass, pNew->pass, TSDB_PASSWORD_LEN);
+  pOld->updateTime = pNew->updateTime;
   return 0;
 }
 
@@ -247,9 +247,9 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, char *user, char *pass,
   return 0;
 }
 
-static int32_t mndProcessCreateUserMsg(SMnodeMsg *pMsg) {
+static int32_t mndProcessCreateUserReq(SMnodeMsg *pMsg) {
   SMnode         *pMnode = pMsg->pMnode;
-  SCreateUserMsg *pCreate = pMsg->rpcMsg.pCont;
+  SCreateUserReq *pCreate = pMsg->rpcMsg.pCont;
 
   mDebug("user:%s, start to create", pCreate->user);
 
@@ -291,15 +291,15 @@ static int32_t mndProcessCreateUserMsg(SMnodeMsg *pMsg) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
-static int32_t mndUpdateUser(SMnode *pMnode, SUserObj *pOldUser, SUserObj *pNewUser, SMnodeMsg *pMsg) {
+static int32_t mndUpdateUser(SMnode *pMnode, SUserObj *pOld, SUserObj *pNew, SMnodeMsg *pMsg) {
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pMsg->rpcMsg);
   if (pTrans == NULL) {
-    mError("user:%s, failed to update since %s", pOldUser->user, terrstr());
+    mError("user:%s, failed to update since %s", pOld->user, terrstr());
     return -1;
   }
-  mDebug("trans:%d, used to update user:%s", pTrans->id, pOldUser->user);
+  mDebug("trans:%d, used to update user:%s", pTrans->id, pOld->user);
 
-  SSdbRaw *pRedoRaw = mndUserActionEncode(pNewUser);
+  SSdbRaw *pRedoRaw = mndUserActionEncode(pNew);
   if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
     mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
@@ -317,9 +317,9 @@ static int32_t mndUpdateUser(SMnode *pMnode, SUserObj *pOldUser, SUserObj *pNewU
   return 0;
 }
 
-static int32_t mndProcessAlterUserMsg(SMnodeMsg *pMsg) {
+static int32_t mndProcessAlterUserReq(SMnodeMsg *pMsg) {
   SMnode        *pMnode = pMsg->pMnode;
-  SAlterUserMsg *pAlter = pMsg->rpcMsg.pCont;
+  SAlterUserReq *pAlter = pMsg->rpcMsg.pCont;
 
   mDebug("user:%s, start to alter", pAlter->user);
 
@@ -394,9 +394,9 @@ static int32_t mndDropUser(SMnode *pMnode, SMnodeMsg *pMsg, SUserObj *pUser) {
   return 0;
 }
 
-static int32_t mndProcessDropUserMsg(SMnodeMsg *pMsg) {
+static int32_t mndProcessDropUserReq(SMnodeMsg *pMsg) {
   SMnode       *pMnode = pMsg->pMnode;
-  SDropUserMsg *pDrop = pMsg->rpcMsg.pCont;
+  SDropUserReq *pDrop = pMsg->rpcMsg.pCont;
 
   mDebug("user:%s, start to drop", pDrop->user);
 

source/dnode/mnode/impl/src/mnode.c

@@ -34,21 +34,27 @@
 #include "mndUser.h"
 #include "mndVgroup.h"
 
-void mndSendMsgToDnode(SMnode *pMnode, SEpSet *pEpSet, SRpcMsg *pMsg) {
-  if (pMnode != NULL && pMnode->sendMsgToDnodeFp != NULL) {
-    (*pMnode->sendMsgToDnodeFp)(pMnode->pDnode, pEpSet, pMsg);
+int32_t mndSendReqToDnode(SMnode *pMnode, SEpSet *pEpSet, SRpcMsg *pMsg) {
+  if (pMnode == NULL || pMnode->sendReqToDnodeFp == NULL) {
+    terrno = TSDB_CODE_MND_NOT_READY;
+    return -1;
   }
+
+  return (*pMnode->sendReqToDnodeFp)(pMnode->pDnode, pEpSet, pMsg);
 }
 
-void mndSendMsgToMnode(SMnode *pMnode, SRpcMsg *pMsg) {
-  if (pMnode != NULL && pMnode->sendMsgToMnodeFp != NULL) {
-    (*pMnode->sendMsgToMnodeFp)(pMnode->pDnode, pMsg);
+int32_t mndSendReqToMnode(SMnode *pMnode, SRpcMsg *pMsg) {
+  if (pMnode == NULL || pMnode->sendReqToDnodeFp == NULL) {
+    terrno = TSDB_CODE_MND_NOT_READY;
+    return -1;
   }
+
+  return (*pMnode->sendReqToMnodeFp)(pMnode->pDnode, pMsg);
 }
 
-void mndSendRedirectMsg(SMnode *pMnode, SRpcMsg *pMsg) {
-  if (pMnode != NULL && pMnode->sendRedirectMsgFp != NULL) {
-    (*pMnode->sendRedirectMsgFp)(pMnode->pDnode, pMsg);
+void mndSendRedirectRsp(SMnode *pMnode, SRpcMsg *pMsg) {
+  if (pMnode != NULL && pMnode->sendRedirectRspFp != NULL) {
+    (*pMnode->sendRedirectRspFp)(pMnode->pDnode, pMsg);
   }
 }
 
@@ -56,11 +62,8 @@ static void mndTransReExecute(void *param, void *tmrId) {
   SMnode *pMnode = param;
   if (mndIsMaster(pMnode)) {
     STransMsg *pMsg = rpcMallocCont(sizeof(STransMsg));
-    SEpSet     epSet = {.inUse = 0, .numOfEps = 1};
-    epSet.port[0] = pMnode->replicas[pMnode->selfIndex].port;
-    memcpy(epSet.fqdn[0], pMnode->replicas[pMnode->selfIndex].fqdn, TSDB_FQDN_LEN);
-    SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRANS, .pCont = pMsg, .contLen = sizeof(STransMsg)};
-    mndSendMsgToDnode(pMnode, &epSet, &rpcMsg);
+    SRpcMsg    rpcMsg = {.msgType = TDMT_MND_TRANS, .pCont = pMsg, .contLen = sizeof(STransMsg)};
+    pMnode->putReqToMWriteQFp(pMnode->pDnode, &rpcMsg);
   }
 
   taosTmrReset(mndTransReExecute, 3000, pMnode, pMnode->timer, &pMnode->transTimer);
@@ -76,7 +79,7 @@ static int32_t mndInitTimer(SMnode *pMnode) {
     return -1;
   }
 
-  if (taosTmrReset(mndTransReExecute, 1000, pMnode, pMnode->timer, &pMnode->transTimer)) {
+  if (taosTmrReset(mndTransReExecute, 6000, pMnode, pMnode->timer, &pMnode->transTimer)) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -223,9 +226,10 @@ static int32_t mndSetOptions(SMnode *pMnode, const SMnodeOpt *pOption) {
   pMnode->selfIndex = pOption->selfIndex;
   memcpy(&pMnode->replicas, pOption->replicas, sizeof(SReplica) * TSDB_MAX_REPLICA);
   pMnode->pDnode = pOption->pDnode;
-  pMnode->sendMsgToDnodeFp = pOption->sendMsgToDnodeFp;
-  pMnode->sendMsgToMnodeFp = pOption->sendMsgToMnodeFp;
-  pMnode->sendRedirectMsgFp = pOption->sendRedirectMsgFp;
+  pMnode->putReqToMWriteQFp = pOption->putReqToMWriteQFp;
+  pMnode->sendReqToDnodeFp = pOption->sendReqToDnodeFp;
+  pMnode->sendReqToMnodeFp = pOption->sendReqToMnodeFp;
+  pMnode->sendRedirectRspFp = pOption->sendRedirectRspFp;
   pMnode->cfg.sver = pOption->cfg.sver;
   pMnode->cfg.enableTelem = pOption->cfg.enableTelem;
   pMnode->cfg.statusInterval = pOption->cfg.statusInterval;
@@ -236,8 +240,9 @@ static int32_t mndSetOptions(SMnode *pMnode, const SMnodeOpt *pOption) {
   pMnode->cfg.gitinfo = strdup(pOption->cfg.gitinfo);
   pMnode->cfg.buildinfo = strdup(pOption->cfg.buildinfo);
 
-  if (pMnode->sendMsgToDnodeFp == NULL || pMnode->sendMsgToMnodeFp == NULL || pMnode->sendRedirectMsgFp == NULL ||
-      pMnode->dnodeId < 0 || pMnode->clusterId < 0 || pMnode->cfg.statusInterval < 1) {
+  if (pMnode->sendReqToDnodeFp == NULL || pMnode->sendReqToMnodeFp == NULL || pMnode->sendRedirectRspFp == NULL ||
+      pMnode->putReqToMWriteQFp == NULL || pMnode->dnodeId < 0 || pMnode->clusterId < 0 ||
+      pMnode->cfg.statusInterval < 1) {
     terrno = TSDB_CODE_MND_INVALID_OPTIONS;
     return -1;
   }
@@ -433,7 +438,7 @@ void mndProcessMsg(SMnodeMsg *pMsg) {
 PROCESS_RPC_END:
   if (isReq) {
     if (code == TSDB_CODE_APP_NOT_READY) {
-      mndSendRedirectMsg(pMnode, &pMsg->rpcMsg);
+      mndSendRedirectRsp(pMnode, &pMsg->rpcMsg);
     } else if (code != 0) {
       SRpcMsg rpcRsp = {.handle = pMsg->rpcMsg.handle, .code = code};
       rpcSendResponse(&rpcRsp);

source/dnode/mnode/impl/test/CMakeLists.txt

 enable_testing()
 
-add_subdirectory(acct)
 add_subdirectory(user)
+add_subdirectory(acct)
 add_subdirectory(trans)
+add_subdirectory(qnode)
+add_subdirectory(snode)
+add_subdirectory(bnode)
+

source/dnode/mnode/impl/test/acct/acct.cpp

@@ -3,15 +3,15 @@
  * @author slguan (slguan@taosdata.com)
  * @brief MNODE module acct tests
  * @version 1.0
- * @date 2021-12-15
+ * @date 2022-01-04
  *
  * @copyright Copyright (c) 2022
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
-class DndTestAcct : public ::testing::Test {
+class MndTestAcct : public ::testing::Test {
  protected:
   static void SetUpTestSuite() { test.Init("/tmp/mnode_test_acct", 9012); }
   static void TearDownTestSuite() { test.Cleanup(); }
@@ -23,39 +23,39 @@ class DndTestAcct : public ::testing::Test {
   void TearDown() override {}
 };
 
-Testbase DndTestAcct::test;
+Testbase MndTestAcct::test;
 
-TEST_F(DndTestAcct, 01_CreateAcct) {
-  int32_t contLen = sizeof(SCreateAcctMsg);
+TEST_F(MndTestAcct, 01_Create_Acct) {
+  int32_t contLen = sizeof(SCreateAcctReq);
 
-  SCreateAcctMsg* pReq = (SCreateAcctMsg*)rpcMallocCont(contLen);
+  SCreateAcctReq* pReq = (SCreateAcctReq*)rpcMallocCont(contLen);
 
   SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
-TEST_F(DndTestAcct, 02_AlterAcct) {
-  int32_t contLen = sizeof(SCreateAcctMsg);
+TEST_F(MndTestAcct, 02_Alter_Acct) {
+  int32_t contLen = sizeof(SCreateAcctReq);
 
-  SAlterAcctMsg* pReq = (SAlterAcctMsg*)rpcMallocCont(contLen);
+  SAlterAcctReq* pReq = (SAlterAcctReq*)rpcMallocCont(contLen);
 
   SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
-TEST_F(DndTestAcct, 03_DropAcct) {
-  int32_t contLen = sizeof(SDropAcctMsg);
+TEST_F(MndTestAcct, 03_Drop_Acct) {
+  int32_t contLen = sizeof(SDropAcctReq);
 
-  SDropAcctMsg* pReq = (SDropAcctMsg*)rpcMallocCont(contLen);
+  SDropAcctReq* pReq = (SDropAcctReq*)rpcMallocCont(contLen);
 
   SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
-TEST_F(DndTestAcct, 04_ShowAcct) {
+TEST_F(MndTestAcct, 04_Show_Acct) {
   int32_t contLen = sizeof(SShowMsg);
 
   SShowMsg* pReq = (SShowMsg*)rpcMallocCont(contLen);

source/dnode/mgmt/impl/test/bnode/CMakeLists.txt → source/dnode/mnode/impl/test/bnode/CMakeLists.txt

 aux_source_directory(. STEST_SRC)
-add_executable(dnode_test_bnode ${STEST_SRC})
+add_executable(mnode_test_bnode ${STEST_SRC})
 target_link_libraries(
-    dnode_test_bnode
+    mnode_test_bnode
     PUBLIC sut
 )
 
 add_test(
-    NAME dnode_test_bnode
-    COMMAND dnode_test_bnode
+    NAME mnode_test_bnode
+    COMMAND mnode_test_bnode
 )

source/dnode/mnode/impl/test/bnode/bnode.cpp

+/**
+ * @file bnode.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief MNODE module bnode tests
+ * @version 1.0
+ * @date 2022-01-05
+ *
+ * @copyright Copyright (c) 2022
+ *
+ */
+
+#include "sut.h"
+
+class MndTestBnode : public ::testing::Test {
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+
+ public:
+  static void SetUpTestSuite() {
+    test.Init("/tmp/mnode_test_bnode1", 9018);
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9018";
+
+    server2.Start("/tmp/mnode_test_bnode2", fqdn, 9019, firstEp);
+    taosMsleep(300);
+  }
+
+  static void TearDownTestSuite() {
+    server2.Stop();
+    test.Cleanup();
+  }
+
+  static Testbase   test;
+  static TestServer server2;
+};
+
+Testbase   MndTestBnode::test;
+TestServer MndTestBnode::server2;
+
+TEST_F(MndTestBnode, 01_Show_Bnode) {
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_BNODE, "");
+  CHECK_META("show bnodes", 3);
+
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 0);
+}
+
+TEST_F(MndTestBnode, 02_Create_Bnode_Invalid_Id) {
+  {
+    int32_t contLen = sizeof(SMCreateBnodeReq);
+
+    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(1);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_BNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    test.SendShowMetaMsg(TSDB_MGMT_TABLE_BNODE, "");
+    CHECK_META("show bnodes", 3);
+
+    CHECK_SCHEMA(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
+    CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint");
+    CHECK_SCHEMA(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+
+    test.SendShowRetrieveMsg();
+    EXPECT_EQ(test.GetShowRows(), 1);
+
+    CheckInt16(1);
+    CheckBinary("localhost:9018", TSDB_EP_LEN);
+    CheckTimestamp();
+  }
+}
+
+TEST_F(MndTestBnode, 03_Create_Bnode_Invalid_Id) {
+  {
+    int32_t contLen = sizeof(SMCreateBnodeReq);
+
+    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(2);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_BNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, TSDB_CODE_MND_DNODE_NOT_EXIST);
+  }
+}
+
+TEST_F(MndTestBnode, 04_Create_Bnode) {
+  {
+    // create dnode
+    int32_t contLen = sizeof(SCreateDnodeMsg);
+
+    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
+    strcpy(pReq->fqdn, "localhost");
+    pReq->port = htonl(9019);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    taosMsleep(1300);
+    test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "");
+    test.SendShowRetrieveMsg();
+    EXPECT_EQ(test.GetShowRows(), 2);
+  }
+
+  {
+    // create bnode
+    int32_t contLen = sizeof(SMCreateBnodeReq);
+
+    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(2);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_BNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    test.SendShowMetaMsg(TSDB_MGMT_TABLE_BNODE, "");
+    test.SendShowRetrieveMsg();
+    EXPECT_EQ(test.GetShowRows(), 2);
+
+    CheckInt16(1);
+    CheckInt16(2);
+    CheckBinary("localhost:9018", TSDB_EP_LEN);
+    CheckBinary("localhost:9019", TSDB_EP_LEN);
+    CheckTimestamp();
+    CheckTimestamp();
+  }
+
+  {
+    // drop bnode
+    int32_t contLen = sizeof(SMDropBnodeReq);
+
+    SMDropBnodeReq* pReq = (SMDropBnodeReq*)rpcMallocCont(contLen);
+    pReq->dnodeId = htonl(2);
+
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_BNODE, pReq, contLen);
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    test.SendShowMetaMsg(TSDB_MGMT_TABLE_BNODE, "");
+    test.SendShowRetrieveMsg();
+    EXPECT_EQ(test.GetShowRows(), 1);
+
+    CheckInt16(1);
+    CheckBinary("localhost:9018", TSDB_EP_LEN);
+    CheckTimestamp();
+  }
+}
\ No newline at end of file

source/dnode/mnode/impl/test/qnode/CMakeLists.txt

+aux_source_directory(. QTEST_SRC)
+add_executable(mnode_test_qnode ${QTEST_SRC})
+target_link_libraries(
+    mnode_test_qnode
+    PUBLIC sut
+)
+
+add_test(
+    NAME mnode_test_qnode
+    COMMAND mnode_test_qnode
+)

source/dnode/mgmt/impl/test/qnode/qnode.cpp → source/dnode/mnode/impl/test/qnode/qnode.cpp

 /**
- * @file dnode.cpp
+ * @file qnode.cpp
  * @author slguan (slguan@taosdata.com)
- * @brief DNODE module dnode-msg tests
- * @version 0.1
- * @date 2021-12-15
+ * @brief MNODE module qnode tests
+ * @version 1.0
+ * @date 2022-01-05
  *
- * @copyright Copyright (c) 2021
+ * @copyright Copyright (c) 2022
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
-class DndTestQnode : public ::testing::Test {
+class MndTestQnode : public ::testing::Test {
  public:
   void SetUp() override {}
   void TearDown() override {}
 
  public:
   static void SetUpTestSuite() {
-    test.Init("/tmp/dnode_test_qnode1", 9064);
+    test.Init("/tmp/mnode_test_qnode1", 9014);
     const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9064";
+    const char* firstEp = "localhost:9014";
 
-    server2.Start("/tmp/dnode_test_qnode2", fqdn, 9065, firstEp);
+    server2.Start("/tmp/mnode_test_qnode2", fqdn, 9015, firstEp);
     taosMsleep(300);
   }
 
@@ -35,10 +35,10 @@ class DndTestQnode : public ::testing::Test {
   static TestServer server2;
 };
 
-Testbase   DndTestQnode::test;
-TestServer DndTestQnode::server2;
+Testbase   MndTestQnode::test;
+TestServer MndTestQnode::server2;
 
-TEST_F(DndTestQnode, 01_ShowQnode) {
+TEST_F(MndTestQnode, 01_Show_Qnode) {
   test.SendShowMetaMsg(TSDB_MGMT_TABLE_QNODE, "");
   CHECK_META("show qnodes", 3);
 
@@ -50,11 +50,11 @@ TEST_F(DndTestQnode, 01_ShowQnode) {
   EXPECT_EQ(test.GetShowRows(), 0);
 }
 
-TEST_F(DndTestQnode, 02_Create_Qnode_Invalid_Id) {
+TEST_F(MndTestQnode, 02_Create_Qnode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateQnodeMsg);
+    int32_t contLen = sizeof(SMCreateQnodeReq);
 
-    SMCreateQnodeMsg* pReq = (SMCreateQnodeMsg*)rpcMallocCont(contLen);
+    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(1);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_QNODE, pReq, contLen);
@@ -72,16 +72,16 @@ TEST_F(DndTestQnode, 02_Create_Qnode_Invalid_Id) {
     EXPECT_EQ(test.GetShowRows(), 1);
 
     CheckInt16(1);
-    CheckBinary("localhost:9064", TSDB_EP_LEN);
+    CheckBinary("localhost:9014", TSDB_EP_LEN);
     CheckTimestamp();
   }
 }
 
-TEST_F(DndTestQnode, 03_Create_Qnode_Invalid_Id) {
+TEST_F(MndTestQnode, 03_Create_Qnode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateQnodeMsg);
+    int32_t contLen = sizeof(SMCreateQnodeReq);
 
-    SMCreateQnodeMsg* pReq = (SMCreateQnodeMsg*)rpcMallocCont(contLen);
+    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_QNODE, pReq, contLen);
@@ -90,14 +90,14 @@ TEST_F(DndTestQnode, 03_Create_Qnode_Invalid_Id) {
   }
 }
 
-TEST_F(DndTestQnode, 04_Create_Qnode) {
+TEST_F(MndTestQnode, 04_Create_Qnode) {
   {
     // create dnode
     int32_t contLen = sizeof(SCreateDnodeMsg);
 
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->fqdn, "localhost");
-    pReq->port = htonl(9065);
+    pReq->port = htonl(9015);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
@@ -111,9 +111,9 @@ TEST_F(DndTestQnode, 04_Create_Qnode) {
 
   {
     // create qnode
-    int32_t contLen = sizeof(SMCreateQnodeMsg);
+    int32_t contLen = sizeof(SMCreateQnodeReq);
 
-    SMCreateQnodeMsg* pReq = (SMCreateQnodeMsg*)rpcMallocCont(contLen);
+    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_QNODE, pReq, contLen);
@@ -126,17 +126,17 @@ TEST_F(DndTestQnode, 04_Create_Qnode) {
 
     CheckInt16(1);
     CheckInt16(2);
-    CheckBinary("localhost:9064", TSDB_EP_LEN);
-    CheckBinary("localhost:9065", TSDB_EP_LEN);
+    CheckBinary("localhost:9014", TSDB_EP_LEN);
+    CheckBinary("localhost:9015", TSDB_EP_LEN);
     CheckTimestamp();
     CheckTimestamp();
   }
 
   {
     // drop qnode
-    int32_t contLen = sizeof(SMDropQnodeMsg);
+    int32_t contLen = sizeof(SMDropQnodeReq);
 
-    SMDropQnodeMsg* pReq = (SMDropQnodeMsg*)rpcMallocCont(contLen);
+    SMDropQnodeReq* pReq = (SMDropQnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_QNODE, pReq, contLen);
@@ -148,7 +148,7 @@ TEST_F(DndTestQnode, 04_Create_Qnode) {
     EXPECT_EQ(test.GetShowRows(), 1);
 
     CheckInt16(1);
-    CheckBinary("localhost:9064", TSDB_EP_LEN);
+    CheckBinary("localhost:9014", TSDB_EP_LEN);
     CheckTimestamp();
   }
 }
\ No newline at end of file

source/dnode/mgmt/impl/test/snode/CMakeLists.txt → source/dnode/mnode/impl/test/snode/CMakeLists.txt

 aux_source_directory(. STEST_SRC)
-add_executable(dnode_test_snode ${STEST_SRC})
+add_executable(mnode_test_snode ${STEST_SRC})
 target_link_libraries(
-    dnode_test_snode
+    mnode_test_snode
     PUBLIC sut
 )
 
 add_test(
-    NAME dnode_test_snode
-    COMMAND dnode_test_snode
+    NAME mnode_test_snode
+    COMMAND mnode_test_snode
 )

source/dnode/mgmt/impl/test/snode/snode.cpp → source/dnode/mnode/impl/test/snode/snode.cpp

 /**
- * @file dnode.cpp
+ * @file snode.cpp
  * @author slguan (slguan@taosdata.com)
- * @brief DNODE module dnode-msg tests
- * @version 0.1
- * @date 2021-12-15
+ * @brief MNODE module snode tests
+ * @version 1.0
+ * @date 2022-01-05
  *
- * @copyright Copyright (c) 2021
+ * @copyright Copyright (c) 2022
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
-class DndTestSnode : public ::testing::Test {
+class MndTestSnode : public ::testing::Test {
  public:
   void SetUp() override {}
   void TearDown() override {}
 
  public:
   static void SetUpTestSuite() {
-    test.Init("/tmp/dnode_test_snode1", 9066);
+    test.Init("/tmp/mnode_test_snode1", 9016);
     const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9066";
+    const char* firstEp = "localhost:9016";
 
-    server2.Start("/tmp/dnode_test_snode2", fqdn, 9067, firstEp);
+    server2.Start("/tmp/mnode_test_snode2", fqdn, 9017, firstEp);
     taosMsleep(300);
   }
 
@@ -35,10 +35,10 @@ class DndTestSnode : public ::testing::Test {
   static TestServer server2;
 };
 
-Testbase   DndTestSnode::test;
-TestServer DndTestSnode::server2;
+Testbase   MndTestSnode::test;
+TestServer MndTestSnode::server2;
 
-TEST_F(DndTestSnode, 01_ShowSnode) {
+TEST_F(MndTestSnode, 01_Show_Snode) {
   test.SendShowMetaMsg(TSDB_MGMT_TABLE_SNODE, "");
   CHECK_META("show snodes", 3);
 
@@ -50,11 +50,11 @@ TEST_F(DndTestSnode, 01_ShowSnode) {
   EXPECT_EQ(test.GetShowRows(), 0);
 }
 
-TEST_F(DndTestSnode, 02_Create_Snode_Invalid_Id) {
+TEST_F(MndTestSnode, 02_Create_Snode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateSnodeMsg);
+    int32_t contLen = sizeof(SMCreateSnodeReq);
 
-    SMCreateSnodeMsg* pReq = (SMCreateSnodeMsg*)rpcMallocCont(contLen);
+    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(1);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_SNODE, pReq, contLen);
@@ -72,16 +72,16 @@ TEST_F(DndTestSnode, 02_Create_Snode_Invalid_Id) {
     EXPECT_EQ(test.GetShowRows(), 1);
 
     CheckInt16(1);
-    CheckBinary("localhost:9066", TSDB_EP_LEN);
+    CheckBinary("localhost:9016", TSDB_EP_LEN);
     CheckTimestamp();
   }
 }
 
-TEST_F(DndTestSnode, 03_Create_Snode_Invalid_Id) {
+TEST_F(MndTestSnode, 03_Create_Snode_Invalid_Id) {
   {
-    int32_t contLen = sizeof(SMCreateSnodeMsg);
+    int32_t contLen = sizeof(SMCreateSnodeReq);
 
-    SMCreateSnodeMsg* pReq = (SMCreateSnodeMsg*)rpcMallocCont(contLen);
+    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_SNODE, pReq, contLen);
@@ -90,14 +90,14 @@ TEST_F(DndTestSnode, 03_Create_Snode_Invalid_Id) {
   }
 }
 
-TEST_F(DndTestSnode, 04_Create_Snode) {
+TEST_F(MndTestSnode, 04_Create_Snode) {
   {
     // create dnode
     int32_t contLen = sizeof(SCreateDnodeMsg);
 
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->fqdn, "localhost");
-    pReq->port = htonl(9067);
+    pReq->port = htonl(9017);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
@@ -111,9 +111,9 @@ TEST_F(DndTestSnode, 04_Create_Snode) {
 
   {
     // create snode
-    int32_t contLen = sizeof(SMCreateSnodeMsg);
+    int32_t contLen = sizeof(SMCreateSnodeReq);
 
-    SMCreateSnodeMsg* pReq = (SMCreateSnodeMsg*)rpcMallocCont(contLen);
+    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_SNODE, pReq, contLen);
@@ -126,17 +126,17 @@ TEST_F(DndTestSnode, 04_Create_Snode) {
 
     CheckInt16(1);
     CheckInt16(2);
-    CheckBinary("localhost:9066", TSDB_EP_LEN);
-    CheckBinary("localhost:9067", TSDB_EP_LEN);
+    CheckBinary("localhost:9016", TSDB_EP_LEN);
+    CheckBinary("localhost:9017", TSDB_EP_LEN);
     CheckTimestamp();
     CheckTimestamp();
   }
 
   {
     // drop snode
-    int32_t contLen = sizeof(SMDropSnodeMsg);
+    int32_t contLen = sizeof(SMDropSnodeReq);
 
-    SMDropSnodeMsg* pReq = (SMDropSnodeMsg*)rpcMallocCont(contLen);
+    SMDropSnodeReq* pReq = (SMDropSnodeReq*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_SNODE, pReq, contLen);
@@ -148,7 +148,7 @@ TEST_F(DndTestSnode, 04_Create_Snode) {
     EXPECT_EQ(test.GetShowRows(), 1);
 
     CheckInt16(1);
-    CheckBinary("localhost:9066", TSDB_EP_LEN);
+    CheckBinary("localhost:9016", TSDB_EP_LEN);
     CheckTimestamp();
   }
 }
\ No newline at end of file

source/dnode/mnode/impl/test/trans/trans.cpp

 /**
- * @file user.cpp
+ * @file trans.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief MNODE module trans tests
  * @version 1.0
@@ -9,10 +9,10 @@
  *
  */
 
-#include "base.h"
+#include "sut.h"
 #include "os.h"
 
-class DndTestTrans : public ::testing::Test {
+class MndTestTrans : public ::testing::Test {
  protected:
   static void SetUpTestSuite() { test.Init("/tmp/mnode_test_trans", 9013); }
   static void TearDownTestSuite() { test.Cleanup(); }
@@ -48,13 +48,13 @@ class DndTestTrans : public ::testing::Test {
   void TearDown() override {}
 };
 
-Testbase DndTestTrans::test;
+Testbase MndTestTrans::test;
 
-TEST_F(DndTestTrans, 01_CreateUser_Crash) {
+TEST_F(MndTestTrans, 01_Create_User_Crash) {
   {
-    int32_t contLen = sizeof(SCreateUserMsg);
+    int32_t contLen = sizeof(SCreateUserReq);
 
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
+    SCreateUserReq* pReq = (SCreateUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p1");
 
@@ -75,12 +75,12 @@ TEST_F(DndTestTrans, 01_CreateUser_Crash) {
   test.SendShowRetrieveMsg();
   EXPECT_EQ(test.GetShowRows(), 2);
 
-  // CheckBinary("root", TSDB_USER_LEN);
-  // CheckBinary("u2", TSDB_USER_LEN);
-  // CheckBinary("super", 10);
-  // CheckBinary("normal", 10);
-  // CheckTimestamp();
-  // CheckTimestamp();
-  // CheckBinary("root", TSDB_USER_LEN);
-  // CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("u1", TSDB_USER_LEN);
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("normal", 10);
+  CheckBinary("super", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("root", TSDB_USER_LEN);
 }
\ No newline at end of file

source/dnode/mnode/impl/test/user/user.cpp

@@ -3,15 +3,15 @@
  * @author slguan (slguan@taosdata.com)
  * @brief MNODE module user tests
  * @version 1.0
- * @date 2021-12-15
+ * @date 2022-01-04
  *
- * @copyright Copyright (c) 2021
+ * @copyright Copyright (c) 2022
  *
  */
 
-#include "base.h"
+#include "sut.h"
 
-class DndTestUser : public ::testing::Test {
+class MndTestUser : public ::testing::Test {
  protected:
   static void SetUpTestSuite() { test.Init("/tmp/mnode_test_user", 9011); }
   static void TearDownTestSuite() { test.Cleanup(); }
@@ -23,9 +23,9 @@ class DndTestUser : public ::testing::Test {
   void TearDown() override {}
 };
 
-Testbase DndTestUser::test;
+Testbase MndTestUser::test;
 
-TEST_F(DndTestUser, 01_ShowUser) {
+TEST_F(MndTestUser, 01_Show_User) {
   test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, "");
   CHECK_META("show users", 4);
 
@@ -43,11 +43,11 @@ TEST_F(DndTestUser, 01_ShowUser) {
   CheckBinary("root", TSDB_USER_LEN);
 }
 
-TEST_F(DndTestUser, 02_Create_User) {
+TEST_F(MndTestUser, 02_Create_User) {
   {
-    int32_t contLen = sizeof(SCreateUserMsg);
+    int32_t contLen = sizeof(SCreateUserReq);
 
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
+    SCreateUserReq* pReq = (SCreateUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "");
     strcpy(pReq->pass, "p1");
 
@@ -57,9 +57,9 @@ TEST_F(DndTestUser, 02_Create_User) {
   }
 
   {
-    int32_t contLen = sizeof(SCreateUserMsg);
+    int32_t contLen = sizeof(SCreateUserReq);
 
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
+    SCreateUserReq* pReq = (SCreateUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "");
 
@@ -69,9 +69,9 @@ TEST_F(DndTestUser, 02_Create_User) {
   }
 
   {
-    int32_t contLen = sizeof(SCreateUserMsg);
+    int32_t contLen = sizeof(SCreateUserReq);
 
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
+    SCreateUserReq* pReq = (SCreateUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "root");
     strcpy(pReq->pass, "1");
 
@@ -81,9 +81,9 @@ TEST_F(DndTestUser, 02_Create_User) {
   }
 
   {
-    int32_t contLen = sizeof(SCreateUserMsg);
+    int32_t contLen = sizeof(SCreateUserReq);
 
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
+    SCreateUserReq* pReq = (SCreateUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p1");
 
@@ -99,11 +99,11 @@ TEST_F(DndTestUser, 02_Create_User) {
   EXPECT_EQ(test.GetShowRows(), 2);
 }
 
-TEST_F(DndTestUser, 03_Alter_User) {
+TEST_F(MndTestUser, 03_Alter_User) {
   {
-    int32_t contLen = sizeof(SAlterUserMsg);
+    int32_t contLen = sizeof(SAlterUserReq);
 
-    SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen);
+    SAlterUserReq* pReq = (SAlterUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "");
     strcpy(pReq->pass, "p1");
 
@@ -113,9 +113,9 @@ TEST_F(DndTestUser, 03_Alter_User) {
   }
 
   {
-    int32_t contLen = sizeof(SAlterUserMsg);
+    int32_t contLen = sizeof(SAlterUserReq);
 
-    SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen);
+    SAlterUserReq* pReq = (SAlterUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "");
 
@@ -125,9 +125,9 @@ TEST_F(DndTestUser, 03_Alter_User) {
   }
 
   {
-    int32_t contLen = sizeof(SAlterUserMsg);
+    int32_t contLen = sizeof(SAlterUserReq);
 
-    SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen);
+    SAlterUserReq* pReq = (SAlterUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u4");
     strcpy(pReq->pass, "1");
 
@@ -137,9 +137,9 @@ TEST_F(DndTestUser, 03_Alter_User) {
   }
 
   {
-    int32_t contLen = sizeof(SAlterUserMsg);
+    int32_t contLen = sizeof(SAlterUserReq);
 
-    SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen);
+    SAlterUserReq* pReq = (SAlterUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "1");
 
@@ -149,11 +149,11 @@ TEST_F(DndTestUser, 03_Alter_User) {
   }
 }
 
-TEST_F(DndTestUser, 04_Drop_User) {
+TEST_F(MndTestUser, 04_Drop_User) {
   {
-    int32_t contLen = sizeof(SDropUserMsg);
+    int32_t contLen = sizeof(SDropUserReq);
 
-    SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen);
+    SDropUserReq* pReq = (SDropUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "");
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen);
@@ -162,9 +162,9 @@ TEST_F(DndTestUser, 04_Drop_User) {
   }
 
   {
-    int32_t contLen = sizeof(SDropUserMsg);
+    int32_t contLen = sizeof(SDropUserReq);
 
-    SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen);
+    SDropUserReq* pReq = (SDropUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u4");
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen);
@@ -173,9 +173,9 @@ TEST_F(DndTestUser, 04_Drop_User) {
   }
 
   {
-    int32_t contLen = sizeof(SDropUserMsg);
+    int32_t contLen = sizeof(SDropUserReq);
 
-    SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen);
+    SDropUserReq* pReq = (SDropUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen);
@@ -190,11 +190,11 @@ TEST_F(DndTestUser, 04_Drop_User) {
   EXPECT_EQ(test.GetShowRows(), 1);
 }
 
-TEST_F(DndTestUser, 05_Create_Drop_Alter_User) {
+TEST_F(MndTestUser, 05_Create_Drop_Alter_User) {
   {
-    int32_t contLen = sizeof(SCreateUserMsg);
+    int32_t contLen = sizeof(SCreateUserReq);
 
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
+    SCreateUserReq* pReq = (SCreateUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p1");
 
@@ -204,9 +204,9 @@ TEST_F(DndTestUser, 05_Create_Drop_Alter_User) {
   }
 
   {
-    int32_t contLen = sizeof(SCreateUserMsg);
+    int32_t contLen = sizeof(SCreateUserReq);
 
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
+    SCreateUserReq* pReq = (SCreateUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u2");
     strcpy(pReq->pass, "p2");
 
@@ -235,9 +235,9 @@ TEST_F(DndTestUser, 05_Create_Drop_Alter_User) {
   CheckBinary("root", TSDB_USER_LEN);
 
   {
-    int32_t contLen = sizeof(SAlterUserMsg);
+    int32_t contLen = sizeof(SAlterUserReq);
 
-    SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen);
+    SAlterUserReq* pReq = (SAlterUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p2");
 
@@ -266,9 +266,9 @@ TEST_F(DndTestUser, 05_Create_Drop_Alter_User) {
   CheckBinary("root", TSDB_USER_LEN);
 
   {
-    int32_t contLen = sizeof(SDropUserMsg);
+    int32_t contLen = sizeof(SDropUserReq);
 
-    SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen);
+    SDropUserReq* pReq = (SDropUserReq*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen);

source/dnode/mnode/sdb/src/sdb.c

@@ -64,8 +64,9 @@ SSdb *sdbInit(SSdbOpt *pOption) {
 void sdbCleanup(SSdb *pSdb) {
   mDebug("start to cleanup sdb");
 
-  if (pSdb->curVer != pSdb->lastCommitVer) {
-    mDebug("write sdb file for current ver:%" PRId64 " != last commit ver:%" PRId64, pSdb->curVer, pSdb->lastCommitVer);
+  if (pSdb->curVer > pSdb->lastCommitVer) {
+    mDebug("write sdb file for current ver:%" PRId64 " larger than last commit ver:%" PRId64, pSdb->curVer,
+           pSdb->lastCommitVer);
     sdbWriteFile(pSdb);
   }
 

source/dnode/qnode/inc/qndInt.h

@@ -32,9 +32,9 @@ typedef struct SQnode {
   int32_t           dnodeId;
   int64_t           clusterId;
   SQnodeCfg         cfg;
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
 } SQnode;
 
 #ifdef __cplusplus

source/dnode/snode/inc/sndInt.h

@@ -32,9 +32,9 @@ typedef struct SSnode {
   int32_t           dnodeId;
   int64_t           clusterId;
   SSnodeCfg         cfg;
-  SendMsgToDnodeFp  sendMsgToDnodeFp;
-  SendMsgToMnodeFp  sendMsgToMnodeFp;
-  SendRedirectMsgFp sendRedirectMsgFp;
+  SendReqToDnodeFp  sendReqToDnodeFp;
+  SendReqToMnodeFp  sendReqToMnodeFp;
+  SendRedirectRspFp sendRedirectRspFp;
 } SSnode;
 
 #ifdef __cplusplus

source/libs/parser/inc/astToMsg.h

@@ -5,9 +5,9 @@
 #include "tmsg.h"
 
 
-SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
-SCreateAcctMsg* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
-SDropUserMsg* buildDropUserMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
+SCreateUserReq* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
+SCreateAcctReq* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
+SDropUserReq* buildDropUserMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SShowMsg* buildShowMsg(SShowInfo* pShowInfo, SParseBasicCtx* pParseCtx, char* msgBuf, int32_t msgLen);
 SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf);
 SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);

source/libs/parser/src/astToMsg.c

@@ -2,8 +2,8 @@
 #include "astGenerator.h"
 #include "parserUtil.h"
 
-SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen) {
-  SCreateUserMsg* pMsg = (SCreateUserMsg*)calloc(1, sizeof(SCreateUserMsg));
+SCreateUserReq* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen) {
+  SCreateUserReq* pMsg = (SCreateUserReq*)calloc(1, sizeof(SCreateUserReq));
   if (pMsg == NULL) {
     //    tscError("0x%" PRIx64 " failed to malloc for query msg", id);
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -25,8 +25,8 @@ SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, in
   return pMsg;
 }
 
-SCreateAcctMsg* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen) {
-  SCreateAcctMsg *pCreateMsg = (SCreateAcctMsg *) calloc(1, sizeof(SCreateAcctMsg));
+SCreateAcctReq* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen) {
+  SCreateAcctReq *pCreateMsg = (SCreateAcctReq *) calloc(1, sizeof(SCreateAcctReq));
   if (pCreateMsg == NULL) {
     qError("0x%" PRIx64 " failed to malloc for query msg", id);
     terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
@@ -64,24 +64,24 @@ SCreateAcctMsg* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, in
     }
   }
 
-  *outputLen = sizeof(SCreateAcctMsg);
+  *outputLen = sizeof(SCreateAcctReq);
   return pCreateMsg;
 }
 
-SDropUserMsg* buildDropUserMsg(SSqlInfo* pInfo, int32_t *msgLen, int64_t id, char* msgBuf, int32_t msgBufLen) {
+SDropUserReq* buildDropUserMsg(SSqlInfo* pInfo, int32_t *msgLen, int64_t id, char* msgBuf, int32_t msgBufLen) {
   SToken* pName = taosArrayGet(pInfo->pMiscInfo->a, 0);
   if (pName->n >= TSDB_USER_LEN) {
     return NULL;
   }
 
-  SDropUserMsg* pMsg = calloc(1, sizeof(SDropUserMsg));
+  SDropUserReq* pMsg = calloc(1, sizeof(SDropUserReq));
   if (pMsg == NULL) {
     terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
     return NULL;
   }
 
   strncpy(pMsg->user, pName->z, pName->n);
-  *msgLen = sizeof(SDropUserMsg);
+  *msgLen = sizeof(SDropUserReq);
   return pMsg;
 }
 

source/libs/transport/src/rpcMain.c

@@ -1198,7 +1198,7 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead, SRpcReqConte
       }
       rpcSendReqToServer(pRpc, pContext);
       rpcFreeCont(rpcMsg.pCont);
-    } else if (pHead->code == TSDB_CODE_RPC_NOT_READY || pHead->code == TSDB_CODE_APP_NOT_READY || pHead->code == TSDB_CODE_DND_EXITING) {
+    } else if (pHead->code == TSDB_CODE_RPC_NOT_READY || pHead->code == TSDB_CODE_APP_NOT_READY || pHead->code == TSDB_CODE_DND_OFFLINE) {
       pContext->code = pHead->code;
       rpcProcessConnError(pContext, NULL);
       rpcFreeCont(rpcMsg.pCont);

source/util/src/terror.c

@@ -253,7 +253,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_NOT_EXIST,           "Transaction not exis
 
 // dnode
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_ACTION_IN_PROGRESS,       "Action in progress")
-TAOS_DEFINE_ERROR(TSDB_CODE_DND_EXITING,                  "Dnode is exiting")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_OFFLINE,                  "Dnode is offline")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_INVALID_MSG_LEN,          "Invalid message length")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_DNODE_READ_FILE_ERROR,    "Read dnode.json error")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_DNODE_WRITE_FILE_ERROR,   "Write dnode.json error")

src/client/src/tscServer.c

@@ -1210,13 +1210,13 @@ int32_t tscBuildCreateDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
 int32_t tscBuildAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
-  pCmd->payloadLen = sizeof(SCreateAcctMsg);
+  pCmd->payloadLen = sizeof(SCreateAcctReq);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
     tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  SCreateAcctMsg *pAlterMsg = (SCreateAcctMsg *)pCmd->payload;
+  SCreateAcctReq *pAlterMsg = (SCreateAcctReq *)pCmd->payload;
 
   SStrToken *pName = &pInfo->pMiscInfo->user.user;
   SStrToken *pPwd = &pInfo->pMiscInfo->user.passwd;
@@ -1255,14 +1255,14 @@ int32_t tscBuildAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
 int32_t tscBuildUserMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
-  pCmd->payloadLen = sizeof(SCreateUserMsg);
+  pCmd->payloadLen = sizeof(SCreateUserReq);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
     tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  SCreateUserMsg *pAlterMsg = (SCreateUserMsg *)pCmd->payload;
+  SCreateUserReq *pAlterMsg = (SCreateUserReq *)pCmd->payload;
 
   SUserInfo *pUser = &pInfo->pMiscInfo->user;
   strncpy(pAlterMsg->user, pUser->user.z, pUser->user.n);
@@ -1369,7 +1369,7 @@ int32_t tscBuildDropUserAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   char user[TSDB_USER_LEN] = {0};
   tstrncpy(user, pCmd->payload, TSDB_USER_LEN);
 
-  pCmd->payloadLen = sizeof(SDropUserMsg);
+  pCmd->payloadLen = sizeof(SDropUserReq);
   pCmd->msgType = (pInfo->type == TSDB_SQL_DROP_USER)? TDMT_MND_DROP_USER:TDMT_MND_DROP_ACCT;
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
@@ -1377,7 +1377,7 @@ int32_t tscBuildDropUserAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  SDropUserMsg *pDropMsg = (SDropUserMsg *)pCmd->payload;
+  SDropUserReq *pDropMsg = (SDropUserReq *)pCmd->payload;
   tstrncpy(pDropMsg->user, user, tListLen(user));
 
   return TSDB_CODE_SUCCESS;