serialize node msg

include/common/tmsg.h

@@ -872,15 +872,11 @@ typedef struct {
 
 typedef struct {
   int32_t dnodeId;
-} SMCreateQnodeReq, SMDropQnodeReq, SDCreateQnodeReq, SDDropQnodeReq;
+} SMCreateQnodeReq, SMDropQnodeReq, SDCreateQnodeReq, SDDropQnodeReq, SMCreateSnodeReq, SMDropSnodeReq,
+    SDCreateSnodeReq, SDDropSnodeReq, SMCreateBnodeReq, SMDropBnodeReq, SDCreateBnodeReq, SDDropBnodeReq;
 
-typedef struct {
-  int32_t dnodeId;
-} SMCreateSnodeReq, SMDropSnodeReq, SDCreateSnodeReq, SDDropSnodeReq;
-
-typedef struct {
-  int32_t dnodeId;
-} SMCreateBnodeReq, SMDropBnodeReq, SDCreateBnodeReq, SDDropBnodeReq;
+int32_t tSerializeSMCreateDropQSBNodeReq(void* buf, int32_t bufLen, SMCreateQnodeReq* pReq);
+int32_t tDeserializeSMCreateDropQSBNodeReq(void* buf, int32_t bufLen, SMCreateQnodeReq* pReq);
 
 typedef struct {
   char    sql[TSDB_SHOW_SQL_LEN];

source/common/src/tmsg.c

@@ -823,3 +823,28 @@ int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *
   tCoderClear(&decoder);
   return 0;
 }
+
+int32_t tSerializeSMCreateDropQSBNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSMCreateDropQSBNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}

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

@@ -29,6 +29,10 @@ int32_t mndCheckCreateUserAuth(SUserObj *pOperUser);
 int32_t mndCheckAlterUserAuth(SUserObj *pOperUser, SUserObj *pUser, SDbObj *pDb, SAlterUserReq *pAlter);
 int32_t mndCheckDropUserAuth(SUserObj *pOperUser);
 
+int32_t mndCheckCreateNodeAuth(SUserObj *pOperUser);
+int32_t mndCheckDropNodeAuth(SUserObj *pOperUser);
+int32_t mndCheckAlterNodeAuth(SUserObj *pOperUser);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -109,4 +109,17 @@ int32_t mndCheckDropUserAuth(SUserObj *pOperUser) {
 
   terrno = TSDB_CODE_MND_NO_RIGHTS;
   return -1;
-}
\ No newline at end of file
+}
+
+int32_t mndCheckCreateNodeAuth(SUserObj *pOperUser) {
+  if (pOperUser->superUser) {
+    return 0;
+  }
+
+  terrno = TSDB_CODE_MND_NO_RIGHTS;
+  return -1;
+}
+
+int32_t mndCheckDropNodeAuth(SUserObj *pOperUser) { return mndCheckCreateNodeAuth(pOperUser); }
+
+int32_t mndCheckAlterNodeAuth(SUserObj *pOperUser) { return mndCheckCreateNodeAuth(pOperUser); }

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

@@ -15,9 +15,11 @@
 
 #define _DEFAULT_SOURCE
 #include "mndBnode.h"
+#include "mndAuth.h"
 #include "mndDnode.h"
 #include "mndShow.h"
 #include "mndTrans.h"
+#include "mndUser.h"
 
 #define TSDB_BNODE_VER_NUMBER 1
 #define TSDB_BNODE_RESERVE_SIZE 64
@@ -257,40 +259,57 @@ CREATE_BNODE_OVER:
 }
 
 static int32_t mndProcessCreateBnodeReq(SMnodeMsg *pReq) {
-  SMnode           *pMnode = pReq->pMnode;
-  SMCreateBnodeReq *pCreate = pReq->rpcMsg.pCont;
-
-  pCreate->dnodeId = htonl(pCreate->dnodeId);
+  SMnode          *pMnode = pReq->pMnode;
+  int32_t          code = -1;
+  SBnodeObj       *pObj = NULL;
+  SDnodeObj       *pDnode = NULL;
+  SUserObj        *pUser = NULL;
+  SMCreateBnodeReq createReq = {0};
+
+  if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto CREATE_BNODE_OVER;
+  }
 
-  mDebug("bnode:%d, start to create", pCreate->dnodeId);
+  mDebug("bnode:%d, start to create", createReq.dnodeId);
 
-  SBnodeObj *pObj = mndAcquireBnode(pMnode, pCreate->dnodeId);
+  pObj = mndAcquireBnode(pMnode, createReq.dnodeId);
   if (pObj != NULL) {
-    mError("bnode:%d, bnode already exist", pObj->id);
     terrno = TSDB_CODE_MND_BNODE_ALREADY_EXIST;
-    mndReleaseBnode(pMnode, pObj);
-    return -1;
+    goto CREATE_BNODE_OVER;
   } else if (terrno != TSDB_CODE_MND_BNODE_NOT_EXIST) {
-    mError("bnode:%d, failed to create bnode since %s", pCreate->dnodeId, terrstr());
-    return -1;
+    goto CREATE_BNODE_OVER;
   }
 
-  SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCreate->dnodeId);
+  pDnode = mndAcquireDnode(pMnode, createReq.dnodeId);
   if (pDnode == NULL) {
-    mError("bnode:%d, dnode not exist", pCreate->dnodeId);
     terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
-    return -1;
+    goto CREATE_BNODE_OVER;
   }
 
-  int32_t code = mndCreateBnode(pMnode, pReq, pDnode, pCreate);
-  mndReleaseDnode(pMnode, pDnode);
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto CREATE_BNODE_OVER;
+  }
 
-  if (code != 0) {
-    mError("bnode:%d, failed to create since %s", pCreate->dnodeId, terrstr());
-    return -1;
+  if (mndCheckDropNodeAuth(pUser)) {
+    goto CREATE_BNODE_OVER;
   }
 
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  code = mndCreateBnode(pMnode, pReq, pDnode, &createReq);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+CREATE_BNODE_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("bnode:%d, failed to create since %s", createReq.dnodeId, terrstr());
+  }
+
+  mndReleaseBnode(pMnode, pObj);
+  mndReleaseDnode(pMnode, pDnode);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndSetDropBnodeRedoLogs(STrans *pTrans, SBnodeObj *pObj) {
@@ -352,33 +371,51 @@ DROP_BNODE_OVER:
 }
 
 static int32_t mndProcessDropBnodeReq(SMnodeMsg *pReq) {
-  SMnode         *pMnode = pReq->pMnode;
-  SMDropBnodeReq *pDrop = pReq->rpcMsg.pCont;
-  pDrop->dnodeId = htonl(pDrop->dnodeId);
+  SMnode        *pMnode = pReq->pMnode;
+  int32_t        code = -1;
+  SUserObj      *pUser = NULL;
+  SBnodeObj     *pObj = NULL;
+  SMDropBnodeReq dropReq = {0};
+
+  if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto DROP_BNODE_OVER;
+  }
 
-  mDebug("bnode:%d, start to drop", pDrop->dnodeId);
+  mDebug("bnode:%d, start to drop", dropReq.dnodeId);
 
-  if (pDrop->dnodeId <= 0) {
+  if (dropReq.dnodeId <= 0) {
     terrno = TSDB_CODE_SDB_APP_ERROR;
-    mError("bnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr());
-    return -1;
+    goto DROP_BNODE_OVER;
   }
 
-  SBnodeObj *pObj = mndAcquireBnode(pMnode, pDrop->dnodeId);
+  pObj = mndAcquireBnode(pMnode, dropReq.dnodeId);
   if (pObj == NULL) {
-    mError("bnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr());
-    return -1;
+    goto DROP_BNODE_OVER;
   }
 
-  int32_t code = mndDropBnode(pMnode, pReq, pObj);
-  if (code != 0) {
-    sdbRelease(pMnode->pSdb, pObj);
-    mError("bnode:%d, failed to drop since %s", pMnode->dnodeId, terrstr());
-    return -1;
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto DROP_BNODE_OVER;
+  }
+
+  if (mndCheckCreateNodeAuth(pUser)) {
+    goto DROP_BNODE_OVER;
   }
 
-  sdbRelease(pMnode->pSdb, pObj);
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  code = mndDropBnode(pMnode, pReq, pObj);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+DROP_BNODE_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("bnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr());
+  }
+
+  mndReleaseBnode(pMnode, pObj);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndProcessCreateBnodeRsp(SMnodeMsg *pRsp) {

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

@@ -15,9 +15,11 @@
 
 #define _DEFAULT_SOURCE
 #include "mndQnode.h"
+#include "mndAuth.h"
 #include "mndDnode.h"
 #include "mndShow.h"
 #include "mndTrans.h"
+#include "mndUser.h"
 
 #define TSDB_QNODE_VER_NUMBER 1
 #define TSDB_QNODE_RESERVE_SIZE 64
@@ -257,40 +259,58 @@ CREATE_QNODE_OVER:
 }
 
 static int32_t mndProcessCreateQnodeReq(SMnodeMsg *pReq) {
-  SMnode           *pMnode = pReq->pMnode;
-  SMCreateQnodeReq *pCreate = pReq->rpcMsg.pCont;
-
-  pCreate->dnodeId = htonl(pCreate->dnodeId);
+  SMnode          *pMnode = pReq->pMnode;
+  int32_t          code = -1;
+  SQnodeObj       *pObj = NULL;
+  SDnodeObj       *pDnode = NULL;
+  SUserObj        *pUser = NULL;
+  SMCreateQnodeReq createReq = {0};
+
+  if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto CREATE_QNODE_OVER;
+  }
 
-  mDebug("qnode:%d, start to create", pCreate->dnodeId);
+  mDebug("qnode:%d, start to create", createReq.dnodeId);
 
-  SQnodeObj *pObj = mndAcquireQnode(pMnode, pCreate->dnodeId);
+  pObj = mndAcquireQnode(pMnode, createReq.dnodeId);
   if (pObj != NULL) {
-    mError("qnode:%d, qnode already exist", pObj->id);
     terrno = TSDB_CODE_MND_QNODE_ALREADY_EXIST;
-    mndReleaseQnode(pMnode, pObj);
-    return -1;
+    goto CREATE_QNODE_OVER;
   } else if (terrno != TSDB_CODE_MND_QNODE_NOT_EXIST) {
-    mError("qnode:%d, failed to create qnode since %s", pCreate->dnodeId, terrstr());
-    return -1;
+    goto CREATE_QNODE_OVER;
   }
 
-  SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCreate->dnodeId);
+  pDnode = mndAcquireDnode(pMnode, createReq.dnodeId);
   if (pDnode == NULL) {
-    mError("qnode:%d, dnode not exist", pCreate->dnodeId);
     terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
-    return -1;
+    goto CREATE_QNODE_OVER;
   }
 
-  int32_t code = mndCreateQnode(pMnode, pReq, pDnode, pCreate);
-  mndReleaseDnode(pMnode, pDnode);
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto CREATE_QNODE_OVER;
+  }
 
-  if (code != 0) {
-    mError("qnode:%d, failed to create since %s", pCreate->dnodeId, terrstr());
+  if (mndCheckDropNodeAuth(pUser)) {
+    goto CREATE_QNODE_OVER;
+  }
+
+  code = mndCreateQnode(pMnode, pReq, pDnode, &createReq);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+CREATE_QNODE_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("qnode:%d, failed to create since %s", createReq.dnodeId, terrstr());
     return -1;
   }
 
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  mndReleaseQnode(pMnode, pObj);
+  mndReleaseDnode(pMnode, pDnode);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndSetDropQnodeRedoLogs(STrans *pTrans, SQnodeObj *pObj) {
@@ -352,33 +372,52 @@ DROP_QNODE_OVER:
 }
 
 static int32_t mndProcessDropQnodeReq(SMnodeMsg *pReq) {
-  SMnode         *pMnode = pReq->pMnode;
-  SMDropQnodeReq *pDrop = pReq->rpcMsg.pCont;
-  pDrop->dnodeId = htonl(pDrop->dnodeId);
+  SMnode        *pMnode = pReq->pMnode;
+  int32_t        code = -1;
+  SUserObj      *pUser = NULL;
+  SQnodeObj     *pObj = NULL;
+  SMDropQnodeReq dropReq = {0};
+
+  if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto DROP_QNODE_OVER;
+  }
 
-  mDebug("qnode:%d, start to drop", pDrop->dnodeId);
+  mDebug("qnode:%d, start to drop", dropReq.dnodeId);
 
-  if (pDrop->dnodeId <= 0) {
+  if (dropReq.dnodeId <= 0) {
     terrno = TSDB_CODE_SDB_APP_ERROR;
-    mError("qnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr());
-    return -1;
+    goto DROP_QNODE_OVER;
   }
 
-  SQnodeObj *pObj = mndAcquireQnode(pMnode, pDrop->dnodeId);
+  pObj = mndAcquireQnode(pMnode, dropReq.dnodeId);
   if (pObj == NULL) {
-    mError("qnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr());
-    return -1;
+    goto DROP_QNODE_OVER;
+  }
+
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto DROP_QNODE_OVER;
   }
 
-  int32_t code = mndDropQnode(pMnode, pReq, pObj);
-  if (code != 0) {
-    sdbRelease(pMnode->pSdb, pObj);
+  if (mndCheckCreateNodeAuth(pUser)) {
+    goto DROP_QNODE_OVER;
+  }
+
+  code = mndDropQnode(pMnode, pReq, pObj);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+DROP_QNODE_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("qnode:%d, failed to drop since %s", pMnode->dnodeId, terrstr());
     return -1;
   }
 
-  sdbRelease(pMnode->pSdb, pObj);
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  mndReleaseQnode(pMnode, pObj);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndProcessCreateQnodeRsp(SMnodeMsg *pRsp) {

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

@@ -15,9 +15,11 @@
 
 #define _DEFAULT_SOURCE
 #include "mndSnode.h"
+#include "mndAuth.h"
 #include "mndDnode.h"
 #include "mndShow.h"
 #include "mndTrans.h"
+#include "mndUser.h"
 
 #define TSDB_SNODE_VER_NUMBER 1
 #define TSDB_SNODE_RESERVE_SIZE 64
@@ -258,40 +260,58 @@ CREATE_SNODE_OVER:
 }
 
 static int32_t mndProcessCreateSnodeReq(SMnodeMsg *pReq) {
-  SMnode           *pMnode = pReq->pMnode;
-  SMCreateSnodeReq *pCreate = pReq->rpcMsg.pCont;
-
-  pCreate->dnodeId = htonl(pCreate->dnodeId);
+  SMnode          *pMnode = pReq->pMnode;
+  int32_t          code = -1;
+  SSnodeObj       *pObj = NULL;
+  SDnodeObj       *pDnode = NULL;
+  SUserObj        *pUser = NULL;
+  SMCreateSnodeReq createReq = {0};
+
+  if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto CREATE_SNODE_OVER;
+  }
 
-  mDebug("snode:%d, start to create", pCreate->dnodeId);
+  mDebug("snode:%d, start to create", createReq.dnodeId);
 
-  SSnodeObj *pObj = mndAcquireSnode(pMnode, pCreate->dnodeId);
+  pObj = mndAcquireSnode(pMnode, createReq.dnodeId);
   if (pObj != NULL) {
-    mError("snode:%d, snode already exist", pObj->id);
     terrno = TSDB_CODE_MND_SNODE_ALREADY_EXIST;
-    mndReleaseSnode(pMnode, pObj);
-    return -1;
+    goto CREATE_SNODE_OVER;
   } else if (terrno != TSDB_CODE_MND_SNODE_NOT_EXIST) {
-    mError("snode:%d, failed to create snode since %s", pCreate->dnodeId, terrstr());
-    return -1;
+    goto CREATE_SNODE_OVER;
   }
 
-  SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCreate->dnodeId);
+  pDnode = mndAcquireDnode(pMnode, createReq.dnodeId);
   if (pDnode == NULL) {
-    mError("snode:%d, dnode not exist", pCreate->dnodeId);
     terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
-    return -1;
+    goto CREATE_SNODE_OVER;
   }
 
-  int32_t code = mndCreateSnode(pMnode, pReq, pDnode, pCreate);
-  mndReleaseDnode(pMnode, pDnode);
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto CREATE_SNODE_OVER;
+  }
 
-  if (code != 0) {
-    mError("snode:%d, failed to create since %s", pCreate->dnodeId, terrstr());
+  if (mndCheckDropNodeAuth(pUser)) {
+    goto CREATE_SNODE_OVER;
+  }
+
+  code = mndCreateSnode(pMnode, pReq, pDnode, &createReq);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+CREATE_SNODE_OVER:
+  if(code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("snode:%d, failed to create since %s", createReq.dnodeId, terrstr());
     return -1;
   }
 
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  mndReleaseSnode(pMnode, pObj);
+  mndReleaseDnode(pMnode, pDnode);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndSetDropSnodeRedoLogs(STrans *pTrans, SSnodeObj *pObj) {
@@ -354,33 +374,52 @@ DROP_SNODE_OVER:
 }
 
 static int32_t mndProcessDropSnodeReq(SMnodeMsg *pReq) {
-  SMnode         *pMnode = pReq->pMnode;
-  SMDropSnodeReq *pDrop = pReq->rpcMsg.pCont;
-  pDrop->dnodeId = htonl(pDrop->dnodeId);
+  SMnode        *pMnode = pReq->pMnode;
+  int32_t        code = -1;
+  SUserObj      *pUser = NULL;
+  SSnodeObj     *pObj = NULL;
+  SMDropSnodeReq dropReq = {0};
+
+  if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto DROP_SNODE_OVER;
+  }
 
-  mDebug("snode:%d, start to drop", pDrop->dnodeId);
+  mDebug("snode:%d, start to drop", dropReq.dnodeId);
 
-  if (pDrop->dnodeId <= 0) {
+  if (dropReq.dnodeId <= 0) {
     terrno = TSDB_CODE_SDB_APP_ERROR;
-    mError("snode:%d, failed to drop since %s", pDrop->dnodeId, terrstr());
-    return -1;
+    goto DROP_SNODE_OVER;
   }
 
-  SSnodeObj *pObj = mndAcquireSnode(pMnode, pDrop->dnodeId);
+  pObj = mndAcquireSnode(pMnode, dropReq.dnodeId);
   if (pObj == NULL) {
-    mError("snode:%d, failed to drop since %s", pDrop->dnodeId, terrstr());
-    return -1;
+    goto DROP_SNODE_OVER;
+  }
+
+  pUser = mndAcquireUser(pMnode, pReq->user);
+  if (pUser == NULL) {
+    terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
+    goto DROP_SNODE_OVER;
   }
 
-  int32_t code = mndDropSnode(pMnode, pReq, pObj);
-  if (code != 0) {
-    sdbRelease(pMnode->pSdb, pObj);
+  if (mndCheckCreateNodeAuth(pUser)) {
+    goto DROP_SNODE_OVER;
+  }
+
+  code = mndDropSnode(pMnode, pReq, pObj);
+  if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
+
+DROP_SNODE_OVER:
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("snode:%d, failed to drop since %s", pMnode->dnodeId, terrstr());
     return -1;
   }
 
-  sdbRelease(pMnode->pSdb, pObj);
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+  mndReleaseSnode(pMnode, pObj);
+  mndReleaseUser(pMnode, pUser);
+
+  return code;
 }
 
 static int32_t mndProcessCreateSnodeRsp(SMnodeMsg *pRsp) {

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

@@ -52,10 +52,12 @@ TEST_F(MndTestBnode, 01_Show_Bnode) {
 
 TEST_F(MndTestBnode, 02_Create_Bnode) {
   {
-    int32_t contLen = sizeof(SMCreateBnodeReq);
+    SMCreateBnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -63,10 +65,12 @@ TEST_F(MndTestBnode, 02_Create_Bnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateBnodeReq);
+    SMCreateBnodeReq createReq = {0};
+    createReq.dnodeId = 1;
 
-    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(1);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -83,10 +87,12 @@ TEST_F(MndTestBnode, 02_Create_Bnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateBnodeReq);
+    SMCreateBnodeReq createReq = {0};
+    createReq.dnodeId = 1;
 
-    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(1);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -113,10 +119,12 @@ TEST_F(MndTestBnode, 03_Drop_Bnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateBnodeReq);
+    SMCreateBnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -135,10 +143,12 @@ TEST_F(MndTestBnode, 03_Drop_Bnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMDropBnodeReq);
+    SMDropBnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropBnodeReq* pReq = (SMDropBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -154,10 +164,12 @@ TEST_F(MndTestBnode, 03_Drop_Bnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMDropBnodeReq);
+    SMDropBnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropBnodeReq* pReq = (SMDropBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -168,10 +180,12 @@ TEST_F(MndTestBnode, 03_Drop_Bnode) {
 TEST_F(MndTestBnode, 03_Create_Bnode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMCreateBnodeReq);
+    SMCreateBnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
@@ -181,10 +195,12 @@ TEST_F(MndTestBnode, 03_Create_Bnode_Rollback) {
 
   {
     // continue send message, bnode is creating
-    int32_t contLen = sizeof(SMCreateBnodeReq);
+    SMCreateBnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -193,10 +209,12 @@ TEST_F(MndTestBnode, 03_Create_Bnode_Rollback) {
 
   {
     // continue send message, bnode is creating
-    int32_t contLen = sizeof(SMDropBnodeReq);
+    SMDropBnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropBnodeReq* pReq = (SMDropBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -212,10 +230,12 @@ TEST_F(MndTestBnode, 03_Create_Bnode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateBnodeReq);
+      SMCreateBnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
-      SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);
@@ -230,10 +250,12 @@ TEST_F(MndTestBnode, 03_Create_Bnode_Rollback) {
 TEST_F(MndTestBnode, 04_Drop_Bnode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMDropBnodeReq);
+    SMDropBnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropBnodeReq* pReq = (SMDropBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_BNODE, pReq, contLen);
@@ -243,10 +265,12 @@ TEST_F(MndTestBnode, 04_Drop_Bnode_Rollback) {
 
   {
     // continue send message, bnode is dropping
-    int32_t contLen = sizeof(SMCreateBnodeReq);
+    SMCreateBnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -255,10 +279,12 @@ TEST_F(MndTestBnode, 04_Drop_Bnode_Rollback) {
 
   {
     // continue send message, bnode is dropping
-    int32_t contLen = sizeof(SMDropBnodeReq);
+    SMDropBnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropBnodeReq* pReq = (SMDropBnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_BNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -274,10 +300,12 @@ TEST_F(MndTestBnode, 04_Drop_Bnode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateBnodeReq);
+      SMCreateBnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
-      SMCreateBnodeReq* pReq = (SMCreateBnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_BNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);

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

@@ -52,10 +52,12 @@ TEST_F(MndTestQnode, 01_Show_Qnode) {
 
 TEST_F(MndTestQnode, 02_Create_Qnode) {
   {
-    int32_t contLen = sizeof(SMCreateQnodeReq);
+    SMCreateQnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -63,10 +65,12 @@ TEST_F(MndTestQnode, 02_Create_Qnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateQnodeReq);
+    SMCreateQnodeReq createReq = {0};
+    createReq.dnodeId = 1;
 
-    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(1);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -83,10 +87,12 @@ TEST_F(MndTestQnode, 02_Create_Qnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateQnodeReq);
+    SMCreateQnodeReq createReq = {0};
+    createReq.dnodeId = 1;
 
-    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(1);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -113,10 +119,12 @@ TEST_F(MndTestQnode, 03_Drop_Qnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateQnodeReq);
+    SMCreateQnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -135,10 +143,12 @@ TEST_F(MndTestQnode, 03_Drop_Qnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMDropQnodeReq);
+    SMDropQnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropQnodeReq* pReq = (SMDropQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -154,10 +164,12 @@ TEST_F(MndTestQnode, 03_Drop_Qnode) {
   }
 
   {
-    int32_t contLen = sizeof(SMDropQnodeReq);
+    SMDropQnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropQnodeReq* pReq = (SMDropQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -168,10 +180,12 @@ TEST_F(MndTestQnode, 03_Drop_Qnode) {
 TEST_F(MndTestQnode, 03_Create_Qnode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMCreateQnodeReq);
+    SMCreateQnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
@@ -181,10 +195,12 @@ TEST_F(MndTestQnode, 03_Create_Qnode_Rollback) {
 
   {
     // continue send message, qnode is creating
-    int32_t contLen = sizeof(SMCreateQnodeReq);
+    SMCreateQnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -193,10 +209,12 @@ TEST_F(MndTestQnode, 03_Create_Qnode_Rollback) {
 
   {
     // continue send message, qnode is creating
-    int32_t contLen = sizeof(SMDropQnodeReq);
+    SMDropQnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropQnodeReq* pReq = (SMDropQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -212,10 +230,12 @@ TEST_F(MndTestQnode, 03_Create_Qnode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateQnodeReq);
+      SMCreateQnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
-      SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);
@@ -230,10 +250,12 @@ TEST_F(MndTestQnode, 03_Create_Qnode_Rollback) {
 TEST_F(MndTestQnode, 04_Drop_Qnode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMDropQnodeReq);
+    SMDropQnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropQnodeReq* pReq = (SMDropQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_QNODE, pReq, contLen);
@@ -243,11 +265,12 @@ TEST_F(MndTestQnode, 04_Drop_Qnode_Rollback) {
 
   {
     // continue send message, qnode is dropping
-    int32_t contLen = sizeof(SMCreateQnodeReq);
-
-    SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    SMCreateQnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_SDB_OBJ_DROPPING);
@@ -255,10 +278,12 @@ TEST_F(MndTestQnode, 04_Drop_Qnode_Rollback) {
 
   {
     // continue send message, qnode is dropping
-    int32_t contLen = sizeof(SMDropQnodeReq);
+    SMDropQnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropQnodeReq* pReq = (SMDropQnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -274,11 +299,12 @@ TEST_F(MndTestQnode, 04_Drop_Qnode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateQnodeReq);
-
-      SMCreateQnodeReq* pReq = (SMCreateQnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      SMCreateQnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
+      int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_QNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);
       if (pRsp->code == 0) break;

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

@@ -52,10 +52,12 @@ TEST_F(MndTestSnode, 01_Show_Snode) {
 
 TEST_F(MndTestSnode, 02_Create_Snode) {
   {
-    int32_t contLen = sizeof(SMCreateSnodeReq);
+    SMCreateSnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -63,10 +65,12 @@ TEST_F(MndTestSnode, 02_Create_Snode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateSnodeReq);
+    SMCreateSnodeReq createReq = {0};
+    createReq.dnodeId = 1;
 
-    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(1);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -83,10 +87,12 @@ TEST_F(MndTestSnode, 02_Create_Snode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateSnodeReq);
+    SMCreateSnodeReq createReq = {0};
+    createReq.dnodeId = 1;
 
-    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(1);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -113,10 +119,12 @@ TEST_F(MndTestSnode, 03_Drop_Snode) {
   }
 
   {
-    int32_t contLen = sizeof(SMCreateSnodeReq);
+    SMCreateSnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -135,10 +143,12 @@ TEST_F(MndTestSnode, 03_Drop_Snode) {
   }
 
   {
-    int32_t contLen = sizeof(SMDropSnodeReq);
+    SMDropSnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropSnodeReq* pReq = (SMDropSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -154,10 +164,12 @@ TEST_F(MndTestSnode, 03_Drop_Snode) {
   }
 
   {
-    int32_t contLen = sizeof(SMDropSnodeReq);
+    SMDropSnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropSnodeReq* pReq = (SMDropSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -168,10 +180,12 @@ TEST_F(MndTestSnode, 03_Drop_Snode) {
 TEST_F(MndTestSnode, 03_Create_Snode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMCreateSnodeReq);
+    SMCreateSnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
@@ -181,10 +195,12 @@ TEST_F(MndTestSnode, 03_Create_Snode_Rollback) {
 
   {
     // continue send message, snode is creating
-    int32_t contLen = sizeof(SMCreateSnodeReq);
+    SMCreateSnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -193,10 +209,12 @@ TEST_F(MndTestSnode, 03_Create_Snode_Rollback) {
 
   {
     // continue send message, snode is creating
-    int32_t contLen = sizeof(SMDropSnodeReq);
+    SMDropSnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropSnodeReq* pReq = (SMDropSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -212,10 +230,12 @@ TEST_F(MndTestSnode, 03_Create_Snode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateSnodeReq);
+      SMCreateSnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
-      SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);
@@ -230,10 +250,12 @@ TEST_F(MndTestSnode, 03_Create_Snode_Rollback) {
 TEST_F(MndTestSnode, 04_Drop_Snode_Rollback) {
   {
     // send message first, then dnode2 crash, result is returned, and rollback is started
-    int32_t contLen = sizeof(SMDropSnodeReq);
+    SMDropSnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropSnodeReq* pReq = (SMDropSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     server2.Stop();
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_SNODE, pReq, contLen);
@@ -243,10 +265,12 @@ TEST_F(MndTestSnode, 04_Drop_Snode_Rollback) {
 
   {
     // continue send message, snode is dropping
-    int32_t contLen = sizeof(SMCreateSnodeReq);
+    SMCreateSnodeReq createReq = {0};
+    createReq.dnodeId = 2;
 
-    SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -255,10 +279,12 @@ TEST_F(MndTestSnode, 04_Drop_Snode_Rollback) {
 
   {
     // continue send message, snode is dropping
-    int32_t contLen = sizeof(SMDropSnodeReq);
+    SMDropSnodeReq dropReq = {0};
+    dropReq.dnodeId = 2;
 
-    SMDropSnodeReq* pReq = (SMDropSnodeReq*)rpcMallocCont(contLen);
-    pReq->dnodeId = htonl(2);
+    int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &dropReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -274,10 +300,12 @@ TEST_F(MndTestSnode, 04_Drop_Snode_Rollback) {
     int32_t retryMax = 20;
 
     for (retry = 0; retry < retryMax; retry++) {
-      int32_t contLen = sizeof(SMCreateSnodeReq);
+      SMCreateSnodeReq createReq = {0};
+      createReq.dnodeId = 2;
 
-      SMCreateSnodeReq* pReq = (SMCreateSnodeReq*)rpcMallocCont(contLen);
-      pReq->dnodeId = htonl(2);
+      int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
+      void*   pReq = rpcMallocCont(contLen);
+      tSerializeSMCreateDropQSBNodeReq(pReq, contLen, &createReq);
 
       SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_SNODE, pReq, contLen);
       ASSERT_NE(pRsp, nullptr);