xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

serialize node msg

This commit is contained in:
Shengliang Guan 2022-02-12 11:39:58 +08:00
parent 9b75a243d3
commit 34361b11a0
10 changed files with 477 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/common/tmsg.h
View File

@ -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];

25
source/common/src/tmsg.c
View File

@ -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;
}

4
source/dnode/mnode/impl/inc/mndAuth.h
View File

@ -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

15
source/dnode/mnode/impl/src/mndAuth.c
View File

@ -109,4 +109,17 @@ int32_t mndCheckDropUserAuth(SUserObj *pOperUser) {
terrno = TSDB_CODE_MND_NO_RIGHTS;
return -1;
}
}
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); }

111
source/dnode/mnode/impl/src/mndBnode.c
View File

@ -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;
SMnode *pMnode = pReq->pMnode;
int32_t code = -1;
SBnodeObj *pObj = NULL;
SDnodeObj *pDnode = NULL;
SUserObj *pUser = NULL;
SMCreateBnodeReq createReq = {0};
pCreate->dnodeId = htonl(pCreate->dnodeId);
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);
pUser = mndAcquireUser(pMnode, pReq->user);
if (pUser == NULL) {
terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
goto CREATE_BNODE_OVER;
}
if (mndCheckDropNodeAuth(pUser)) {
goto CREATE_BNODE_OVER;
}
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);
if (code != 0) {
mError("bnode:%d, failed to create since %s", pCreate->dnodeId, terrstr());
return -1;
}
return TSDB_CODE_MND_ACTION_IN_PROGRESS;
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};
mDebug("bnode:%d, start to drop", pDrop->dnodeId);
if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
terrno = TSDB_CODE_INVALID_MSG;
goto DROP_BNODE_OVER;
}
if (pDrop->dnodeId <= 0) {
mDebug("bnode:%d, start to drop", dropReq.dnodeId);
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;
}
sdbRelease(pMnode->pSdb, pObj);
return TSDB_CODE_MND_ACTION_IN_PROGRESS;
if (mndCheckCreateNodeAuth(pUser)) {
goto DROP_BNODE_OVER;
}
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) {

107
source/dnode/mnode/impl/src/mndQnode.c
View File

@ -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;
SMnode *pMnode = pReq->pMnode;
int32_t code = -1;
SQnodeObj *pObj = NULL;
SDnodeObj *pDnode = NULL;
SUserObj *pUser = NULL;
SMCreateQnodeReq createReq = {0};
pCreate->dnodeId = htonl(pCreate->dnodeId);
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;
goto CREATE_QNODE_OVER;
}
pUser = mndAcquireUser(pMnode, pReq->user);
if (pUser == NULL) {
terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
goto CREATE_QNODE_OVER;
}
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;
}
int32_t code = mndCreateQnode(pMnode, pReq, pDnode, pCreate);
mndReleaseQnode(pMnode, pObj);
mndReleaseDnode(pMnode, pDnode);
mndReleaseUser(pMnode, pUser);
if (code != 0) {
mError("qnode:%d, failed to create since %s", pCreate->dnodeId, terrstr());
return -1;
}
return TSDB_CODE_MND_ACTION_IN_PROGRESS;
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};
mDebug("qnode:%d, start to drop", pDrop->dnodeId);
if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
terrno = TSDB_CODE_INVALID_MSG;
goto DROP_QNODE_OVER;
}
if (pDrop->dnodeId <= 0) {
mDebug("qnode:%d, start to drop", dropReq.dnodeId);
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;
}
int32_t code = mndDropQnode(pMnode, pReq, pObj);
if (code != 0) {
sdbRelease(pMnode->pSdb, pObj);
pUser = mndAcquireUser(pMnode, pReq->user);
if (pUser == NULL) {
terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
goto DROP_QNODE_OVER;
}
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) {

107
source/dnode/mnode/impl/src/mndSnode.c
View File

@ -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;
SMnode *pMnode = pReq->pMnode;
int32_t code = -1;
SSnodeObj *pObj = NULL;
SDnodeObj *pDnode = NULL;
SUserObj *pUser = NULL;
SMCreateSnodeReq createReq = {0};
pCreate->dnodeId = htonl(pCreate->dnodeId);
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;
goto CREATE_SNODE_OVER;
}
pUser = mndAcquireUser(pMnode, pReq->user);
if (pUser == NULL) {
terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
goto CREATE_SNODE_OVER;
}
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;
}
int32_t code = mndCreateSnode(pMnode, pReq, pDnode, pCreate);
mndReleaseSnode(pMnode, pObj);
mndReleaseDnode(pMnode, pDnode);
mndReleaseUser(pMnode, pUser);
if (code != 0) {
mError("snode:%d, failed to create since %s", pCreate->dnodeId, terrstr());
return -1;
}
return TSDB_CODE_MND_ACTION_IN_PROGRESS;
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};
mDebug("snode:%d, start to drop", pDrop->dnodeId);
if (tDeserializeSMCreateDropQSBNodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
terrno = TSDB_CODE_INVALID_MSG;
goto DROP_SNODE_OVER;
}
if (pDrop->dnodeId <= 0) {
mDebug("snode:%d, start to drop", dropReq.dnodeId);
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;
}
int32_t code = mndDropSnode(pMnode, pReq, pObj);
if (code != 0) {
sdbRelease(pMnode->pSdb, pObj);
pUser = mndAcquireUser(pMnode, pReq->user);
if (pUser == NULL) {
terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
goto DROP_SNODE_OVER;
}
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) {

112
source/dnode/mnode/impl/test/bnode/bnode.cpp
View File

@ -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);

114
source/dnode/mnode/impl/test/qnode/qnode.cpp
View File

@ -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;

112
source/dnode/mnode/impl/test/snode/snode.cpp
View File

@ -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);