diff --git a/Jenkinsfile2 b/Jenkinsfile2 index a4f765c9fb..b074a0ee05 100644 --- a/Jenkinsfile2 +++ b/Jenkinsfile2 @@ -422,6 +422,10 @@ pipeline { mkdir -p ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID} echo "''' + env.FILE_CHANGED + '''" > ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}/docs_changed.txt ''' + sh ''' + cd ${WKC}/tests/parallel_test + ./run_check_assert_container.sh -d ${WKDIR} + ''' sh ''' date rm -rf ${WKC}/debug diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt index 33179662fd..2a38bf74c7 100644 --- a/contrib/CMakeLists.txt +++ b/contrib/CMakeLists.txt @@ -321,7 +321,7 @@ if (${BUILD_WITH_ROCKSDB}) endif(${TD_DARWIN_ARM64}) if (${TD_WINDOWS}) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819 /std:c++17") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4244 /wd4819") option(WITH_JNI "" OFF) if(CMAKE_C_FLAGS MATCHES "/MT" OR CMAKE_C_FLAGS MATCHES "/MTd") @@ -370,7 +370,7 @@ if (${BUILD_WITH_ROCKSDB}) endif(${TD_DARWIN_ARM64}) if (${TD_WINDOWS}) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819 /std:c++17") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4244 /wd4819") option(WITH_JNI "" OFF) if(CMAKE_C_FLAGS MATCHES "/MT" OR CMAKE_C_FLAGS MATCHES "/MTd") diff --git a/include/dnode/mnode/mnode.h b/include/dnode/mnode/mnode.h index b821231539..1f205b3f11 100644 --- a/include/dnode/mnode/mnode.h +++ b/include/dnode/mnode/mnode.h @@ -121,6 +121,8 @@ void mndGenerateMachineCode(); void mndDumpSdb(); +void mndDeleteTrans(); + #ifdef __cplusplus } #endif diff --git a/packaging/cfg/taosd.service b/packaging/cfg/taosd.service index bfa330f6cb..09a5fd61a8 100644 --- a/packaging/cfg/taosd.service +++ b/packaging/cfg/taosd.service @@ -1,5 +1,5 @@ [Unit] -Description=server service +Description=taosd - TDengine time series database core service After=network-online.target Wants=network-online.target diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 7018dc5696..f0aaf183d7 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -1662,185 +1662,179 @@ _exit: int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); // status - if (tEncodeI64(&encoder, pRsp->dnodeVer) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->dnodeVer)); // dnode cfg - if (tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId) < 0) return -1; - if (tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId)); // dnode eps int32_t dlen = (int32_t)taosArrayGetSize(pRsp->pDnodeEps); - if (tEncodeI32(&encoder, dlen) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, dlen)); for (int32_t i = 0; i < dlen; ++i) { SDnodeEp *pDnodeEp = taosArrayGet(pRsp->pDnodeEps, i); - if (tEncodeI32(&encoder, pDnodeEp->id) < 0) return -1; - if (tEncodeI8(&encoder, pDnodeEp->isMnode) < 0) return -1; - if (tEncodeCStr(&encoder, pDnodeEp->ep.fqdn) < 0) return -1; - if (tEncodeU16(&encoder, pDnodeEp->ep.port) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pDnodeEp->id)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pDnodeEp->isMnode)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pDnodeEp->ep.fqdn)); + TAOS_CHECK_EXIT(tEncodeU16(&encoder, pDnodeEp->ep.port)); } - if (tEncodeI32(&encoder, pRsp->statusSeq) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->statusSeq)); - if (tEncodeI64(&encoder, pRsp->ipWhiteVer) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->ipWhiteVer)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); // status - if (tDecodeI64(&decoder, &pRsp->dnodeVer) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->dnodeVer)); // cluster cfg - if (tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId) < 0) return -1; - if (tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId)); // dnode eps int32_t dlen = 0; - if (tDecodeI32(&decoder, &dlen) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &dlen)); pRsp->pDnodeEps = taosArrayInit(dlen, sizeof(SDnodeEp)); if (pRsp->pDnodeEps == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } for (int32_t i = 0; i < dlen; ++i) { SDnodeEp dnodeEp = {0}; - if (tDecodeI32(&decoder, &dnodeEp.id) < 0) return -1; - if (tDecodeI8(&decoder, &dnodeEp.isMnode) < 0) return -1; - if (tDecodeCStrTo(&decoder, dnodeEp.ep.fqdn) < 0) return -1; - if (tDecodeU16(&decoder, &dnodeEp.ep.port) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &dnodeEp.id)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &dnodeEp.isMnode)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, dnodeEp.ep.fqdn)); + TAOS_CHECK_EXIT(tDecodeU16(&decoder, &dnodeEp.ep.port)); if (taosArrayPush(pRsp->pDnodeEps, &dnodeEp) == NULL) { - return -1; + TAOS_CHECK_EXIT(terrno); } } - if (tDecodeI32(&decoder, &pRsp->statusSeq) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->statusSeq)); if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI64(&decoder, &pRsp->ipWhiteVer) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ipWhiteVer)); } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSStatusRsp(SStatusRsp *pRsp) { taosArrayDestroy(pRsp->pDnodeEps); } int32_t tSerializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - - if (tEncodeI32(&encoder, pReq->contLen) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->pCont) < 0) return -1; - if (tEncodeI8(&encoder, pReq->type) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->contLen)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pCont)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->type)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - - if (tDecodeI32(&decoder, &pReq->contLen) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->contLen)); if (pReq->contLen > 0) { pReq->pCont = taosMemoryMalloc(pReq->contLen + 1); - if (pReq->pCont == NULL) return -1; - if (tDecodeCStrTo(&decoder, pReq->pCont) < 0) return -1; + if (pReq->pCont == NULL) { + TAOS_CHECK_EXIT(terrno); + } + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pCont)); } if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI8(&decoder, (int8_t *)&pReq->type) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI8(&decoder, (int8_t *)&pReq->type)); } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSStatisReq(SStatisReq *pReq) { taosMemoryFreeClear(pReq->pCont); } -// int32_t tSerializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) { -// SEncoder encoder = {0}; -// tEncoderInit(&encoder, buf, bufLen); - -// 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; -// tEncoderClear(&encoder); -// return tlen; -// } - -// int32_t tDeserializeSCreateAcctReq(void *buf, int32_t bufLen, SCreateAcctReq *pReq) { -// SDecoder decoder = {0}; -// tDecoderInit(&decoder, buf, bufLen); - -// 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); - -// tDecoderClear(&decoder); -// return 0; -// } - int32_t tSerializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user)); ENCODESQL(); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user)); DECODESQL(); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSDropUserReq(SDropUserReq *pReq) { FREESQL(); } @@ -1858,113 +1852,143 @@ SIpWhiteList *cloneIpWhiteList(SIpWhiteList *pIpWhiteList) { int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI8(&encoder, pReq->createType) < 0) return -1; - if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; - if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1; - if (tEncodeI8(&encoder, pReq->enable) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createType)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->superUser)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->sysInfo)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->enable)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pass)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numIpRanges)); for (int32_t i = 0; i < pReq->numIpRanges; ++i) { - if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1; - if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].ip)); + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].mask)); } ENCODESQL(); - if (tEncodeI8(&encoder, pReq->isImport) < 0) return -1; - if (tEncodeI8(&encoder, pReq->createDb) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isImport)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createDb)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->createType) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->numIpRanges) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createType)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->superUser)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->sysInfo)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->enable)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pass)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numIpRanges)); pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range)); - if (pReq->pIpRanges == NULL) return -1; + if (pReq->pIpRanges == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int32_t i = 0; i < pReq->numIpRanges; ++i) { - if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1; - if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip))); + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask))); } DECODESQL(); if (!tDecodeIsEnd(&decoder)) { - if (tDecodeI8(&decoder, &pReq->createDb) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->isImport) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createDb)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isImport)); } tEndDecode(&decoder); + +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) { - // impl later SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; + tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI64(&encoder, pReq->ver) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numOfUser) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->ver)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfUser)); for (int i = 0; i < pReq->numOfUser; i++) { SUpdateUserIpWhite *pUser = &(pReq->pUserIpWhite[i]); - if (tEncodeI64(&encoder, pUser->ver) < 0) return -1; - if (tEncodeCStr(&encoder, pUser->user) < 0) return -1; - if (tEncodeI32(&encoder, pUser->numOfRange) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pUser->ver)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pUser->user)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pUser->numOfRange)); for (int j = 0; j < pUser->numOfRange; j++) { SIpV4Range *pRange = &pUser->pIpRanges[j]; - if (tEncodeU32(&encoder, pRange->ip) < 0) return -1; - if (tEncodeU32(&encoder, pRange->mask) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRange->ip)); + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRange->mask)); } } tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); // impl later - if (tDecodeI64(&decoder, &pReq->ver) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->numOfUser) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->ver)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numOfUser)); - if ((pReq->pUserIpWhite = taosMemoryCalloc(1, sizeof(SUpdateUserIpWhite) * pReq->numOfUser)) == NULL) return -1; + if ((pReq->pUserIpWhite = taosMemoryCalloc(1, sizeof(SUpdateUserIpWhite) * pReq->numOfUser)) == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int i = 0; i < pReq->numOfUser; i++) { SUpdateUserIpWhite *pUserWhite = &pReq->pUserIpWhite[i]; - if (tDecodeI64(&decoder, &pUserWhite->ver) < 0) return -1; - if (tDecodeCStrTo(&decoder, pUserWhite->user) < 0) return -1; - if (tDecodeI32(&decoder, &pUserWhite->numOfRange) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pUserWhite->ver)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pUserWhite->user)); + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pUserWhite->numOfRange)); - if ((pUserWhite->pIpRanges = taosMemoryCalloc(1, pUserWhite->numOfRange * sizeof(SIpV4Range))) == NULL) return -1; + if ((pUserWhite->pIpRanges = taosMemoryCalloc(1, pUserWhite->numOfRange * sizeof(SIpV4Range))) == NULL) { + TAOS_CHECK_EXIT(terrno); + } for (int j = 0; j < pUserWhite->numOfRange; j++) { SIpV4Range *pRange = &pUserWhite->pIpRanges[j]; - if (tDecodeU32(&decoder, &pRange->ip) < 0) return -1; - if (tDecodeU32(&decoder, &pRange->mask) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pRange->ip)); + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pRange->mask)); } } tEndDecode(&decoder); + +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSUpdateIpWhiteReq(SUpdateIpWhite *pReq) { if (pReq == NULL) return; @@ -2023,29 +2047,39 @@ _return: } int32_t tSerializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI64(&encoder, pReq->ipWhiteVer) < 0) { - return -1; - } + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->ipWhiteVer)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; + tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - // impl later - if (tDecodeI64(&decoder, &pReq->ipWhiteVer) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->ipWhiteVer)); tEndDecode(&decoder); + +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSCreateUserReq(SCreateUserReq *pReq) { @@ -2055,77 +2089,90 @@ void tFreeSCreateUserReq(SCreateUserReq *pReq) { int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1; - if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; - if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1; - if (tEncodeI8(&encoder, pReq->enable) < 0) return -1; - if (tEncodeI8(&encoder, pReq->isView) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->objname) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->alterType)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->superUser)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->sysInfo)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->enable)); + TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isView)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pass)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->objname)); int32_t len = strlen(pReq->tabName); - if (tEncodeI32(&encoder, len) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI32(&encoder, len)); if (len > 0) { - if (tEncodeCStr(&encoder, pReq->tabName) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->tabName)); } - if (tEncodeBinary(&encoder, pReq->tagCond, pReq->tagCondLen) < 0) return -1; - if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->tagCond, pReq->tagCondLen)); + TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numIpRanges)); for (int32_t i = 0; i < pReq->numIpRanges; ++i) { - if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1; - if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].ip)); + TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].mask)); } - if (tEncodeI64(&encoder, pReq->privileges) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->privileges)); ENCODESQL(); - if (tEncodeU8(&encoder, pReq->flag) < 0) return -1; + TAOS_CHECK_EXIT(tEncodeU8(&encoder, pReq->flag)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1; - if (tDecodeI8(&decoder, &pReq->isView) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->objname) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->alterType)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->superUser)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->sysInfo)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->enable)); + TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isView)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pass)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->objname)); if (!tDecodeIsEnd(&decoder)) { int32_t len = 0; - if (tDecodeI32(&decoder, &len) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &len)); if (len > 0) { - if (tDecodeCStrTo(&decoder, pReq->tabName) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->tabName)); } uint64_t tagCondLen = 0; - if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->tagCond, &tagCondLen) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->tagCond, &tagCondLen)); pReq->tagCondLen = tagCondLen; } - if (tDecodeI32(&decoder, &pReq->numIpRanges) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numIpRanges)); pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range)); - if (pReq->pIpRanges == NULL) return -1; - for (int32_t i = 0; i < pReq->numIpRanges; ++i) { - if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1; - if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1; + if (pReq->pIpRanges == NULL) { + TAOS_CHECK_EXIT(terrno); } - if (tDecodeI64(&decoder, &pReq->privileges) < 0) return -1; + for (int32_t i = 0; i < pReq->numIpRanges; ++i) { + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip))); + TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask))); + } + TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->privileges)); DECODESQL(); if (!tDecodeIsEnd(&decoder)) { - if (tDecodeU8(&decoder, &pReq->flag) < 0) return -1; + TAOS_CHECK_EXIT(tDecodeU8(&decoder, &pReq->flag)); } tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSAlterUserReq(SAlterUserReq *pReq) { @@ -2136,60 +2183,71 @@ void tFreeSAlterUserReq(SAlterUserReq *pReq) { int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { SEncoder encoder = {0}; - tEncoderInit(&encoder, buf, bufLen); + int32_t code = 0; + int32_t lino; + int32_t tlen; - if (tStartEncode(&encoder) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; + tEncoderInit(&encoder, buf, bufLen); + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) { - if (tEncodeCStr(pEncoder, pRsp->user) < 0) return -1; - if (tEncodeI8(pEncoder, pRsp->superAuth) < 0) return -1; - if (tEncodeI8(pEncoder, pRsp->sysInfo) < 0) return -1; - if (tEncodeI8(pEncoder, pRsp->enable) < 0) return -1; - if (tEncodeI8(pEncoder, pRsp->dropped) < 0) return -1; - if (tEncodeI32(pEncoder, pRsp->version) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->user)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->superAuth)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->sysInfo)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->enable)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->dropped)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->version)); int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs); int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs); int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs); - if (tEncodeI32(pEncoder, numOfCreatedDbs) < 0) return -1; - if (tEncodeI32(pEncoder, numOfReadDbs) < 0) return -1; - if (tEncodeI32(pEncoder, numOfWriteDbs) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfCreatedDbs)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadDbs)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteDbs)); char *db = taosHashIterate(pRsp->createdDbs, NULL); while (db != NULL) { - if (tEncodeCStr(pEncoder, db) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, db)); db = taosHashIterate(pRsp->createdDbs, db); } db = taosHashIterate(pRsp->readDbs, NULL); while (db != NULL) { - if (tEncodeCStr(pEncoder, db) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, db)); db = taosHashIterate(pRsp->readDbs, db); } db = taosHashIterate(pRsp->writeDbs, NULL); while (db != NULL) { - if (tEncodeCStr(pEncoder, db) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, db)); db = taosHashIterate(pRsp->writeDbs, db); } @@ -2200,25 +2258,25 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) int32_t numOfWriteViews = taosHashGetSize(pRsp->writeViews); int32_t numOfAlterViews = taosHashGetSize(pRsp->alterViews); int32_t numOfUseDbs = taosHashGetSize(pRsp->useDbs); - if (tEncodeI32(pEncoder, numOfReadTbs) < 0) return -1; - if (tEncodeI32(pEncoder, numOfWriteTbs) < 0) return -1; - if (tEncodeI32(pEncoder, numOfAlterTbs) < 0) return -1; - if (tEncodeI32(pEncoder, numOfReadViews) < 0) return -1; - if (tEncodeI32(pEncoder, numOfWriteViews) < 0) return -1; - if (tEncodeI32(pEncoder, numOfAlterViews) < 0) return -1; - if (tEncodeI32(pEncoder, numOfUseDbs) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadTbs)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteTbs)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfAlterTbs)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadViews)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteViews)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfAlterViews)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfUseDbs)); char *tb = taosHashIterate(pRsp->readTbs, NULL); while (tb != NULL) { size_t keyLen = 0; void *key = taosHashGetKey(tb, &keyLen); - if (tEncodeI32(pEncoder, keyLen) < 0) return -1; - if (tEncodeCStr(pEncoder, key) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key)); size_t valueLen = 0; valueLen = strlen(tb); - if (tEncodeI32(pEncoder, valueLen) < 0) return -1; - if (tEncodeCStr(pEncoder, tb) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb)); tb = taosHashIterate(pRsp->readTbs, tb); } @@ -2227,13 +2285,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) while (tb != NULL) { size_t keyLen = 0; void *key = taosHashGetKey(tb, &keyLen); - if (tEncodeI32(pEncoder, keyLen) < 0) return -1; - if (tEncodeCStr(pEncoder, key) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key)); size_t valueLen = 0; valueLen = strlen(tb); - if (tEncodeI32(pEncoder, valueLen) < 0) return -1; - if (tEncodeCStr(pEncoder, tb) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb)); tb = taosHashIterate(pRsp->writeTbs, tb); } @@ -2242,13 +2300,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) while (tb != NULL) { size_t keyLen = 0; void *key = taosHashGetKey(tb, &keyLen); - if (tEncodeI32(pEncoder, keyLen) < 0) return -1; - if (tEncodeCStr(pEncoder, key) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key)); size_t valueLen = 0; valueLen = strlen(tb); - if (tEncodeI32(pEncoder, valueLen) < 0) return -1; - if (tEncodeCStr(pEncoder, tb) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb)); tb = taosHashIterate(pRsp->alterTbs, tb); } @@ -2257,13 +2315,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) while (tb != NULL) { size_t keyLen = 0; void *key = taosHashGetKey(tb, &keyLen); - if (tEncodeI32(pEncoder, keyLen) < 0) return -1; - if (tEncodeCStr(pEncoder, key) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key)); size_t valueLen = 0; valueLen = strlen(tb); - if (tEncodeI32(pEncoder, valueLen) < 0) return -1; - if (tEncodeCStr(pEncoder, tb) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb)); tb = taosHashIterate(pRsp->readViews, tb); } @@ -2272,13 +2330,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) while (tb != NULL) { size_t keyLen = 0; void *key = taosHashGetKey(tb, &keyLen); - if (tEncodeI32(pEncoder, keyLen) < 0) return -1; - if (tEncodeCStr(pEncoder, key) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key)); size_t valueLen = 0; valueLen = strlen(tb); - if (tEncodeI32(pEncoder, valueLen) < 0) return -1; - if (tEncodeCStr(pEncoder, tb) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb)); tb = taosHashIterate(pRsp->writeViews, tb); } @@ -2287,13 +2345,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) while (tb != NULL) { size_t keyLen = 0; void *key = taosHashGetKey(tb, &keyLen); - if (tEncodeI32(pEncoder, keyLen) < 0) return -1; - if (tEncodeCStr(pEncoder, key) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key)); size_t valueLen = 0; valueLen = strlen(tb); - if (tEncodeI32(pEncoder, valueLen) < 0) return -1; - if (tEncodeCStr(pEncoder, tb) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb)); tb = taosHashIterate(pRsp->alterViews, tb); } @@ -2302,30 +2360,36 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) while (useDb != NULL) { size_t keyLen = 0; void *key = taosHashGetKey(useDb, &keyLen); - if (tEncodeI32(pEncoder, keyLen) < 0) return -1; - if (tEncodeCStr(pEncoder, key) < 0) return -1; - - if (tEncodeI32(pEncoder, *useDb) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, *useDb)); useDb = taosHashIterate(pRsp->useDbs, useDb); } // since 3.0.7.0 - if (tEncodeI32(pEncoder, pRsp->passVer) < 0) return -1; - if (tEncodeI64(pEncoder, pRsp->whiteListVer) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->passVer)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pRsp->whiteListVer)); return 0; } int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) { SEncoder encoder = {0}; + int32_t code = 0; + int32_t lino; + int32_t tlen; tEncoderInit(&encoder, buf, bufLen); - if (tStartEncode(&encoder) < 0) return -1; - - if (tSerializeSGetUserAuthRspImpl(&encoder, pRsp) < 0) return -1; + TAOS_CHECK_EXIT(tStartEncode(&encoder)); + TAOS_CHECK_EXIT(tSerializeSGetUserAuthRspImpl(&encoder, pRsp)); tEndEncode(&encoder); - int32_t tlen = encoder.pos; +_exit: + if (code) { + tlen = code; + } else { + tlen = encoder.pos; + } tEncoderClear(&encoder); return tlen; } @@ -2558,16 +2622,18 @@ _err: int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) { SDecoder decoder = {0}; + int32_t code = 0; + int32_t lino; tDecoderInit(&decoder, buf, bufLen); - if (tStartDecode(&decoder) < 0) return -1; - - if (tDeserializeSGetUserAuthRspImpl(&decoder, pRsp) < 0) return -1; + TAOS_CHECK_EXIT(tStartDecode(&decoder)); + TAOS_CHECK_EXIT(tDeserializeSGetUserAuthRspImpl(&decoder, pRsp)); tEndDecode(&decoder); +_exit: tDecoderClear(&decoder); - return 0; + return code; } void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) { diff --git a/source/dnode/mgmt/exe/dmMain.c b/source/dnode/mgmt/exe/dmMain.c index e5c37e3d55..9b0cd7d5a5 100644 --- a/source/dnode/mgmt/exe/dmMain.c +++ b/source/dnode/mgmt/exe/dmMain.c @@ -59,6 +59,7 @@ static struct { #endif bool dumpConfig; bool dumpSdb; + bool deleteTrans; bool generateGrant; bool memDbg; bool checkS3; @@ -187,6 +188,8 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) { } } else if (strcmp(argv[i], "-s") == 0) { global.dumpSdb = true; + } else if (strcmp(argv[i], "-dTxn") == 0) { + global.deleteTrans = true; } else if (strcmp(argv[i], "-E") == 0) { if (i < argc - 1) { if (strlen(argv[++i]) >= PATH_MAX) { @@ -436,6 +439,22 @@ int mainWindows(int argc, char **argv) { return 0; } + if (global.deleteTrans) { + TdFilePtr pFile; + if ((code = dmCheckRunning(tsDataDir, &pFile)) != 0) { + printf("failed to generate encrypt code since taosd is running, please stop it first, reason:%s", + tstrerror(code)); + return code; + } + + mndDeleteTrans(); + taosCleanupCfg(); + taosCloseLog(); + taosCleanupArgs(); + taosConvDestroy(); + return 0; + } + osSetProcPath(argc, (char **)argv); taosCleanupArgs(); diff --git a/source/dnode/mnode/impl/src/mndDump.c b/source/dnode/mnode/impl/src/mndDump.c index 565e244014..04c9093c11 100644 --- a/source/dnode/mnode/impl/src/mndDump.c +++ b/source/dnode/mnode/impl/src/mndDump.c @@ -630,4 +630,30 @@ void mndDumpSdb() { mInfo("dump sdb info success"); } +void mndDeleteTrans() { + mInfo("start to dump sdb info to sdb.json"); + + char path[PATH_MAX * 2] = {0}; + (void)snprintf(path, sizeof(path), "%s%smnode", tsDataDir, TD_DIRSEP); + + SMsgCb msgCb = {0}; + msgCb.reportStartupFp = reportStartup; + msgCb.sendReqFp = sendReq; + msgCb.sendSyncReqFp = sendSyncReq; + msgCb.sendRspFp = sendRsp; + msgCb.mgmt = (SMgmtWrapper *)(&msgCb); // hack + tmsgSetDefault(&msgCb); + + (void)walInit(NULL); + (void)syncInit(); + + SMnodeOpt opt = {.msgCb = msgCb}; + SMnode *pMnode = mndOpen(path, &opt); + if (pMnode == NULL) return; + + (void)sdbWriteFileForDump(pMnode->pSdb); + + mInfo("dump sdb info success"); +} + #pragma GCC diagnostic pop diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c index 36f5d31676..d669994128 100644 --- a/source/dnode/mnode/impl/src/mndSync.c +++ b/source/dnode/mnode/impl/src/mndSync.c @@ -475,7 +475,7 @@ int32_t mndInitSync(SMnode *pMnode) { snprintf(syncInfo.path, sizeof(syncInfo.path), "%s%ssync", pMnode->path, TD_DIRSEP); syncInfo.pFsm = mndSyncMakeFsm(pMnode); - mInfo("vgId:1, start to open sync, replica:%d selfIndex:%d", pMgmt->numOfReplicas, pMgmt->selfIndex); + mInfo("vgId:1, start to open mnode sync, replica:%d selfIndex:%d", pMgmt->numOfReplicas, pMgmt->selfIndex); SSyncCfg *pCfg = &syncInfo.syncCfg; pCfg->totalReplicaNum = pMgmt->numOfTotalReplicas; pCfg->replicaNum = pMgmt->numOfReplicas; @@ -502,7 +502,7 @@ int32_t mndInitSync(SMnode *pMnode) { } pMnode->pSdb->sync = pMgmt->sync; - mInfo("mnode-sync is opened, id:%" PRId64, pMgmt->sync); + mInfo("vgId:1, mnode sync is opened, id:%" PRId64, pMgmt->sync); TAOS_RETURN(code); } @@ -606,12 +606,13 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) { } void mndSyncStart(SMnode *pMnode) { + mInfo("vgId:1, start to start mnode sync"); SSyncMgmt *pMgmt = &pMnode->syncMgmt; if (syncStart(pMgmt->sync) < 0) { mError("vgId:1, failed to start sync, id:%" PRId64, pMgmt->sync); return; } - mInfo("vgId:1, sync started, id:%" PRId64, pMgmt->sync); + mInfo("vgId:1, mnode sync started, id:%" PRId64, pMgmt->sync); } void mndSyncStop(SMnode *pMnode) { diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index 521539759c..63cab4168a 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -837,6 +837,9 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNew) { if (pNew->conflict == TRN_CONFLICT_NOTHING) return conflict; + int32_t size = sdbGetSize(pMnode->pSdb, SDB_TRANS); + mInfo("trans:%d, trans hash size %d", pNew->id, size); + while (1) { pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&pTrans); if (pIter == NULL) break; @@ -905,14 +908,14 @@ int32_t mndTransCheckConflict(SMnode *pMnode, STrans *pTrans) { if (pTrans->conflict == TRN_CONFLICT_DB || pTrans->conflict == TRN_CONFLICT_DB_INSIDE) { if (strlen(pTrans->dbname) == 0 && strlen(pTrans->stbname) == 0) { code = TSDB_CODE_MND_TRANS_CONFLICT; - mError("trans:%d, failed to prepare conflict db not set", pTrans->id); + mError("trans:%d, failed to check tran conflict since db not set", pTrans->id); TAOS_RETURN(code); } } if (mndCheckTransConflict(pMnode, pTrans)) { code = TSDB_CODE_MND_TRANS_CONFLICT; - mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code)); + mError("trans:%d, failed to check tran conflict since %s", pTrans->id, tstrerror(code)); TAOS_RETURN(code); } @@ -948,7 +951,7 @@ int32_t mndTransCheckConflictWithCompact(SMnode *pMnode, STrans *pTrans) { if (conflict) { code = TSDB_CODE_MND_TRANS_CONFLICT_COMPACT; - mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code)); + mError("trans:%d, failed to check tran conflict with compact since %s", pTrans->id, tstrerror(code)); TAOS_RETURN(code); } diff --git a/source/dnode/mnode/sdb/inc/sdb.h b/source/dnode/mnode/sdb/inc/sdb.h index 4584cb817a..c33b1d4366 100644 --- a/source/dnode/mnode/sdb/inc/sdb.h +++ b/source/dnode/mnode/sdb/inc/sdb.h @@ -280,6 +280,7 @@ int32_t sdbReadFile(SSdb *pSdb); */ int32_t sdbWriteFile(SSdb *pSdb, int32_t delta); +int32_t sdbWriteFileForDump(SSdb *pSdb); /** * @brief Parse and write raw data to sdb, then free the pRaw object * diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c index 6045ff80f6..dec37bfbf1 100644 --- a/source/dnode/mnode/sdb/src/sdbFile.c +++ b/source/dnode/mnode/sdb/src/sdbFile.c @@ -381,7 +381,7 @@ int32_t sdbReadFile(SSdb *pSdb) { return code; } -static int32_t sdbWriteFileImp(SSdb *pSdb) { +static int32_t sdbWriteFileImp(SSdb *pSdb, int32_t skip_type) { int32_t code = 0; char tmpfile[PATH_MAX] = {0}; @@ -409,6 +409,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) { } for (int32_t i = SDB_MAX - 1; i >= 0; --i) { + if (i == skip_type) continue; SdbEncodeFp encodeFp = pSdb->encodeFps[i]; if (encodeFp == NULL) continue; @@ -550,7 +551,7 @@ int32_t sdbWriteFile(SSdb *pSdb, int32_t delta) { } } if (code == 0) { - code = sdbWriteFileImp(pSdb); + code = sdbWriteFileImp(pSdb, -1); } if (code == 0) { if (pSdb->pWal != NULL) { @@ -566,6 +567,14 @@ int32_t sdbWriteFile(SSdb *pSdb, int32_t delta) { return code; } +int32_t sdbWriteFileForDump(SSdb *pSdb) { + int32_t code = 0; + + code = sdbWriteFileImp(pSdb, 0); + + return code; +} + int32_t sdbDeploy(SSdb *pSdb) { int32_t code = 0; code = sdbDeployData(pSdb); diff --git a/source/dnode/vnode/src/tsdb/tsdbRead2.c b/source/dnode/vnode/src/tsdb/tsdbRead2.c index d4e0eb6221..cecc52c51c 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead2.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead2.c @@ -4749,13 +4749,13 @@ int32_t tsdbReaderOpen2(void* pVnode, SQueryTableDataCond* pCond, void* pTableLi if (pCond->suid != 0) { pReader->info.pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, -1, 1); if (pReader->info.pSchema == NULL) { - tsdbError("failed to get table schema, suid:%" PRIu64 ", ver:-1, %s", pReader->info.suid, pReader->idStr); + tsdbWarn("failed to get table schema, suid:%" PRIu64 ", ver:-1, %s", pReader->info.suid, pReader->idStr); } } else if (numOfTables > 0) { STableKeyInfo* pKey = pTableList; pReader->info.pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1, 1); if (pReader->info.pSchema == NULL) { - tsdbError("failed to get table schema, uid:%" PRIu64 ", ver:-1, %s", pKey->uid, pReader->idStr); + tsdbWarn("failed to get table schema, uid:%" PRIu64 ", ver:-1, %s", pKey->uid, pReader->idStr); } } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 7634d209eb..76da8adc57 100755 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -4673,7 +4673,7 @@ int32_t translateTable(STranslateContext* pCxt, SNode** pTable, SNode* pJoinPare return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_GET_META_ERROR, tstrerror(code)); } #ifdef TD_ENTERPRISE - if (TSDB_VIEW_TABLE == pRealTable->pMeta->tableType && !pCurrSmt->tagScan) { + if (TSDB_VIEW_TABLE == pRealTable->pMeta->tableType && (!pCurrSmt->tagScan || pCxt->pParseCxt->biMode)) { return translateView(pCxt, pTable, &name); } code = translateAudit(pCxt, pRealTable, &name); diff --git a/source/libs/sync/inc/syncUtil.h b/source/libs/sync/inc/syncUtil.h index f0bf095935..1606f47592 100644 --- a/source/libs/sync/inc/syncUtil.h +++ b/source/libs/sync/inc/syncUtil.h @@ -113,7 +113,8 @@ void syncLogRecvSyncSnapshotRsp(SSyncNode* pSyncNode, const SyncSnapshotRsp* pMs void syncLogRecvAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s); void syncLogSendAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s); -void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, int32_t voteGranted, const char* s); +void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, int32_t voteGranted, const char* s, + const char* opt); void syncLogSendRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, const char* s); void syncLogRecvRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteReply* pMsg, const char* s); diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index 92c8127b50..a0236c38b8 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -61,6 +61,7 @@ static int32_t syncDoLeaderTransfer(SSyncNode* ths, SRpcMsg* pRpcMsg, SSyncRaftE static ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode); int64_t syncOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) { + sInfo("vgId:%d, start to open sync", pSyncInfo->vgId); SSyncNode* pSyncNode = syncNodeOpen(pSyncInfo, vnodeVersion); if (pSyncNode == NULL) { sError("vgId:%d, failed to open sync node", pSyncInfo->vgId); @@ -79,6 +80,7 @@ int64_t syncOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) { pSyncNode->hbBaseLine = pSyncInfo->heartbeatMs; pSyncNode->heartbeatTimerMS = pSyncInfo->heartbeatMs; pSyncNode->msgcb = pSyncInfo->msgcb; + sInfo("vgId:%d, sync opened", pSyncInfo->vgId); return pSyncNode->rid; } @@ -91,6 +93,7 @@ int32_t syncStart(int64_t rid) { sError("failed to acquire rid:%" PRId64 " of tsNodeReftId for pSyncNode", rid); TAOS_RETURN(code); } + sInfo("vgId:%d, begin to start sync", pSyncNode->vgId); if ((code = syncNodeRestore(pSyncNode)) < 0) { sError("vgId:%d, failed to restore sync log buffer since %s", pSyncNode->vgId, tstrerror(code)); @@ -103,6 +106,9 @@ int32_t syncStart(int64_t rid) { } syncNodeRelease(pSyncNode); + + sInfo("vgId:%d, sync started", pSyncNode->vgId); + TAOS_RETURN(code); _err: @@ -1370,7 +1376,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) { pSyncNode->hbrSlowNum = 0; pSyncNode->tmrRoutineNum = 0; - sNInfo(pSyncNode, "sync open, node:%p electInterval:%d heartbeatInterval:%d heartbeatTimeout:%d", pSyncNode, + sNInfo(pSyncNode, "sync node opened, node:%p electInterval:%d heartbeatInterval:%d heartbeatTimeout:%d", pSyncNode, tsElectInterval, tsHeartbeatInterval, tsHeartbeatTimeout); return pSyncNode; @@ -1434,6 +1440,7 @@ int32_t syncNodeRestore(SSyncNode* pSyncNode) { int32_t syncNodeStart(SSyncNode* pSyncNode) { // start raft + sInfo("vgId:%d, begin to start sync node", pSyncNode->vgId); if (pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex].nodeRole == TAOS_SYNC_ROLE_LEARNER) { syncNodeBecomeLearner(pSyncNode, "first start"); } else { @@ -1453,6 +1460,7 @@ int32_t syncNodeStart(SSyncNode* pSyncNode) { if (ret != 0) { sError("vgId:%d, failed to start ping timer since %s", pSyncNode->vgId, tstrerror(ret)); } + sInfo("vgId:%d, sync node started", pSyncNode->vgId); return ret; } @@ -2034,6 +2042,8 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) { // reset elect timer syncNodeResetElectTimer(pSyncNode); + + sInfo("vgId:%d, become follower. %s", pSyncNode->vgId, debugStr); } void syncNodeBecomeLearner(SSyncNode* pSyncNode, const char* debugStr) { diff --git a/source/libs/sync/src/syncRequestVote.c b/source/libs/sync/src/syncRequestVote.c index 738e558033..c8e81b13df 100644 --- a/source/libs/sync/src/syncRequestVote.c +++ b/source/libs/sync/src/syncRequestVote.c @@ -91,9 +91,11 @@ int32_t syncNodeOnRequestVote(SSyncNode* ths, const SRpcMsg* pRpcMsg) { SyncRequestVote* pMsg = pRpcMsg->pCont; bool resetElect = false; + syncLogRecvRequestVote(ths, pMsg, -1, "", "recv"); + // if already drop replica, do not process if (!syncNodeInRaftGroup(ths, &pMsg->srcId)) { - syncLogRecvRequestVote(ths, pMsg, -1, "not in my config"); + syncLogRecvRequestVote(ths, pMsg, -1, "not in my config", "process"); TAOS_RETURN(TSDB_CODE_SYN_MISMATCHED_SIGNATURE); } @@ -133,7 +135,7 @@ int32_t syncNodeOnRequestVote(SSyncNode* ths, const SRpcMsg* pRpcMsg) { if (!(!grant || pMsg->term == pReply->term)) return TSDB_CODE_SYN_INTERNAL_ERROR; // trace log - syncLogRecvRequestVote(ths, pMsg, pReply->voteGranted, ""); + syncLogRecvRequestVote(ths, pMsg, pReply->voteGranted, "", "proceed"); syncLogSendRequestVoteReply(ths, pReply, ""); (void)syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg); diff --git a/source/libs/sync/src/syncUtil.c b/source/libs/sync/src/syncUtil.c index a30bd9064f..553560f089 100644 --- a/source/libs/sync/src/syncUtil.c +++ b/source/libs/sync/src/syncUtil.c @@ -470,13 +470,13 @@ void syncLogSendAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMs pMsg->commitIndex, pMsg->dataLen, s); } -void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, int32_t voteGranted, - const char* errmsg) { +void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, int32_t voteGranted, const char* errmsg, + const char* opt) { char statusMsg[64]; snprintf(statusMsg, sizeof(statusMsg), "granted:%d", voteGranted); sNInfo(pSyncNode, - "recv sync-request-vote from dnode:%d, {term:%" PRId64 ", last-index:%" PRId64 ", last-term:%" PRId64 "}, %s", - DID(&pMsg->srcId), pMsg->term, pMsg->lastLogIndex, pMsg->lastLogTerm, + "%s sync-request-vote from dnode:%d, {term:%" PRId64 ", last-index:%" PRId64 ", last-term:%" PRId64 "}, %s", + opt, DID(&pMsg->srcId), pMsg->term, pMsg->lastLogIndex, pMsg->lastLogTerm, (voteGranted != -1) ? statusMsg : errmsg); } diff --git a/tests/army/insert/test_column_tag_boundary.py b/tests/army/insert/test_column_tag_boundary.py index aadada024f..a3a865ee8f 100644 --- a/tests/army/insert/test_column_tag_boundary.py +++ b/tests/army/insert/test_column_tag_boundary.py @@ -22,6 +22,9 @@ class TDTestCase(TBase): self.child_table_num = 1 self.insert_round_num = 300 self.row_num_per_round = 15 + self.row_num_per_round_varbia_json = 8 + self.rows_all1 = self.insert_round_num * self.row_num_per_round + self.rows_all2 = self.insert_round_num * self.row_num_per_round_varbia_json self.start_ts = 1704082431000 def prepare_data(self): @@ -47,8 +50,8 @@ class TDTestCase(TBase): # check the data for i in range(self.child_table_num): tdSql.query(f"select * from ct_binary{i+1};") - tdSql.checkRows(4500) - row_num = random.randint(0, 3999) + tdSql.checkRows(self.rows_all1) + row_num = random.randint(0, self.rows_all1-1) tdSql.checkData(row_num, 1, 'a' * self.max_column_length) tdSql.query(f"show tags from ct_binary{i+1};") tdSql.checkData(0, 5, tag) @@ -71,8 +74,8 @@ class TDTestCase(TBase): # check the data for i in range(self.child_table_num): tdSql.query(f"select * from ct_varchar{i+1};") - tdSql.checkRows(4500) - row_num = random.randint(0, 3999) + tdSql.checkRows(self.rows_all1) + row_num = random.randint(0, self.rows_all1-1) tdSql.checkData(row_num, 1, 'b' * self.max_column_length) tdSql.query(f"show tags from ct_varchar{i+1};") tdSql.checkData(0, 5, tag) @@ -106,14 +109,14 @@ class TDTestCase(TBase): # check the data for i in range(self.child_table_num): tdSql.query(f"select * from ct_nchar{i+1};") - tdSql.checkRows(4500) - row_num = random.randint(0, 3999) + tdSql.checkRows(self.rows_all1) + row_num = random.randint(0, self.rows_all1-1) tdSql.checkData(row_num, 1, column) tdSql.query(f"show tags from ct_nchar{i+1};") tdSql.checkData(0, 5, tag) def test_varbinary_boundary(self): - row_num_per_round = 8 + # create tables tdSql.execute(f"create table st_varbinary (ts timestamp, c1 varbinary({self.max_column_length})) tags (t1 varbinary({self.max_tag_length}));") for i in range(self.child_table_num): @@ -124,22 +127,21 @@ class TDTestCase(TBase): # insert data for j in range(self.insert_round_num): sql = "insert into ct_varbinary%s values" % (i+1) - for k in range(row_num_per_round): + for k in range(self.row_num_per_round_varbia_json): sql += "(%s, '%s')," % (str(self.start_ts + (j * self.insert_round_num + k * self.row_num_per_round + 1)), '\\x' + column) tdSql.execute(sql) - tdLog.info(f"Insert {row_num_per_round} rows data into ct_varbinary{i+1} {j+1} times successfully") + tdLog.info(f"Insert {self.row_num_per_round_varbia_json} rows data into ct_varbinary{i+1} {j+1} times successfully") tdSql.execute("flush database db;") # check the data for i in range(self.child_table_num): tdSql.query(f"select * from ct_varbinary{i+1};") - tdSql.checkRows(2400) - row_num = random.randint(0, 2399) + tdSql.checkRows(self.rows_all2) + row_num = random.randint(0, self.rows_all2-1) tdSql.checkData(row_num, 1, bytes.fromhex(column)) tdSql.query(f"show tags from ct_varbinary{i+1};") tdSql.checkData(0, 5, '\\x' + tag.upper()) def test_json_tag_boundary(self): - row_num_per_round = 8 max_json_tag_length = 4095 max_json_tag_key_length = 256 # create tables @@ -153,16 +155,16 @@ class TDTestCase(TBase): # insert data for j in range(self.insert_round_num): sql = "insert into ct_json_tag%s values" % (i+1) - for k in range(row_num_per_round): + for k in range(self.row_num_per_round_varbia_json): sql += "(%s, '%s')," % (str(self.start_ts + (j * self.insert_round_num + k * self.row_num_per_round + 1)), '\\x' + column) tdSql.execute(sql) - tdLog.info(f"Insert {row_num_per_round} rows data into ct_json_tag{i+1} {j+1} times successfully") + tdLog.info(f"Insert {self.row_num_per_round_varbia_json} rows data into ct_json_tag{i+1} {j+1} times successfully") tdSql.execute("flush database db;") # check the data for i in range(self.child_table_num): tdSql.query(f"select * from ct_json_tag{i+1} where t1->'{tag_key}' = '{tag_value}';") - tdSql.checkRows(2400) - row_num = random.randint(0, 2399) + tdSql.checkRows(self.rows_all2) + row_num = random.randint(0, self.rows_all2-1) tdSql.checkData(row_num, 1, bytes.fromhex(column)) def run(self): diff --git a/tests/ci/count_assert.py b/tests/ci/count_assert.py index 415c197b3f..2b51596403 100644 --- a/tests/ci/count_assert.py +++ b/tests/ci/count_assert.py @@ -1,23 +1,45 @@ import os import re +from loguru import logger # List of source directories to search + +self_path = os.path.dirname(os.path.realpath(__file__)) + +# Check if "community" or "tests" is in self_path +index_community = self_path.find("community") +if index_community != -1: + TD_project_path = self_path[:index_community] + index_TDinternal = TD_project_path.find("TDinternal") + # Check if index_TDinternal is valid and set work_path accordingly + if index_TDinternal != -1: + work_path = TD_project_path[:index_TDinternal] +else: + index_tests = self_path.find("tests") + if index_tests != -1: + TD_project_path = self_path[:index_tests] + # Check if index_TDengine is valid and set work_path accordingly + index_TDengine = TD_project_path.find("TDengine") + if index_TDengine != -1: + work_path = TD_project_path[:index_TDengine] +TD_project_path = TD_project_path.rstrip('/') +print(TD_project_path) source_dirs = [ - "community/source", - "community/include", - "enterprise/src/plugins/" + f"{TD_project_path}/community/source", + f"{TD_project_path}/community/include", + f"{TD_project_path}/enterprise/src/plugins/" ] # List of directories to exclude exclude_dirs = [ - "community/source/client/jni" + f"{TD_project_path}/community/source/client/jni" ] # List of files to exclude exclude_source_files = [ - "community/source/libs/parser/src/sql.c", - "community/source/util/src/tlog.c", - "community/include/util/tlog.h" + f"{TD_project_path}/community/source/libs/parser/src/sql.c", + f"{TD_project_path}/community/source/util/src/tlog.c", + f"{TD_project_path}/community/include/util/tlog.h" ] def grep_asserts_in_file(file_path, summary_list, detaild_list): @@ -26,10 +48,10 @@ def grep_asserts_in_file(file_path, summary_list, detaild_list): with open(file_path, 'r') as file: for line_number, line in enumerate(file, start=1): if re.search(r'\bassert\(.*\)|\bASSERT\(.*\)|\bASSERTS\(.*\)|\bASSERT_CORE\(.*\)', line): - detaild_list.append(f"{file_path}:{line_number}: {line.strip()}") + detaild_list.append(f"{file_path}:{line.strip()}:{line_number}") match_count += 1 if match_count > 0: - summary_list.append(f"Total matches in {file_path}: {match_count}") + summary_list.append(f"Total matches in {file_path}:{match_count}") def traverse_and_grep(source_dirs, exclude_dirs, exclude_source_files): """Traverse directories and grep for assert, ASSERTS, or ASSERT function calls in .h and .c files.""" @@ -47,7 +69,52 @@ def traverse_and_grep(source_dirs, exclude_dirs, exclude_source_files): grep_asserts_in_file(file_path, summary_list, detaild_list) return summary_list, detaild_list +def check_list_result(result_list,detaild_list): + logger.debug("check assert in source code") + error_message = "ERROR: do not add `assert` statements in new code." + error_message2 = "ERROR: Please check the detailed information below: assert statement with file name and line number" + remove_detail_items = [ + f"{TD_project_path}/community/source/dnode/vnode/src/tsdb/tsdbCommit2.c:ASSERT_CORE(tsdb->imem == NULL, \"imem should be null to commit mem\");", + f"{TD_project_path}/community/include/util/types.h:assert(sizeof(float) == sizeof(uint32_t));", + f"{TD_project_path}/community/include/util/types.h:assert(sizeof(double) == sizeof(uint64_t));" + ] + expected_strings = [ + f"Total matches in {TD_project_path}/community/source/dnode/vnode/src/tsdb/tsdbCommit2.c:1", + f"Total matches in {TD_project_path}/community/include/util/types.h:2" + ] + # logger.debug(len(result_list)) + if len(result_list) != 2: + logger.error(f"{error_message}") + for item in expected_strings: + if item in result_list: + result_list.remove(item) + logger.error("\n" + "\n".join(result_list)) + logger.error(f"{error_message2}") + for item in remove_detail_items: + if item in detaild_list: + detaild_list.remove(item) + logger.error("\n" + "\n".join(detaild_list)) + exit(1) + else: + # check if all expected strings are in the result list + if all(item in result_list for item in expected_strings): + # logger.debug(result_list) + # logger.debug(detaild_list) + if all(any(remove_detail_item in detaild for remove_detail_item in remove_detail_items) for detaild in detaild_list): + logger.info("Validation successful.") + else: + logger.error(f"{error_message}") + for item in expected_strings: + if item in result_list: + result_list.remove(item) + logger.error("\n" + "\n".join(result_list)) + logger.error(f"{error_message2}") + for item in remove_detail_items: + if item in detaild_list: + detaild_list.remove(item) + logger.error("\n" + "\n".join(detaild_list)) + exit(1) if __name__ == "__main__": summary_list, detaild_list = traverse_and_grep(source_dirs, exclude_dirs, exclude_source_files) - print("\n".join(summary_list)) - # print("\n".join(detaild_list)) \ No newline at end of file + check_list_result(summary_list,detaild_list) + diff --git a/tests/parallel_test/run_check_assert_container.sh b/tests/parallel_test/run_check_assert_container.sh new file mode 100755 index 0000000000..e8d78d62ae --- /dev/null +++ b/tests/parallel_test/run_check_assert_container.sh @@ -0,0 +1,54 @@ +#!/bin/bash + +function usage() { + echo "$0" + echo -e "\t -d work dir" + echo -e "\t -h help" +} + +while getopts "d:h" opt; do + case $opt in + d) + WORKDIR=$OPTARG + ;; + h) + usage + exit 0 + ;; + \?) + echo "Invalid option: -$OPTARG" + usage + exit 0 + ;; + esac +done + +if [ -z "$WORKDIR" ]; then + usage + exit 1 +fi + + + # enterprise edition +INTERNAL_REPDIR=$WORKDIR/TDinternal +REPDIR_DEBUG=$WORKDIR/debugNoSan/ + +REP_MOUNT_PARAM="$INTERNAL_REPDIR:/home/TDinternal" + +CONTAINER_TESTDIR=/home/TDinternal/community + +check_assert_scripts="$CONTAINER_TESTDIR/tests/ci/count_assert.py" + +ulimit -c unlimited +cat << EOF +docker run \ + -v $REP_MOUNT_PARAM \ + --rm --ulimit core=-1 taos_test:v1.0 python3 $check_assert_scripts +EOF +docker run \ + -v $REP_MOUNT_PARAM \ + --rm --ulimit core=-1 taos_test:v1.0 python3 $check_assert_scripts + +ret=$? +exit $ret +