From f63cd651354e784f8ae59c4ff70855564e4bf5e6 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Fri, 11 Feb 2022 17:48:26 +0800 Subject: [PATCH 1/4] refact user msg decoder --- include/common/tmsg.h | 24 +- source/common/src/tmsg.c | 236 +++++++++++++------ source/dnode/mnode/impl/src/mndUser.c | 13 +- source/dnode/mnode/impl/test/trans/trans.cpp | 5 +- source/dnode/mnode/impl/test/user/user.cpp | 147 +++++------- source/libs/parser/src/astToMsg.c | 15 +- 6 files changed, 245 insertions(+), 195 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index a090f6925c..23e3f3ba29 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -349,15 +349,15 @@ typedef struct { int64_t maxStorage; // In unit of GB } SCreateAcctReq, SAlterAcctReq; -int32_t tSerializeSCreateAcctReq(void** buf, SCreateAcctReq* pReq); -void* tDeserializeSCreateAcctReq(void* buf, SCreateAcctReq* pReq); +int32_t tSerializeSCreateAcctReq(void* buf, int32_t bufLen, SCreateAcctReq* pReq); +int32_t tDeserializeSCreateAcctReq(void* buf, int32_t bufLen, SCreateAcctReq* pReq); typedef struct { char user[TSDB_USER_LEN]; } SDropUserReq, SDropAcctReq; -int32_t tSerializeSDropUserReq(void** buf, SDropUserReq* pReq); -void* tDeserializeSDropUserReq(void* buf, SDropUserReq* pReq); +int32_t tSerializeSDropUserReq(void* buf, int32_t bufLen, SDropUserReq* pReq); +int32_t tDeserializeSDropUserReq(void* buf, int32_t bufLen, SDropUserReq* pReq); typedef struct { int8_t createType; @@ -366,8 +366,8 @@ typedef struct { char pass[TSDB_PASSWORD_LEN]; } SCreateUserReq; -int32_t tSerializeSCreateUserReq(void** buf, SCreateUserReq* pReq); -void* tDeserializeSCreateUserReq(void* buf, SCreateUserReq* pReq); +int32_t tSerializeSCreateUserReq(void* buf, int32_t bufLen, SCreateUserReq* pReq); +int32_t tDeserializeSCreateUserReq(void* buf, int32_t bufLen, SCreateUserReq* pReq); typedef struct { int8_t alterType; @@ -377,15 +377,15 @@ typedef struct { char dbname[TSDB_DB_FNAME_LEN]; } SAlterUserReq; -int32_t tSerializeSAlterUserReq(void** buf, SAlterUserReq* pReq); -void* tDeserializeSAlterUserReq(void* buf, SAlterUserReq* pReq); +int32_t tSerializeSAlterUserReq(void* buf, int32_t bufLen, SAlterUserReq* pReq); +int32_t tDeserializeSAlterUserReq(void* buf, int32_t bufLen, SAlterUserReq* pReq); typedef struct { char user[TSDB_USER_LEN]; } SGetUserAuthReq; -int32_t tSerializeSGetUserAuthReq(void** buf, SGetUserAuthReq* pReq); -void* tDeserializeSGetUserAuthReq(void* buf, SGetUserAuthReq* pReq); +int32_t tSerializeSGetUserAuthReq(void* buf, int32_t bufLen, SGetUserAuthReq* pReq); +int32_t tDeserializeSGetUserAuthReq(void* buf, int32_t bufLen, SGetUserAuthReq* pReq); typedef struct { char user[TSDB_USER_LEN]; @@ -394,8 +394,8 @@ typedef struct { SHashObj* writeDbs; } SGetUserAuthRsp; -int32_t tSerializeSGetUserAuthRsp(void** buf, SGetUserAuthRsp* pReq); -void* tDeserializeSGetUserAuthRsp(void* buf, SGetUserAuthRsp* pReq); +int32_t tSerializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pReq); +int32_t tDeserializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pReq); typedef struct { int16_t colId; // column id diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 33add3eb6b..b710d494ff 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -600,142 +600,226 @@ void *tDeserializeSStatusRsp(void *buf, SStatusRsp *pRsp) { return buf; } -int32_t tSerializeSCreateAcctReq(void **buf, SCreateAcctReq *pReq) { - int32_t tlen = 0; - tlen += taosEncodeString(buf, pReq->user); - tlen += taosEncodeString(buf, pReq->pass); - tlen += taosEncodeFixedI32(buf, pReq->maxUsers); - tlen += taosEncodeFixedI32(buf, pReq->maxDbs); - tlen += taosEncodeFixedI32(buf, pReq->maxTimeSeries); - tlen += taosEncodeFixedI32(buf, pReq->maxStreams); - tlen += taosEncodeFixedI32(buf, pReq->accessState); - tlen += taosEncodeFixedI64(buf, pReq->maxStorage); +int32_t tSerializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) { + SCoder encoder = {0}; + tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); + + if (tStartEncode(&encoder) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; + if (tEncodeI32(&encoder, pReq->maxUsers) < 0) return -1; + if (tEncodeI32(&encoder, pReq->maxDbs) < 0) return -1; + if (tEncodeI32(&encoder, pReq->maxTimeSeries) < 0) return -1; + if (tEncodeI32(&encoder, pReq->maxStreams) < 0) return -1; + if (tEncodeI32(&encoder, pReq->accessState) < 0) return -1; + if (tEncodeI64(&encoder, pReq->maxStorage) < 0) return -1; + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); return tlen; } -void *tDeserializeSCreateAcctReq(void *buf, SCreateAcctReq *pReq) { - buf = taosDecodeStringTo(buf, pReq->user); - buf = taosDecodeStringTo(buf, pReq->pass); - buf = taosDecodeFixedI32(buf, &pReq->maxUsers); - buf = taosDecodeFixedI32(buf, &pReq->maxDbs); - buf = taosDecodeFixedI32(buf, &pReq->maxTimeSeries); - buf = taosDecodeFixedI32(buf, &pReq->maxStreams); - buf = taosDecodeFixedI32(buf, &pReq->accessState); - buf = taosDecodeFixedI64(buf, &pReq->maxStorage); - return buf; +int32_t tDeserializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) { + SCoder decoder = {0}; + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER); + + if (tStartDecode(&decoder) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; + if (tDecodeI32(&decoder, &pReq->maxUsers) < 0) return -1; + if (tDecodeI32(&decoder, &pReq->maxDbs) < 0) return -1; + if (tDecodeI32(&decoder, &pReq->maxTimeSeries) < 0) return -1; + if (tDecodeI32(&decoder, &pReq->maxStreams) < 0) return -1; + if (tDecodeI32(&decoder, &pReq->accessState) < 0) return -1; + if (tDecodeI64(&decoder, &pReq->maxStorage) < 0) return -1; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; } -int32_t tSerializeSDropUserReq(void **buf, SDropUserReq *pReq) { - int32_t tlen = 0; - tlen += taosEncodeString(buf, pReq->user); +int32_t tSerializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) { + SCoder encoder = {0}; + tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); + + if (tStartEncode(&encoder) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); return tlen; } -void *tDeserializeSDropUserReq(void *buf, SDropUserReq *pReq) { - buf = taosDecodeStringTo(buf, pReq->user); - return buf; +int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) { + SCoder decoder = {0}; + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER); + + if (tStartDecode(&decoder) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; } -int32_t tSerializeSCreateUserReq(void **buf, SCreateUserReq *pReq) { - int32_t tlen = 0; - tlen += taosEncodeFixedI8(buf, pReq->createType); - tlen += taosEncodeFixedI8(buf, pReq->superUser); - tlen += taosEncodeString(buf, pReq->user); - tlen += taosEncodeString(buf, pReq->pass); +int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { + SCoder encoder = {0}; + tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); + + if (tStartEncode(&encoder) < 0) return -1; + if (tEncodeI8(&encoder, pReq->createType) < 0) return -1; + if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); return tlen; } -void *tDeserializeSCreateUserReq(void *buf, SCreateUserReq *pReq) { - buf = taosDecodeFixedI8(buf, &pReq->createType); - buf = taosDecodeFixedI8(buf, &pReq->superUser); - buf = taosDecodeStringTo(buf, pReq->user); - buf = taosDecodeStringTo(buf, pReq->pass); - return buf; +int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { + SCoder decoder = {0}; + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER); + + if (tStartDecode(&decoder) < 0) return -1; + if (tDecodeI8(&decoder, &pReq->createType) < 0) return -1; + if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; } -int32_t tSerializeSAlterUserReq(void **buf, SAlterUserReq *pReq) { - int32_t tlen = 0; - tlen += taosEncodeFixedI8(buf, pReq->alterType); - tlen += taosEncodeString(buf, pReq->user); - tlen += taosEncodeString(buf, pReq->pass); - tlen += taosEncodeString(buf, pReq->dbname); - tlen += taosEncodeFixedI8(buf, pReq->superUser); +int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { + SCoder encoder = {0}; + tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); + + if (tStartEncode(&encoder) < 0) return -1; + if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1; + if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->dbname) < 0) return -1; + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); return tlen; } -void *tDeserializeSAlterUserReq(void *buf, SAlterUserReq *pReq) { - buf = taosDecodeFixedI8(buf, &pReq->alterType); - buf = taosDecodeStringTo(buf, pReq->user); - buf = taosDecodeStringTo(buf, pReq->pass); - buf = taosDecodeStringTo(buf, pReq->dbname); - buf = taosDecodeFixedI8(buf, &pReq->superUser); - return buf; +int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { + SCoder decoder = {0}; + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER); + + if (tStartDecode(&decoder) < 0) return -1; + if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1; + if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->dbname) < 0) return -1; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; } -int32_t tSerializeSGetUserAuthReq(void **buf, SGetUserAuthReq *pReq) { - int32_t tlen = 0; - tlen += taosEncodeString(buf, pReq->user); +int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { + SCoder encoder = {0}; + tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); + + if (tStartEncode(&encoder) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); return tlen; } -void *tDeserializeSGetUserAuthReq(void *buf, SGetUserAuthReq *pReq) { - buf = taosDecodeStringTo(buf, pReq->user); - return buf; +int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { + SCoder decoder = {0}; + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER); + + if (tStartDecode(&decoder) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; } -int32_t tSerializeSGetUserAuthRsp(void **buf, SGetUserAuthRsp *pReq) { - int32_t tlen = 0; - tlen += taosEncodeString(buf, pReq->user); - tlen += taosEncodeFixedI8(buf, pReq->superAuth); +int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pReq) { + SCoder encoder = {0}; + tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); + + if (tStartEncode(&encoder) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + if (tEncodeI8(&encoder, pReq->superAuth) < 0) return -1; int32_t numOfReadDbs = taosHashGetSize(pReq->readDbs); int32_t numOfWriteDbs = taosHashGetSize(pReq->writeDbs); - tlen += taosEncodeFixedI32(buf, numOfReadDbs); - tlen += taosEncodeFixedI32(buf, numOfWriteDbs); + if (tEncodeI32(&encoder, numOfReadDbs) < 0) return -1; + if (tEncodeI32(&encoder, numOfWriteDbs) < 0) return -1; char *db = taosHashIterate(pReq->readDbs, NULL); while (db != NULL) { - tlen += taosEncodeString(buf, db); + if (tEncodeCStr(&encoder, db) < 0) return -1; db = taosHashIterate(pReq->readDbs, db); } db = taosHashIterate(pReq->writeDbs, NULL); while (db != NULL) { - tlen += taosEncodeString(buf, db); + if (tEncodeCStr(&encoder, db) < 0) return -1; db = taosHashIterate(pReq->writeDbs, db); } + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); return tlen; } -void *tDeserializeSGetUserAuthRsp(void *buf, SGetUserAuthRsp *pReq) { - buf = taosDecodeStringTo(buf, pReq->user); - buf = taosDecodeFixedI8(buf, &pReq->superAuth); - +int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pReq) { pReq->readDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false); pReq->writeDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false); if (pReq->readDbs == NULL || pReq->writeDbs == NULL) { - return NULL; + return -1; } + SCoder decoder = {0}; + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER); + + if (tStartDecode(&decoder) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + if (tDecodeI8(&decoder, &pReq->superAuth) < 0) return -1; + int32_t numOfReadDbs = 0; int32_t numOfWriteDbs = 0; - buf = taosDecodeFixedI32(buf, &numOfReadDbs); - buf = taosDecodeFixedI32(buf, &numOfWriteDbs); + if (tDecodeI32(&decoder, &numOfReadDbs) < 0) return -1; + if (tDecodeI32(&decoder, &numOfWriteDbs) < 0) return -1; for (int32_t i = 0; i < numOfReadDbs; ++i) { char db[TSDB_DB_FNAME_LEN] = {0}; - buf = taosDecodeStringTo(buf, db); + if (tDecodeCStrTo(&decoder, db) < 0) return -1; int32_t len = strlen(db) + 1; taosHashPut(pReq->readDbs, db, len, db, len); } for (int32_t i = 0; i < numOfWriteDbs; ++i) { char db[TSDB_DB_FNAME_LEN] = {0}; - buf = taosDecodeStringTo(buf, db); + if (tDecodeCStrTo(&decoder, db) < 0) return -1; int32_t len = strlen(db) + 1; taosHashPut(pReq->writeDbs, db, len, db, len); } - return buf; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; } diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c index b54200f114..5c290c9c4f 100644 --- a/source/dnode/mnode/impl/src/mndUser.c +++ b/source/dnode/mnode/impl/src/mndUser.c @@ -302,7 +302,7 @@ static int32_t mndProcessCreateUserReq(SMnodeMsg *pReq) { SUserObj *pOperUser = NULL; SCreateUserReq createReq = {0}; - if (tDeserializeSCreateUserReq(pReq->rpcMsg.pCont, &createReq) == NULL) goto CREATE_USER_OVER; + if (tDeserializeSCreateUserReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) goto CREATE_USER_OVER; mDebug("user:%s, start to create", createReq.user); @@ -402,7 +402,7 @@ static int32_t mndProcessAlterUserReq(SMnodeMsg *pReq) { SUserObj newUser = {0}; SAlterUserReq alterReq = {0}; - if (tDeserializeSAlterUserReq(pReq->rpcMsg.pCont, &alterReq) == NULL) goto ALTER_USER_OVER; + if (tDeserializeSAlterUserReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &alterReq) != 0) goto ALTER_USER_OVER; mDebug("user:%s, start to alter", alterReq.user); @@ -537,7 +537,7 @@ static int32_t mndProcessDropUserReq(SMnodeMsg *pReq) { SUserObj *pOperUser = NULL; SDropUserReq dropReq = {0}; - if (tDeserializeSDropUserReq(pReq->rpcMsg.pCont, &dropReq) == NULL) goto DROP_USER_OVER; + if (tDeserializeSDropUserReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) goto DROP_USER_OVER; mDebug("user:%s, start to drop", dropReq.user); @@ -583,7 +583,7 @@ static int32_t mndProcessGetUserAuthReq(SMnodeMsg *pReq) { SGetUserAuthReq authReq = {0}; SGetUserAuthRsp authRsp = {0}; - if (tDeserializeSGetUserAuthReq(pReq->rpcMsg.pCont, &authReq) == NULL) goto GET_AUTH_OVER; + if (tDeserializeSGetUserAuthReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &authReq) != 0) goto GET_AUTH_OVER; mTrace("user:%s, start to get auth", authReq.user); @@ -614,15 +614,14 @@ static int32_t mndProcessGetUserAuthReq(SMnodeMsg *pReq) { sdbRelease(pSdb, pDb); } - int32_t contLen = tSerializeSGetUserAuthRsp(NULL, &authRsp); + int32_t contLen = tSerializeSGetUserAuthRsp(NULL, 0, &authRsp); void *pRsp = rpcMallocCont(contLen); if (pRsp == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; goto GET_AUTH_OVER; } - void *pBuf = pRsp; - tSerializeSGetUserAuthRsp(&pBuf, &authRsp); + tSerializeSGetUserAuthRsp(pRsp, contLen, &authRsp); pReq->pCont = pRsp; pReq->contLen = contLen; diff --git a/source/dnode/mnode/impl/test/trans/trans.cpp b/source/dnode/mnode/impl/test/trans/trans.cpp index 0c9f560fce..68d780a391 100644 --- a/source/dnode/mnode/impl/test/trans/trans.cpp +++ b/source/dnode/mnode/impl/test/trans/trans.cpp @@ -67,10 +67,9 @@ TEST_F(MndTestTrans, 01_Create_User_Crash) { strcpy(createReq.user, "u1"); strcpy(createReq.pass, "p1"); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/dnode/mnode/impl/test/user/user.cpp b/source/dnode/mnode/impl/test/user/user.cpp index 5d8c958f15..8f9edfab09 100644 --- a/source/dnode/mnode/impl/test/user/user.cpp +++ b/source/dnode/mnode/impl/test/user/user.cpp @@ -49,10 +49,9 @@ TEST_F(MndTestUser, 02_Create_User) { strcpy(createReq.user, ""); strcpy(createReq.pass, "p1"); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -64,10 +63,9 @@ TEST_F(MndTestUser, 02_Create_User) { strcpy(createReq.user, "u1"); strcpy(createReq.pass, ""); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -79,10 +77,9 @@ TEST_F(MndTestUser, 02_Create_User) { strcpy(createReq.user, "root"); strcpy(createReq.pass, "1"); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -94,10 +91,9 @@ TEST_F(MndTestUser, 02_Create_User) { strcpy(createReq.user, "u1"); strcpy(createReq.pass, "p1"); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -121,10 +117,9 @@ TEST_F(MndTestUser, 02_Create_User) { SDropUserReq dropReq = {0}; strcpy(dropReq.user, "u1"); - int32_t contLen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t contLen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -141,10 +136,9 @@ TEST_F(MndTestUser, 02_Create_User) { strcpy(createReq.pass, "p1"); createReq.superUser = 1; - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -168,10 +162,9 @@ TEST_F(MndTestUser, 02_Create_User) { SDropUserReq dropReq = {0}; strcpy(dropReq.user, "u2"); - int32_t contLen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t contLen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -190,10 +183,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(createReq.pass, "p1"); createReq.superUser = 1; - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -210,10 +202,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.user, ""); strcpy(alterReq.pass, "p1"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -226,10 +217,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.user, "u3"); strcpy(alterReq.pass, ""); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -242,10 +232,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.user, "u4"); strcpy(alterReq.pass, "1"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -258,10 +247,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.user, "u3"); strcpy(alterReq.pass, "1"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -275,10 +263,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.pass, "1"); alterReq.superUser = 1; - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -291,10 +278,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.user, "u3"); strcpy(alterReq.pass, "1"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -307,10 +293,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.user, "u3"); strcpy(alterReq.pass, "1"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -324,10 +309,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.pass, "1"); strcpy(alterReq.dbname, "d1"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -371,10 +355,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.pass, "1"); strcpy(alterReq.dbname, "1.d2"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -388,10 +371,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.pass, "1"); strcpy(alterReq.dbname, "1.d2"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -401,17 +383,16 @@ TEST_F(MndTestUser, 03_Alter_User) { { SGetUserAuthReq authReq = {0}; strcpy(authReq.user, "u3"); - int32_t contLen = tSerializeSGetUserAuthReq(NULL, &authReq); + int32_t contLen = tSerializeSGetUserAuthReq(NULL, 0, &authReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSGetUserAuthReq(&pBuf, &authReq); + tSerializeSGetUserAuthReq(pReq, contLen, &authReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_GET_USER_AUTH, pReq, contLen); ASSERT_NE(pRsp, nullptr); ASSERT_EQ(pRsp->code, 0); SGetUserAuthRsp authRsp = {0}; - tDeserializeSGetUserAuthRsp(pRsp->pCont, &authRsp); + tDeserializeSGetUserAuthRsp(pRsp->pCont, pRsp->contLen, &authRsp); EXPECT_STREQ(authRsp.user, "u3"); EXPECT_EQ(authRsp.superAuth, 1); int32_t numOfReadDbs = taosHashGetSize(authRsp.readDbs); @@ -433,10 +414,9 @@ TEST_F(MndTestUser, 03_Alter_User) { strcpy(alterReq.pass, "1"); strcpy(alterReq.dbname, "1.d2"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -447,10 +427,9 @@ TEST_F(MndTestUser, 03_Alter_User) { SDropUserReq dropReq = {0}; strcpy(dropReq.user, "u3"); - int32_t contLen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t contLen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -467,10 +446,9 @@ TEST_F(MndTestUser, 05_Drop_User) { SDropUserReq dropReq = {0}; strcpy(dropReq.user, ""); - int32_t contLen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t contLen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -481,10 +459,9 @@ TEST_F(MndTestUser, 05_Drop_User) { SDropUserReq dropReq = {0}; strcpy(dropReq.user, "u4"); - int32_t contLen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t contLen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -496,10 +473,9 @@ TEST_F(MndTestUser, 05_Drop_User) { strcpy(createReq.user, "u1"); strcpy(createReq.pass, "p1"); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -510,10 +486,9 @@ TEST_F(MndTestUser, 05_Drop_User) { SDropUserReq dropReq = {0}; strcpy(dropReq.user, "u1"); - int32_t contLen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t contLen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -533,10 +508,9 @@ TEST_F(MndTestUser, 06_Create_Drop_Alter_User) { strcpy(createReq.user, "u1"); strcpy(createReq.pass, "p1"); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -548,10 +522,9 @@ TEST_F(MndTestUser, 06_Create_Drop_Alter_User) { strcpy(createReq.user, "u2"); strcpy(createReq.pass, "p2"); - int32_t contLen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t contLen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -583,10 +556,9 @@ TEST_F(MndTestUser, 06_Create_Drop_Alter_User) { strcpy(alterReq.user, "u1"); strcpy(alterReq.pass, "p2"); - int32_t contLen = tSerializeSAlterUserReq(NULL, &alterReq); + int32_t contLen = tSerializeSAlterUserReq(NULL, 0, &alterReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSAlterUserReq(&pBuf, &alterReq); + tSerializeSAlterUserReq(pReq, contLen, &alterReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -616,10 +588,9 @@ TEST_F(MndTestUser, 06_Create_Drop_Alter_User) { SDropUserReq dropReq = {0}; strcpy(dropReq.user, "u1"); - int32_t contLen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t contLen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = rpcMallocCont(contLen); - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_USER, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/libs/parser/src/astToMsg.c b/source/libs/parser/src/astToMsg.c index 15ad283438..2c9e9df505 100644 --- a/source/libs/parser/src/astToMsg.c +++ b/source/libs/parser/src/astToMsg.c @@ -16,15 +16,14 @@ char* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, strncpy(createReq.pass, pUser->passwd.z, pUser->passwd.n); } - int32_t tlen = tSerializeSCreateUserReq(NULL, &createReq); + int32_t tlen = tSerializeSCreateUserReq(NULL, 0, &createReq); void* pReq = malloc(tlen); if (pReq == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - void* pBuf = pReq; - tSerializeSCreateUserReq(&pBuf, &createReq); + tSerializeSCreateUserReq(pReq, tlen, &createReq); *outputLen = tlen; return pReq; } @@ -63,15 +62,14 @@ char* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, } } - int32_t tlen = tSerializeSCreateAcctReq(NULL, &createReq); + int32_t tlen = tSerializeSCreateAcctReq(NULL, 0, &createReq); void* pReq = malloc(tlen); if (pReq == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - void* pBuf = pReq; - tSerializeSCreateAcctReq(&pBuf, &createReq); + tSerializeSCreateAcctReq(pReq, tlen, &createReq); *outputLen = tlen; return pReq; } @@ -86,15 +84,14 @@ char* buildDropUserMsg(SSqlInfo* pInfo, int32_t* msgLen, int64_t id, char* msgBu strncpy(dropReq.user, pName->z, pName->n); - int32_t tlen = tSerializeSDropUserReq(NULL, &dropReq); + int32_t tlen = tSerializeSDropUserReq(NULL, 0, &dropReq); void* pReq = malloc(tlen); if (pReq == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - void* pBuf = pReq; - tSerializeSDropUserReq(&pBuf, &dropReq); + tSerializeSDropUserReq(pReq, tlen, &dropReq); *msgLen = tlen; return pReq; } From 34361b11a0a3a9df8df041223c2390a924bb32ba Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Sat, 12 Feb 2022 11:39:58 +0800 Subject: [PATCH 2/4] serialize node msg --- include/common/tmsg.h | 12 +- source/common/src/tmsg.c | 25 ++++ source/dnode/mnode/impl/inc/mndAuth.h | 4 + source/dnode/mnode/impl/src/mndAuth.c | 15 ++- source/dnode/mnode/impl/src/mndBnode.c | 111 ++++++++++++------ source/dnode/mnode/impl/src/mndQnode.c | 107 +++++++++++------ source/dnode/mnode/impl/src/mndSnode.c | 107 +++++++++++------ source/dnode/mnode/impl/test/bnode/bnode.cpp | 112 +++++++++++------- source/dnode/mnode/impl/test/qnode/qnode.cpp | 114 ++++++++++++------- source/dnode/mnode/impl/test/snode/snode.cpp | 112 +++++++++++------- 10 files changed, 477 insertions(+), 242 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index f48e0bab9f..743b23a030 100644 --- a/include/common/tmsg.h +++ b/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]; diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index b710d494ff..71c5a895d6 100644 --- a/source/common/src/tmsg.c +++ b/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; +} diff --git a/source/dnode/mnode/impl/inc/mndAuth.h b/source/dnode/mnode/impl/inc/mndAuth.h index c37ae7add5..65b8642572 100644 --- a/source/dnode/mnode/impl/inc/mndAuth.h +++ b/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 diff --git a/source/dnode/mnode/impl/src/mndAuth.c b/source/dnode/mnode/impl/src/mndAuth.c index 99b48adb85..f4e385bbf6 100644 --- a/source/dnode/mnode/impl/src/mndAuth.c +++ b/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); } diff --git a/source/dnode/mnode/impl/src/mndBnode.c b/source/dnode/mnode/impl/src/mndBnode.c index c754494c24..668fe27d2c 100644 --- a/source/dnode/mnode/impl/src/mndBnode.c +++ b/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; + 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) { diff --git a/source/dnode/mnode/impl/src/mndQnode.c b/source/dnode/mnode/impl/src/mndQnode.c index e29ab5a5bd..344f0d9e40 100644 --- a/source/dnode/mnode/impl/src/mndQnode.c +++ b/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; + 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) { diff --git a/source/dnode/mnode/impl/src/mndSnode.c b/source/dnode/mnode/impl/src/mndSnode.c index cbba659719..0e33daed9f 100644 --- a/source/dnode/mnode/impl/src/mndSnode.c +++ b/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; + 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) { diff --git a/source/dnode/mnode/impl/test/bnode/bnode.cpp b/source/dnode/mnode/impl/test/bnode/bnode.cpp index 0b54a9bf4a..c5478d7447 100644 --- a/source/dnode/mnode/impl/test/bnode/bnode.cpp +++ b/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); diff --git a/source/dnode/mnode/impl/test/qnode/qnode.cpp b/source/dnode/mnode/impl/test/qnode/qnode.cpp index 8a9e087e7f..b6faebbf71 100644 --- a/source/dnode/mnode/impl/test/qnode/qnode.cpp +++ b/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; diff --git a/source/dnode/mnode/impl/test/snode/snode.cpp b/source/dnode/mnode/impl/test/snode/snode.cpp index 3a38b9ede6..4962c7abd4 100644 --- a/source/dnode/mnode/impl/test/snode/snode.cpp +++ b/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); From c4efa321c1b774b676b238c3796ef295b7c4092f Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Sat, 12 Feb 2022 11:58:40 +0800 Subject: [PATCH 3/4] serialize dnode msg --- include/common/tmsg.h | 13 ++++++++ include/util/tdef.h | 1 + source/common/src/tmsg.c | 72 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 86 insertions(+) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 743b23a030..c05bbff050 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -851,19 +851,32 @@ typedef struct { int32_t port; } SCreateDnodeReq; +int32_t tSerializeSCreateDnodeReq(void* buf, int32_t bufLen, SCreateDnodeReq* pReq); +int32_t tDeserializeSCreateDnodeReq(void* buf, int32_t bufLen, SCreateDnodeReq* pReq); + typedef struct { int32_t dnodeId; } SDropDnodeReq; +int32_t tSerializeSDropDnodeReq(void* buf, int32_t bufLen, SDropDnodeReq* pReq); +int32_t tDeserializeSDropDnodeReq(void* buf, int32_t bufLen, SDropDnodeReq* pReq); + typedef struct { int32_t dnodeId; char config[TSDB_DNODE_CONFIG_LEN]; + char value[TSDB_DNODE_VALUE_LEN]; } SMCfgDnodeReq, SDCfgDnodeReq; +int32_t tSerializeSMCfgDnodeReq(void* buf, int32_t bufLen, SMCfgDnodeReq* pReq); +int32_t tDeserializeSMCfgDnodeReq(void* buf, int32_t bufLen, SMCfgDnodeReq* pReq); + typedef struct { int32_t dnodeId; } SMCreateMnodeReq, SMDropMnodeReq, SDDropMnodeReq; +int32_t tSerializeSMCreateDropMnodeReq(void* buf, int32_t bufLen, SMCreateMnodeReq* pReq); +int32_t tDeserializeSMCreateDropMnodeReq(void* buf, int32_t bufLen, SMCreateMnodeReq* pReq); + typedef struct { int32_t dnodeId; int8_t replica; diff --git a/include/util/tdef.h b/include/util/tdef.h index 88b526f102..747020a4f9 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -219,6 +219,7 @@ do { \ #define TSDB_ERROR_MSG_LEN 1024 #define TSDB_DNODE_CONFIG_LEN 128 +#define TSDB_DNODE_VALUE_LEN 256 #define TSDB_MQTT_HOSTNAME_LEN 64 #define TSDB_MQTT_PORT_LEN 8 diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 71c5a895d6..65b9252fbb 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -848,3 +848,75 @@ int32_t tDeserializeSMCreateDropQSBNodeReq(void *buf, int32_t bufLen, SMCreateQn tCoderClear(&decoder); return 0; } + +int32_t tSerializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) { + return tSerializeSMCreateDropQSBNodeReq(buf, bufLen, (SMCreateQnodeReq *)pReq); +} + +int32_t tDeserializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) { + return tDeserializeSMCreateDropQSBNodeReq(buf, bufLen, (SMCreateQnodeReq *)pReq); +} + +int32_t tSerializeSMCreateDropMnodeReq(void *buf, int32_t bufLen, SMCreateMnodeReq *pReq) { + return tSerializeSMCreateDropQSBNodeReq(buf, bufLen, (SMCreateQnodeReq *)pReq); +} + +int32_t tDeserializeSMCreateDropMnodeReq(void *buf, int32_t bufLen, SMCreateMnodeReq *pReq) { + return tDeserializeSMCreateDropQSBNodeReq(buf, bufLen, (SMCreateQnodeReq *)pReq); +} + +int32_t tSerializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *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; + if (tEncodeCStr(&encoder, pReq->config) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->value) < 0) return -1; + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); + return tlen; +} + +int32_t tDeserializeSMCfgDnodeReq(void *buf, int32_t bufLen, SMCfgDnodeReq *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; + if (tDecodeCStrTo(&decoder, pReq->config) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->value) < 0) return -1; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; +} + +int32_t tSerializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) { + SCoder encoder = {0}; + tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); + + if (tStartEncode(&encoder) < 0) return -1; + if (tEncodeCStr(&encoder, pReq->fqdn) < 0) return -1; + if (tEncodeI32(&encoder, pReq->port) < 0) return -1; + tEndEncode(&encoder); + + int32_t tlen = encoder.pos; + tCoderClear(&encoder); + return tlen; +} + +int32_t tDeserializeSCreateDnodeReq(void *buf, int32_t bufLen, SCreateDnodeReq *pReq) { + SCoder decoder = {0}; + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER); + + if (tStartDecode(&decoder) < 0) return -1; + if (tDecodeCStrTo(&decoder, pReq->fqdn) < 0) return -1; + if (tDecodeI32(&decoder, &pReq->port) < 0) return -1; + tEndDecode(&decoder); + + tCoderClear(&decoder); + return 0; +} From b8bda48a358183de4f2e8e50b56b01b63d7069e6 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Sat, 12 Feb 2022 14:06:13 +0800 Subject: [PATCH 4/4] serialize msg --- source/dnode/mnode/impl/src/mndDnode.c | 115 +++++++++++++------ source/dnode/mnode/impl/test/bnode/bnode.cpp | 10 +- source/dnode/mnode/impl/test/dnode/dnode.cpp | 112 +++++++++++------- source/dnode/mnode/impl/test/mnode/mnode.cpp | 10 +- source/dnode/mnode/impl/test/qnode/qnode.cpp | 10 +- source/dnode/mnode/impl/test/snode/snode.cpp | 10 +- source/dnode/mnode/impl/test/trans/trans.cpp | 42 ++++--- source/libs/parser/inc/astToMsg.h | 4 +- source/libs/parser/src/astToMsg.c | 109 ++++++++++-------- 9 files changed, 258 insertions(+), 164 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c index 93c6b492bd..26f4f58f45 100644 --- a/source/dnode/mnode/impl/src/mndDnode.c +++ b/source/dnode/mnode/impl/src/mndDnode.c @@ -15,9 +15,11 @@ #define _DEFAULT_SOURCE #include "mndDnode.h" +#include "mndAuth.h" #include "mndMnode.h" #include "mndShow.h" #include "mndTrans.h" +#include "mndUser.h" #include "mndVgroup.h" #define TSDB_DNODE_VER_NUMBER 1 @@ -354,7 +356,8 @@ static int32_t mndProcessStatusReq(SMnodeMsg *pReq) { if (pDnode != NULL) { pDnode->offlineReason = DND_REASON_VERSION_NOT_MATCH; } - mError("dnode:%d, status msg version:%d not match cluster:%d", statusReq.dnodeId, statusReq.sver, pMnode->cfg.sver); + mError("dnode:%d, status msg version:%d not match cluster:%d", statusReq.dnodeId, statusReq.sver, + pMnode->cfg.sver); terrno = TSDB_CODE_MND_INVALID_MSG_VERSION; goto PROCESS_STATUS_MSG_OVER; } @@ -461,35 +464,54 @@ static int32_t mndCreateDnode(SMnode *pMnode, SMnodeMsg *pReq, SCreateDnodeReq * } static int32_t mndProcessCreateDnodeReq(SMnodeMsg *pReq) { - SMnode *pMnode = pReq->pMnode; - SCreateDnodeReq *pCreate = pReq->rpcMsg.pCont; - pCreate->port = htonl(pCreate->port); - mDebug("dnode:%s:%d, start to create", pCreate->fqdn, pCreate->port); + SMnode *pMnode = pReq->pMnode; + int32_t code = -1; + SUserObj *pUser = NULL; + SDnodeObj *pDnode = NULL; + SCreateDnodeReq createReq = {0}; - if (pCreate->fqdn[0] == 0 || pCreate->port <= 0 || pCreate->port > UINT16_MAX) { + if (tDeserializeSCreateDnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) { + terrno = TSDB_CODE_INVALID_MSG; + goto CREATE_DNODE_OVER; + } + + mDebug("dnode:%s:%d, start to create", createReq.fqdn, createReq.port); + + if (createReq.fqdn[0] == 0 || createReq.port <= 0 || createReq.port > UINT16_MAX) { terrno = TSDB_CODE_MND_INVALID_DNODE_EP; - mError("dnode:%s:%d, failed to create since %s", pCreate->fqdn, pCreate->port, terrstr()); - return -1; + goto CREATE_DNODE_OVER; } char ep[TSDB_EP_LEN]; - snprintf(ep, TSDB_EP_LEN, "%s:%d", pCreate->fqdn, pCreate->port); - SDnodeObj *pDnode = mndAcquireDnodeByEp(pMnode, ep); + snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port); + pDnode = mndAcquireDnodeByEp(pMnode, ep); if (pDnode != NULL) { - mError("dnode:%d, already exist, %s:%u", pDnode->id, pCreate->fqdn, pCreate->port); - mndReleaseDnode(pMnode, pDnode); terrno = TSDB_CODE_MND_DNODE_ALREADY_EXIST; + goto CREATE_DNODE_OVER; + } + + pUser = mndAcquireUser(pMnode, pReq->user); + if (pUser == NULL) { + terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; + goto CREATE_DNODE_OVER; + } + + if (mndCheckDropNodeAuth(pUser)) { + goto CREATE_DNODE_OVER; + } + + code = mndCreateDnode(pMnode, pReq, &createReq); + if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; + +CREATE_DNODE_OVER: + if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { + mError("dnode:%s:%d, failed to create since %s", createReq.fqdn, createReq.port, terrstr()); return -1; } - int32_t code = mndCreateDnode(pMnode, pReq, pCreate); - - if (code != 0) { - mError("dnode:%s:%d, failed to create since %s", pCreate->fqdn, pCreate->port, terrstr()); - return -1; - } - - return TSDB_CODE_MND_ACTION_IN_PROGRESS; + mndReleaseDnode(pMnode, pDnode); + mndReleaseUser(pMnode, pUser); + return code; } static int32_t mndDropDnode(SMnode *pMnode, SMnodeMsg *pReq, SDnodeObj *pDnode) { @@ -519,34 +541,53 @@ static int32_t mndDropDnode(SMnode *pMnode, SMnodeMsg *pReq, SDnodeObj *pDnode) } static int32_t mndProcessDropDnodeReq(SMnodeMsg *pReq) { - SMnode *pMnode = pReq->pMnode; - SDropDnodeReq *pDrop = pReq->rpcMsg.pCont; - pDrop->dnodeId = htonl(pDrop->dnodeId); + SMnode *pMnode = pReq->pMnode; + int32_t code = -1; + SUserObj *pUser = NULL; + SDnodeObj *pDnode = NULL; + SDropDnodeReq dropReq = {0}; - mDebug("dnode:%d, start to drop", pDrop->dnodeId); - - if (pDrop->dnodeId <= 0) { - terrno = TSDB_CODE_MND_INVALID_DNODE_ID; - mError("dnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr()); - return -1; + if (tDeserializeSDropDnodeReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) { + terrno = TSDB_CODE_INVALID_MSG; + goto DROP_DNODE_OVER; } - SDnodeObj *pDnode = mndAcquireDnode(pMnode, pDrop->dnodeId); + mDebug("dnode:%d, start to drop", dropReq.dnodeId); + + if (dropReq.dnodeId <= 0) { + terrno = TSDB_CODE_MND_INVALID_DNODE_ID; + goto DROP_DNODE_OVER; + } + + pDnode = mndAcquireDnode(pMnode, dropReq.dnodeId); if (pDnode == NULL) { terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; - mError("dnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr()); - return -1; + goto DROP_DNODE_OVER; } - int32_t code = mndDropDnode(pMnode, pReq, pDnode); - if (code != 0) { - mndReleaseDnode(pMnode, pDnode); - mError("dnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr()); + pUser = mndAcquireUser(pMnode, pReq->user); + if (pUser == NULL) { + terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; + goto DROP_DNODE_OVER; + } + + if (mndCheckCreateNodeAuth(pUser)) { + goto DROP_DNODE_OVER; + } + + code = mndDropDnode(pMnode, pReq, pDnode); + if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; + +DROP_DNODE_OVER: + if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { + mError("dnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr()); return -1; } mndReleaseDnode(pMnode, pDnode); - return TSDB_CODE_MND_ACTION_IN_PROGRESS; + mndReleaseUser(pMnode, pUser); + + return code; } static int32_t mndProcessConfigDnodeReq(SMnodeMsg *pReq) { diff --git a/source/dnode/mnode/impl/test/bnode/bnode.cpp b/source/dnode/mnode/impl/test/bnode/bnode.cpp index c5478d7447..d7d15df35a 100644 --- a/source/dnode/mnode/impl/test/bnode/bnode.cpp +++ b/source/dnode/mnode/impl/test/bnode/bnode.cpp @@ -102,11 +102,13 @@ TEST_F(MndTestBnode, 02_Create_Bnode) { TEST_F(MndTestBnode, 03_Drop_Bnode) { { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9019; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9019); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/dnode/mnode/impl/test/dnode/dnode.cpp b/source/dnode/mnode/impl/test/dnode/dnode.cpp index 1c0cfb7bfc..9af0aad1ae 100644 --- a/source/dnode/mnode/impl/test/dnode/dnode.cpp +++ b/source/dnode/mnode/impl/test/dnode/dnode.cpp @@ -88,11 +88,13 @@ TEST_F(MndTestDnode, 02_ConfigDnode) { TEST_F(MndTestDnode, 03_Create_Dnode) { { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, ""); + createReq.port = 9024; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, ""); - pReq->port = htonl(9024); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -100,11 +102,13 @@ TEST_F(MndTestDnode, 03_Create_Dnode) { } { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = -1; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(-1); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -112,11 +116,13 @@ TEST_F(MndTestDnode, 03_Create_Dnode) { } { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 123456; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(123456); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -124,11 +130,13 @@ TEST_F(MndTestDnode, 03_Create_Dnode) { } { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9024; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9024); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -136,11 +144,13 @@ TEST_F(MndTestDnode, 03_Create_Dnode) { } { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9024; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9024); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -172,10 +182,12 @@ TEST_F(MndTestDnode, 03_Create_Dnode) { TEST_F(MndTestDnode, 04_Drop_Dnode) { { - int32_t contLen = sizeof(SDropDnodeReq); + SDropDnodeReq dropReq = {0}; + dropReq.dnodeId = -3; - SDropDnodeReq* pReq = (SDropDnodeReq*)rpcMallocCont(contLen); - pReq->dnodeId = htonl(-3); + int32_t contLen = tSerializeSDropDnodeReq(NULL, 0, &dropReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSDropDnodeReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -183,10 +195,12 @@ TEST_F(MndTestDnode, 04_Drop_Dnode) { } { - int32_t contLen = sizeof(SDropDnodeReq); + SDropDnodeReq dropReq = {0}; + dropReq.dnodeId = 5; - SDropDnodeReq* pReq = (SDropDnodeReq*)rpcMallocCont(contLen); - pReq->dnodeId = htonl(5); + int32_t contLen = tSerializeSDropDnodeReq(NULL, 0, &dropReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSDropDnodeReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -194,10 +208,12 @@ TEST_F(MndTestDnode, 04_Drop_Dnode) { } { - int32_t contLen = sizeof(SDropDnodeReq); + SDropDnodeReq dropReq = {0}; + dropReq.dnodeId = 2; - SDropDnodeReq* pReq = (SDropDnodeReq*)rpcMallocCont(contLen); - pReq->dnodeId = htonl(2); + int32_t contLen = tSerializeSDropDnodeReq(NULL, 0, &dropReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSDropDnodeReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -205,10 +221,12 @@ TEST_F(MndTestDnode, 04_Drop_Dnode) { } { - int32_t contLen = sizeof(SDropDnodeReq); + SDropDnodeReq dropReq = {0}; + dropReq.dnodeId = 2; - SDropDnodeReq* pReq = (SDropDnodeReq*)rpcMallocCont(contLen); - pReq->dnodeId = htonl(2); + int32_t contLen = tSerializeSDropDnodeReq(NULL, 0, &dropReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSDropDnodeReq(pReq, contLen, &dropReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -235,11 +253,13 @@ TEST_F(MndTestDnode, 04_Drop_Dnode) { TEST_F(MndTestDnode, 05_Create_Drop_Restart_Dnode) { { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9025; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9025); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -247,11 +267,13 @@ TEST_F(MndTestDnode, 05_Create_Drop_Restart_Dnode) { } { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9026; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9026); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -259,11 +281,13 @@ TEST_F(MndTestDnode, 05_Create_Drop_Restart_Dnode) { } { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9027; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9027); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/dnode/mnode/impl/test/mnode/mnode.cpp b/source/dnode/mnode/impl/test/mnode/mnode.cpp index c69c86eb1c..208c40e66d 100644 --- a/source/dnode/mnode/impl/test/mnode/mnode.cpp +++ b/source/dnode/mnode/impl/test/mnode/mnode.cpp @@ -87,11 +87,13 @@ TEST_F(MndTestMnode, 03_Create_Mnode_Invalid_Id) { TEST_F(MndTestMnode, 04_Create_Mnode) { { // create dnode - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9029; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9029); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/dnode/mnode/impl/test/qnode/qnode.cpp b/source/dnode/mnode/impl/test/qnode/qnode.cpp index b6faebbf71..d4e308268a 100644 --- a/source/dnode/mnode/impl/test/qnode/qnode.cpp +++ b/source/dnode/mnode/impl/test/qnode/qnode.cpp @@ -102,11 +102,13 @@ TEST_F(MndTestQnode, 02_Create_Qnode) { TEST_F(MndTestQnode, 03_Drop_Qnode) { { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9015; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9015); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/dnode/mnode/impl/test/snode/snode.cpp b/source/dnode/mnode/impl/test/snode/snode.cpp index 4962c7abd4..a38fb5d604 100644 --- a/source/dnode/mnode/impl/test/snode/snode.cpp +++ b/source/dnode/mnode/impl/test/snode/snode.cpp @@ -102,11 +102,13 @@ TEST_F(MndTestSnode, 02_Create_Snode) { TEST_F(MndTestSnode, 03_Drop_Snode) { { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9017; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9017); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); diff --git a/source/dnode/mnode/impl/test/trans/trans.cpp b/source/dnode/mnode/impl/test/trans/trans.cpp index 68d780a391..8a62ed639a 100644 --- a/source/dnode/mnode/impl/test/trans/trans.cpp +++ b/source/dnode/mnode/impl/test/trans/trans.cpp @@ -100,10 +100,12 @@ TEST_F(MndTestTrans, 01_Create_User_Crash) { TEST_F(MndTestTrans, 02_Create_Qnode1_Crash) { { - 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); @@ -117,10 +119,12 @@ TEST_F(MndTestTrans, 02_Create_Qnode1_Crash) { KillThenRestartServer(); { - 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); @@ -135,11 +139,13 @@ TEST_F(MndTestTrans, 02_Create_Qnode1_Crash) { TEST_F(MndTestTrans, 03_Create_Qnode2_Crash) { { - int32_t contLen = sizeof(SCreateDnodeReq); + SCreateDnodeReq createReq = {0}; + strcpy(createReq.fqdn, "localhost"); + createReq.port = 9020; - SCreateDnodeReq* pReq = (SCreateDnodeReq*)rpcMallocCont(contLen); - strcpy(pReq->fqdn, "localhost"); - pReq->port = htonl(9020); + int32_t contLen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateDnodeReq(pReq, contLen, &createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DNODE, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -152,10 +158,12 @@ TEST_F(MndTestTrans, 03_Create_Qnode2_Crash) { } { - 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); @@ -172,10 +180,12 @@ TEST_F(MndTestTrans, 03_Create_Qnode2_Crash) { 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); diff --git a/source/libs/parser/inc/astToMsg.h b/source/libs/parser/inc/astToMsg.h index 2e08a3afcc..d7b6469abb 100644 --- a/source/libs/parser/inc/astToMsg.h +++ b/source/libs/parser/inc/astToMsg.h @@ -12,7 +12,7 @@ SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseContext* pParseCtx, SMsgBuf* SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext *pCtx, SMsgBuf* pMsgBuf); char* buildCreateStbReq(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf); char* buildDropStableReq(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf); -SCreateDnodeReq *buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf); -SDropDnodeReq *buildDropDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf); +char* buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf); +char* buildDropDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf); #endif // TDENGINE_ASTTOMSG_H diff --git a/source/libs/parser/src/astToMsg.c b/source/libs/parser/src/astToMsg.c index 2c9e9df505..1fae979ee9 100644 --- a/source/libs/parser/src/astToMsg.c +++ b/source/libs/parser/src/astToMsg.c @@ -1,5 +1,5 @@ -#include "parserInt.h" #include "astGenerator.h" +#include "parserInt.h" #include "parserUtil.h" char* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen) { @@ -96,7 +96,7 @@ char* buildDropUserMsg(SSqlInfo* pInfo, int32_t* msgLen, int64_t id, char* msgBu return pReq; } -SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseContext *pCtx, SMsgBuf* pMsgBuf) { +SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseContext* pCtx, SMsgBuf* pMsgBuf) { SShowReq* pShowMsg = calloc(1, sizeof(SShowReq)); if (pShowMsg == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -155,27 +155,27 @@ static int32_t setKeepOption(SCreateDbReq* pMsg, const SCreateDbInfo* pCreateDb, if (pKeep != NULL) { size_t s = taosArrayGetSize(pKeep); #ifdef _STORAGE - if (s >= 4 ||s <= 0) { + if (s >= 4 || s <= 0) { #else if (s != 1) { #endif return buildInvalidOperationMsg(pMsgBuf, msg1); } -// tListI* p0 = taosArrayGet(pKeep, 0); -// tVariantListItem* p1 = (s > 1) ? taosArrayGet(pKeep, 1) : p0; -// tVariantListItem* p2 = (s > 2) ? taosArrayGet(pKeep, 2) : p1; -// -// if ((int32_t)p0->pVar.i64 <= 0 || (int32_t)p1->pVar.i64 <= 0 || (int32_t)p2->pVar.i64 <= 0) { -// return buildInvalidOperationMsg(pMsgBuf, msg2); -// } -// if (!(((int32_t)p0->pVar.i64 <= (int32_t)p1->pVar.i64) && ((int32_t)p1->pVar.i64 <= (int32_t)p2->pVar.i64))) { -// return buildInvalidOperationMsg(pMsgBuf, msg3); -// } -// -// pMsg->daysToKeep0 = htonl((int32_t)p0->pVar.i64); -// pMsg->daysToKeep1 = htonl((int32_t)p1->pVar.i64); -// pMsg->daysToKeep2 = htonl((int32_t)p2->pVar.i64); + // tListI* p0 = taosArrayGet(pKeep, 0); + // tVariantListItem* p1 = (s > 1) ? taosArrayGet(pKeep, 1) : p0; + // tVariantListItem* p2 = (s > 2) ? taosArrayGet(pKeep, 2) : p1; + // + // if ((int32_t)p0->pVar.i64 <= 0 || (int32_t)p1->pVar.i64 <= 0 || (int32_t)p2->pVar.i64 <= 0) { + // return buildInvalidOperationMsg(pMsgBuf, msg2); + // } + // if (!(((int32_t)p0->pVar.i64 <= (int32_t)p1->pVar.i64) && ((int32_t)p1->pVar.i64 <= (int32_t)p2->pVar.i64))) { + // return buildInvalidOperationMsg(pMsgBuf, msg3); + // } + // + // pMsg->daysToKeep0 = htonl((int32_t)p0->pVar.i64); + // pMsg->daysToKeep1 = htonl((int32_t)p1->pVar.i64); + // pMsg->daysToKeep2 = htonl((int32_t)p2->pVar.i64); } return TSDB_CODE_SUCCESS; @@ -186,7 +186,7 @@ static int32_t setTimePrecision(SCreateDbReq* pMsg, const SCreateDbInfo* pCreate pMsg->precision = TSDB_TIME_PRECISION_MILLI; // millisecond by default - SToken* pToken = (SToken*) &pCreateDbInfo->precision; + SToken* pToken = (SToken*)&pCreateDbInfo->precision; if (pToken->n > 0) { pToken->n = strdequote(pToken->z); @@ -210,20 +210,20 @@ static int32_t setTimePrecision(SCreateDbReq* pMsg, const SCreateDbInfo* pCreate static void doSetDbOptions(SCreateDbReq* pMsg, const SCreateDbInfo* pCreateDb) { pMsg->cacheBlockSize = htonl(pCreateDb->cacheBlockSize); - pMsg->totalBlocks = htonl(pCreateDb->numOfBlocks); - pMsg->daysPerFile = htonl(pCreateDb->daysPerFile); - pMsg->commitTime = htonl((int32_t)pCreateDb->commitTime); - pMsg->minRows = htonl(pCreateDb->minRowsPerBlock); - pMsg->maxRows = htonl(pCreateDb->maxRowsPerBlock); - pMsg->fsyncPeriod = htonl(pCreateDb->fsyncPeriod); - pMsg->compression = (int8_t) pCreateDb->compressionLevel; - pMsg->walLevel = (char)pCreateDb->walLevel; - pMsg->replications = pCreateDb->replica; - pMsg->quorum = pCreateDb->quorum; - pMsg->ignoreExist = pCreateDb->ignoreExists; - pMsg->update = pCreateDb->update; - pMsg->cacheLastRow = pCreateDb->cachelast; - pMsg->numOfVgroups = htonl(pCreateDb->numOfVgroups); + pMsg->totalBlocks = htonl(pCreateDb->numOfBlocks); + pMsg->daysPerFile = htonl(pCreateDb->daysPerFile); + pMsg->commitTime = htonl((int32_t)pCreateDb->commitTime); + pMsg->minRows = htonl(pCreateDb->minRowsPerBlock); + pMsg->maxRows = htonl(pCreateDb->maxRowsPerBlock); + pMsg->fsyncPeriod = htonl(pCreateDb->fsyncPeriod); + pMsg->compression = (int8_t)pCreateDb->compressionLevel; + pMsg->walLevel = (char)pCreateDb->walLevel; + pMsg->replications = pCreateDb->replica; + pMsg->quorum = pCreateDb->quorum; + pMsg->ignoreExist = pCreateDb->ignoreExists; + pMsg->update = pCreateDb->update; + pMsg->cacheLastRow = pCreateDb->cachelast; + pMsg->numOfVgroups = htonl(pCreateDb->numOfVgroups); } int32_t setDbOptions(SCreateDbReq* pCreateDbMsg, const SCreateDbInfo* pCreateDbSql, SMsgBuf* pMsgBuf) { @@ -240,7 +240,7 @@ int32_t setDbOptions(SCreateDbReq* pCreateDbMsg, const SCreateDbInfo* pCreateDbS return TSDB_CODE_SUCCESS; } -SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext *pCtx, SMsgBuf* pMsgBuf) { +SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext* pCtx, SMsgBuf* pMsgBuf) { SCreateDbReq* pCreateMsg = calloc(1, sizeof(SCreateDbReq)); if (setDbOptions(pCreateMsg, pCreateDbInfo, pMsgBuf) != TSDB_CODE_SUCCESS) { tfree(pCreateMsg); @@ -320,7 +320,7 @@ char* buildDropStableReq(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx return pReq; } -SCreateDnodeReq *buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf) { +char* buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf) { const char* msg1 = "invalid host name (name too long, maximum length 128)"; const char* msg2 = "dnode name can not be string"; const char* msg3 = "port should be an integer that is less than 65535 and greater than 0"; @@ -352,33 +352,44 @@ SCreateDnodeReq *buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMs return NULL; } - SCreateDnodeReq *pCreate = (SCreateDnodeReq *) calloc(1, sizeof(SCreateDnodeReq)); - if (pCreate == NULL) { - buildInvalidOperationMsg(pMsgBuf, msg4); + SCreateDnodeReq createReq = {0}; + + strncpy(createReq.fqdn, id->z, id->n); + createReq.port = val; + + int32_t tlen = tSerializeSCreateDnodeReq(NULL, 0, &createReq); + void* pReq = malloc(tlen); + if (pReq == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - strncpy(pCreate->fqdn, id->z, id->n); - pCreate->port = htonl(val); - - *len = sizeof(SCreateDnodeReq); - return pCreate; + tSerializeSCreateDnodeReq(pReq, tlen, &createReq); + *len = tlen; + return pReq; } -SDropDnodeReq *buildDropDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf) { +char* buildDropDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf) { + SDropDnodeReq dropReq = {0}; + SToken* pzName = taosArrayGet(pInfo->pMiscInfo->a, 0); char* end = NULL; - SDropDnodeReq * pDrop = (SDropDnodeReq *)calloc(1, sizeof(SDropDnodeReq)); - pDrop->dnodeId = strtoll(pzName->z, &end, 10); - pDrop->dnodeId = htonl(pDrop->dnodeId); - *len = sizeof(SDropDnodeReq); + dropReq.dnodeId = strtoll(pzName->z, &end, 10); if (end - pzName->z != pzName->n) { buildInvalidOperationMsg(pMsgBuf, "invalid dnode id"); - tfree(pDrop); return NULL; } - return pDrop; + int32_t tlen = tSerializeSDropDnodeReq(NULL, 0, &dropReq); + void* pReq = malloc(tlen); + if (pReq == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } + + tSerializeSDropDnodeReq(pReq, tlen, &dropReq); + *len = tlen; + return pReq; } \ No newline at end of file