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

Merge branch '3.0' of https://github.com/taosdata/TDengine into fix/TD-30837

This commit is contained in:
54liuyao 2024-09-03 17:54:28 +08:00
parent 2b6dc42d0e be756ecbf9
commit 79f8b4fc9a
20 changed files with 559 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Jenkinsfile2
View File

@ -422,6 +422,10 @@ pipeline {
mkdir -p ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID} mkdir -p ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}
echo "''' + env.FILE_CHANGED + '''" > ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}/docs_changed.txt 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 ''' sh '''
date date
rm -rf ${WKC}/debug rm -rf ${WKC}/debug

4
contrib/CMakeLists.txt
View File

@ -321,7 +321,7 @@ if (${BUILD_WITH_ROCKSDB})
endif(${TD_DARWIN_ARM64}) endif(${TD_DARWIN_ARM64})
if (${TD_WINDOWS}) 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") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4244 /wd4819")
option(WITH_JNI "" OFF) option(WITH_JNI "" OFF)
if(CMAKE_C_FLAGS MATCHES "/MT" OR CMAKE_C_FLAGS MATCHES "/MTd") if(CMAKE_C_FLAGS MATCHES "/MT" OR CMAKE_C_FLAGS MATCHES "/MTd")
@ -370,7 +370,7 @@ if (${BUILD_WITH_ROCKSDB})
endif(${TD_DARWIN_ARM64}) endif(${TD_DARWIN_ARM64})
if (${TD_WINDOWS}) 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") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4244 /wd4819")
option(WITH_JNI "" OFF) option(WITH_JNI "" OFF)
if(CMAKE_C_FLAGS MATCHES "/MT" OR CMAKE_C_FLAGS MATCHES "/MTd") if(CMAKE_C_FLAGS MATCHES "/MT" OR CMAKE_C_FLAGS MATCHES "/MTd")

2
include/dnode/mnode/mnode.h
View File

@ -121,6 +121,8 @@ void mndGenerateMachineCode();
void mndDumpSdb(); void mndDumpSdb();
void mndDeleteTrans();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

2
packaging/cfg/taosd.service
View File

@ -1,5 +1,5 @@
[Unit] [Unit]
Description=server service Description=taosd - TDengine time series database core service
After=network-online.target After=network-online.target
Wants=network-online.target Wants=network-online.target

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

@ -1662,185 +1662,179 @@ _exit:
int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) { int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
// status // status
if (tEncodeI64(&encoder, pRsp->dnodeVer) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->dnodeVer));
// dnode cfg // dnode cfg
if (tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId));
if (tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->dnodeCfg.clusterId));
// dnode eps // dnode eps
int32_t dlen = (int32_t)taosArrayGetSize(pRsp->pDnodeEps); 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) { for (int32_t i = 0; i < dlen; ++i) {
SDnodeEp *pDnodeEp = taosArrayGet(pRsp->pDnodeEps, i); SDnodeEp *pDnodeEp = taosArrayGet(pRsp->pDnodeEps, i);
if (tEncodeI32(&encoder, pDnodeEp->id) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pDnodeEp->id));
if (tEncodeI8(&encoder, pDnodeEp->isMnode) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pDnodeEp->isMnode));
if (tEncodeCStr(&encoder, pDnodeEp->ep.fqdn) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pDnodeEp->ep.fqdn));
if (tEncodeU16(&encoder, pDnodeEp->ep.port) < 0) return -1; 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); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) { int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
// status // status
if (tDecodeI64(&decoder, &pRsp->dnodeVer) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->dnodeVer));
// cluster cfg // cluster cfg
if (tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId));
if (tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->dnodeCfg.clusterId));
// dnode eps // dnode eps
int32_t dlen = 0; int32_t dlen = 0;
if (tDecodeI32(&decoder, &dlen) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &dlen));
pRsp->pDnodeEps = taosArrayInit(dlen, sizeof(SDnodeEp)); pRsp->pDnodeEps = taosArrayInit(dlen, sizeof(SDnodeEp));
if (pRsp->pDnodeEps == NULL) { if (pRsp->pDnodeEps == NULL) {
return -1; TAOS_CHECK_EXIT(terrno);
} }
for (int32_t i = 0; i < dlen; ++i) { for (int32_t i = 0; i < dlen; ++i) {
SDnodeEp dnodeEp = {0}; SDnodeEp dnodeEp = {0};
if (tDecodeI32(&decoder, &dnodeEp.id) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &dnodeEp.id));
if (tDecodeI8(&decoder, &dnodeEp.isMnode) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &dnodeEp.isMnode));
if (tDecodeCStrTo(&decoder, dnodeEp.ep.fqdn) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, dnodeEp.ep.fqdn));
if (tDecodeU16(&decoder, &dnodeEp.ep.port) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU16(&decoder, &dnodeEp.ep.port));
if (taosArrayPush(pRsp->pDnodeEps, &dnodeEp) == NULL) { 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 (!tDecodeIsEnd(&decoder)) {
if (tDecodeI64(&decoder, &pRsp->ipWhiteVer) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ipWhiteVer));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSStatusRsp(SStatusRsp *pRsp) { taosArrayDestroy(pRsp->pDnodeEps); } void tFreeSStatusRsp(SStatusRsp *pRsp) { taosArrayDestroy(pRsp->pDnodeEps); }
int32_t tSerializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) { int32_t tSerializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->contLen));
if (tEncodeI32(&encoder, pReq->contLen) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pCont));
if (tEncodeCStr(&encoder, pReq->pCont) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->type));
if (tEncodeI8(&encoder, pReq->type) < 0) return -1;
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) { int32_t tDeserializeSStatisReq(void *buf, int32_t bufLen, SStatisReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->contLen));
if (tDecodeI32(&decoder, &pReq->contLen) < 0) return -1;
if (pReq->contLen > 0) { if (pReq->contLen > 0) {
pReq->pCont = taosMemoryMalloc(pReq->contLen + 1); pReq->pCont = taosMemoryMalloc(pReq->contLen + 1);
if (pReq->pCont == NULL) return -1; if (pReq->pCont == NULL) {
if (tDecodeCStrTo(&decoder, pReq->pCont) < 0) return -1; TAOS_CHECK_EXIT(terrno);
}
TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pCont));
} }
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
if (tDecodeI8(&decoder, (int8_t *)&pReq->type) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, (int8_t *)&pReq->type));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSStatisReq(SStatisReq *pReq) { taosMemoryFreeClear(pReq->pCont); } 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) { int32_t tSerializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
ENCODESQL(); ENCODESQL();
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) { int32_t tDeserializeSDropUserReq(void *buf, int32_t bufLen, SDropUserReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
DECODESQL(); DECODESQL();
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSDropUserReq(SDropUserReq *pReq) { FREESQL(); } void tFreeSDropUserReq(SDropUserReq *pReq) { FREESQL(); }
@ -1858,113 +1852,143 @@ SIpWhiteList *cloneIpWhiteList(SIpWhiteList *pIpWhiteList) {
int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeI8(&encoder, pReq->createType) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createType));
if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->superUser));
if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->sysInfo));
if (tEncodeI8(&encoder, pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->enable));
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pass));
if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numIpRanges));
for (int32_t i = 0; i < pReq->numIpRanges; ++i) { for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].ip));
if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].mask));
} }
ENCODESQL(); ENCODESQL();
if (tEncodeI8(&encoder, pReq->isImport) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isImport));
if (tEncodeI8(&encoder, pReq->createDb) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createDb));
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) { int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeI8(&decoder, &pReq->createType) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createType));
if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->superUser));
if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->sysInfo));
if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->enable));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pass));
if (tDecodeI32(&decoder, &pReq->numIpRanges) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->numIpRanges));
pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range)); 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) { for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)));
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)));
} }
DECODESQL(); DECODESQL();
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
if (tDecodeI8(&decoder, &pReq->createDb) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createDb));
if (tDecodeI8(&decoder, &pReq->isImport) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isImport));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
int32_t tSerializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) { int32_t tSerializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) {
// impl later
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeI64(&encoder, pReq->ver) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->ver));
if (tEncodeI32(&encoder, pReq->numOfUser) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numOfUser));
for (int i = 0; i < pReq->numOfUser; i++) { for (int i = 0; i < pReq->numOfUser; i++) {
SUpdateUserIpWhite *pUser = &(pReq->pUserIpWhite[i]); SUpdateUserIpWhite *pUser = &(pReq->pUserIpWhite[i]);
if (tEncodeI64(&encoder, pUser->ver) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pUser->ver));
if (tEncodeCStr(&encoder, pUser->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pUser->user));
if (tEncodeI32(&encoder, pUser->numOfRange) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pUser->numOfRange));
for (int j = 0; j < pUser->numOfRange; j++) { for (int j = 0; j < pUser->numOfRange; j++) {
SIpV4Range *pRange = &pUser->pIpRanges[j]; SIpV4Range *pRange = &pUser->pIpRanges[j];
if (tEncodeU32(&encoder, pRange->ip) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRange->ip));
if (tEncodeU32(&encoder, pRange->mask) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pRange->mask));
} }
} }
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) { int32_t tDeserializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
// impl later // impl later
if (tDecodeI64(&decoder, &pReq->ver) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->ver));
if (tDecodeI32(&decoder, &pReq->numOfUser) < 0) return -1; 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++) { for (int i = 0; i < pReq->numOfUser; i++) {
SUpdateUserIpWhite *pUserWhite = &pReq->pUserIpWhite[i]; SUpdateUserIpWhite *pUserWhite = &pReq->pUserIpWhite[i];
if (tDecodeI64(&decoder, &pUserWhite->ver) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pUserWhite->ver));
if (tDecodeCStrTo(&decoder, pUserWhite->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pUserWhite->user));
if (tDecodeI32(&decoder, &pUserWhite->numOfRange) < 0) return -1; 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++) { for (int j = 0; j < pUserWhite->numOfRange; j++) {
SIpV4Range *pRange = &pUserWhite->pIpRanges[j]; SIpV4Range *pRange = &pUserWhite->pIpRanges[j];
if (tDecodeU32(&decoder, &pRange->ip) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pRange->ip));
if (tDecodeU32(&decoder, &pRange->mask) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pRange->mask));
} }
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSUpdateIpWhiteReq(SUpdateIpWhite *pReq) { void tFreeSUpdateIpWhiteReq(SUpdateIpWhite *pReq) {
if (pReq == NULL) return; if (pReq == NULL) return;
@ -2023,29 +2047,39 @@ _return:
} }
int32_t tSerializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) { int32_t tSerializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1;
if (tEncodeI64(&encoder, pReq->ipWhiteVer) < 0) { TAOS_CHECK_EXIT(tStartEncode(&encoder));
return -1; TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->ipWhiteVer));
}
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) { int32_t tDeserializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
// impl later TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->ipWhiteVer));
if (tDecodeI64(&decoder, &pReq->ipWhiteVer) < 0) return -1;
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSCreateUserReq(SCreateUserReq *pReq) { void tFreeSCreateUserReq(SCreateUserReq *pReq) {
@ -2055,77 +2089,90 @@ void tFreeSCreateUserReq(SCreateUserReq *pReq) {
int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->alterType));
if (tEncodeI8(&encoder, pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->superUser));
if (tEncodeI8(&encoder, pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->sysInfo));
if (tEncodeI8(&encoder, pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->enable));
if (tEncodeI8(&encoder, pReq->isView) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isView));
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pass));
if (tEncodeCStr(&encoder, pReq->objname) < 0) return -1; TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->objname));
int32_t len = strlen(pReq->tabName); int32_t len = strlen(pReq->tabName);
if (tEncodeI32(&encoder, len) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, len));
if (len > 0) { 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; TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->tagCond, pReq->tagCondLen));
if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1; TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->numIpRanges));
for (int32_t i = 0; i < pReq->numIpRanges; ++i) { for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->pIpRanges[i].ip));
if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1; 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(); ENCODESQL();
if (tEncodeU8(&encoder, pReq->flag) < 0) return -1; TAOS_CHECK_EXIT(tEncodeU8(&encoder, pReq->flag));
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) { int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->alterType));
if (tDecodeI8(&decoder, &pReq->superUser) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->superUser));
if (tDecodeI8(&decoder, &pReq->sysInfo) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->sysInfo));
if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->enable));
if (tDecodeI8(&decoder, &pReq->isView) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isView));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pass));
if (tDecodeCStrTo(&decoder, pReq->objname) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->objname));
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
int32_t len = 0; int32_t len = 0;
if (tDecodeI32(&decoder, &len) < 0) return -1; TAOS_CHECK_EXIT(tDecodeI32(&decoder, &len));
if (len > 0) { if (len > 0) {
if (tDecodeCStrTo(&decoder, pReq->tabName) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->tabName));
} }
uint64_t tagCondLen = 0; 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; 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)); pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range));
if (pReq->pIpRanges == NULL) return -1; if (pReq->pIpRanges == NULL) {
for (int32_t i = 0; i < pReq->numIpRanges; ++i) { TAOS_CHECK_EXIT(terrno);
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1;
if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1;
} }
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(); DECODESQL();
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
if (tDecodeU8(&decoder, &pReq->flag) < 0) return -1; TAOS_CHECK_EXIT(tDecodeU8(&decoder, &pReq->flag));
} }
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSAlterUserReq(SAlterUserReq *pReq) { void tFreeSAlterUserReq(SAlterUserReq *pReq) {
@ -2136,60 +2183,71 @@ void tFreeSAlterUserReq(SAlterUserReq *pReq) {
int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen); int32_t code = 0;
int32_t lino;
int32_t tlen;
if (tStartEncode(&encoder) < 0) return -1; tEncoderInit(&encoder, buf, bufLen);
if (tEncodeCStr(&encoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->user));
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) { int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1; TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->user));
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) { int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp) {
if (tEncodeCStr(pEncoder, pRsp->user) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pRsp->user));
if (tEncodeI8(pEncoder, pRsp->superAuth) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->superAuth));
if (tEncodeI8(pEncoder, pRsp->sysInfo) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->sysInfo));
if (tEncodeI8(pEncoder, pRsp->enable) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->enable));
if (tEncodeI8(pEncoder, pRsp->dropped) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pRsp->dropped));
if (tEncodeI32(pEncoder, pRsp->version) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->version));
int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs); int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs);
int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs); int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs);
int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs); int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs);
if (tEncodeI32(pEncoder, numOfCreatedDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfCreatedDbs));
if (tEncodeI32(pEncoder, numOfReadDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadDbs));
if (tEncodeI32(pEncoder, numOfWriteDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteDbs));
char *db = taosHashIterate(pRsp->createdDbs, NULL); char *db = taosHashIterate(pRsp->createdDbs, NULL);
while (db != 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->createdDbs, db);
} }
db = taosHashIterate(pRsp->readDbs, NULL); db = taosHashIterate(pRsp->readDbs, NULL);
while (db != 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->readDbs, db);
} }
db = taosHashIterate(pRsp->writeDbs, NULL); db = taosHashIterate(pRsp->writeDbs, NULL);
while (db != NULL) { while (db != NULL) {
if (tEncodeCStr(pEncoder, db) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, db));
db = taosHashIterate(pRsp->writeDbs, 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 numOfWriteViews = taosHashGetSize(pRsp->writeViews);
int32_t numOfAlterViews = taosHashGetSize(pRsp->alterViews); int32_t numOfAlterViews = taosHashGetSize(pRsp->alterViews);
int32_t numOfUseDbs = taosHashGetSize(pRsp->useDbs); int32_t numOfUseDbs = taosHashGetSize(pRsp->useDbs);
if (tEncodeI32(pEncoder, numOfReadTbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadTbs));
if (tEncodeI32(pEncoder, numOfWriteTbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteTbs));
if (tEncodeI32(pEncoder, numOfAlterTbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfAlterTbs));
if (tEncodeI32(pEncoder, numOfReadViews) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfReadViews));
if (tEncodeI32(pEncoder, numOfWriteViews) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfWriteViews));
if (tEncodeI32(pEncoder, numOfAlterViews) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfAlterViews));
if (tEncodeI32(pEncoder, numOfUseDbs) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, numOfUseDbs));
char *tb = taosHashIterate(pRsp->readTbs, NULL); char *tb = taosHashIterate(pRsp->readTbs, NULL);
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->readTbs, tb); tb = taosHashIterate(pRsp->readTbs, tb);
} }
@ -2227,13 +2285,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->writeTbs, tb); tb = taosHashIterate(pRsp->writeTbs, tb);
} }
@ -2242,13 +2300,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->alterTbs, tb); tb = taosHashIterate(pRsp->alterTbs, tb);
} }
@ -2257,13 +2315,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->readViews, tb); tb = taosHashIterate(pRsp->readViews, tb);
} }
@ -2272,13 +2330,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->writeViews, tb); tb = taosHashIterate(pRsp->writeViews, tb);
} }
@ -2287,13 +2345,13 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (tb != NULL) { while (tb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(tb, &keyLen); void *key = taosHashGetKey(tb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
size_t valueLen = 0; size_t valueLen = 0;
valueLen = strlen(tb); valueLen = strlen(tb);
if (tEncodeI32(pEncoder, valueLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, valueLen));
if (tEncodeCStr(pEncoder, tb) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, tb));
tb = taosHashIterate(pRsp->alterViews, tb); tb = taosHashIterate(pRsp->alterViews, tb);
} }
@ -2302,30 +2360,36 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
while (useDb != NULL) { while (useDb != NULL) {
size_t keyLen = 0; size_t keyLen = 0;
void *key = taosHashGetKey(useDb, &keyLen); void *key = taosHashGetKey(useDb, &keyLen);
if (tEncodeI32(pEncoder, keyLen) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, keyLen));
if (tEncodeCStr(pEncoder, key) < 0) return -1; TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, key));
TAOS_CHECK_RETURN(tEncodeI32(pEncoder, *useDb));
if (tEncodeI32(pEncoder, *useDb) < 0) return -1;
useDb = taosHashIterate(pRsp->useDbs, useDb); useDb = taosHashIterate(pRsp->useDbs, useDb);
} }
// since 3.0.7.0 // since 3.0.7.0
if (tEncodeI32(pEncoder, pRsp->passVer) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pRsp->passVer));
if (tEncodeI64(pEncoder, pRsp->whiteListVer) < 0) return -1; TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pRsp->whiteListVer));
return 0; return 0;
} }
int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) { int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
SEncoder encoder = {0}; SEncoder encoder = {0};
int32_t code = 0;
int32_t lino;
int32_t tlen;
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; TAOS_CHECK_EXIT(tStartEncode(&encoder));
TAOS_CHECK_EXIT(tSerializeSGetUserAuthRspImpl(&encoder, pRsp));
if (tSerializeSGetUserAuthRspImpl(&encoder, pRsp) < 0) return -1;
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; _exit:
if (code) {
tlen = code;
} else {
tlen = encoder.pos;
}
tEncoderClear(&encoder); tEncoderClear(&encoder);
return tlen; return tlen;
} }
@ -2558,16 +2622,18 @@ _err:
int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) { int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
SDecoder decoder = {0}; SDecoder decoder = {0};
int32_t code = 0;
int32_t lino;
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1; TAOS_CHECK_EXIT(tStartDecode(&decoder));
TAOS_CHECK_EXIT(tDeserializeSGetUserAuthRspImpl(&decoder, pRsp));
if (tDeserializeSGetUserAuthRspImpl(&decoder, pRsp) < 0) return -1;
tEndDecode(&decoder); tEndDecode(&decoder);
_exit:
tDecoderClear(&decoder); tDecoderClear(&decoder);
return 0; return code;
} }
void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) { void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) {

19
source/dnode/mgmt/exe/dmMain.c
View File

@ -59,6 +59,7 @@ static struct {
#endif #endif
bool dumpConfig; bool dumpConfig;
bool dumpSdb; bool dumpSdb;
bool deleteTrans;
bool generateGrant; bool generateGrant;
bool memDbg; bool memDbg;
bool checkS3; bool checkS3;
@ -187,6 +188,8 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
} }
} else if (strcmp(argv[i], "-s") == 0) { } else if (strcmp(argv[i], "-s") == 0) {
global.dumpSdb = true; global.dumpSdb = true;
} else if (strcmp(argv[i], "-dTxn") == 0) {
global.deleteTrans = true;
} else if (strcmp(argv[i], "-E") == 0) { } else if (strcmp(argv[i], "-E") == 0) {
if (i < argc - 1) { if (i < argc - 1) {
if (strlen(argv[++i]) >= PATH_MAX) { if (strlen(argv[++i]) >= PATH_MAX) {
@ -436,6 +439,22 @@ int mainWindows(int argc, char **argv) {
return 0; 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); osSetProcPath(argc, (char **)argv);
taosCleanupArgs(); taosCleanupArgs();

26
source/dnode/mnode/impl/src/mndDump.c
View File

@ -630,4 +630,30 @@ void mndDumpSdb() {
mInfo("dump sdb info success"); 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 #pragma GCC diagnostic pop

7
source/dnode/mnode/impl/src/mndSync.c
View File

@ -475,7 +475,7 @@ int32_t mndInitSync(SMnode *pMnode) {
snprintf(syncInfo.path, sizeof(syncInfo.path), "%s%ssync", pMnode->path, TD_DIRSEP); snprintf(syncInfo.path, sizeof(syncInfo.path), "%s%ssync", pMnode->path, TD_DIRSEP);
syncInfo.pFsm = mndSyncMakeFsm(pMnode); 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; SSyncCfg *pCfg = &syncInfo.syncCfg;
pCfg->totalReplicaNum = pMgmt->numOfTotalReplicas; pCfg->totalReplicaNum = pMgmt->numOfTotalReplicas;
pCfg->replicaNum = pMgmt->numOfReplicas; pCfg->replicaNum = pMgmt->numOfReplicas;
@ -502,7 +502,7 @@ int32_t mndInitSync(SMnode *pMnode) {
} }
pMnode->pSdb->sync = pMgmt->sync; 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); TAOS_RETURN(code);
} }
@ -606,12 +606,13 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) {
} }
void mndSyncStart(SMnode *pMnode) { void mndSyncStart(SMnode *pMnode) {
mInfo("vgId:1, start to start mnode sync");
SSyncMgmt *pMgmt = &pMnode->syncMgmt; SSyncMgmt *pMgmt = &pMnode->syncMgmt;
if (syncStart(pMgmt->sync) < 0) { if (syncStart(pMgmt->sync) < 0) {
mError("vgId:1, failed to start sync, id:%" PRId64, pMgmt->sync); mError("vgId:1, failed to start sync, id:%" PRId64, pMgmt->sync);
return; return;
} }
mInfo("vgId:1, sync started, id:%" PRId64, pMgmt->sync); mInfo("vgId:1, mnode sync started, id:%" PRId64, pMgmt->sync);
} }
void mndSyncStop(SMnode *pMnode) { void mndSyncStop(SMnode *pMnode) {

9
source/dnode/mnode/impl/src/mndTrans.c
View File

@ -837,6 +837,9 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNew) {
if (pNew->conflict == TRN_CONFLICT_NOTHING) return conflict; 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) { while (1) {
pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&pTrans); pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&pTrans);
if (pIter == NULL) break; 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 (pTrans->conflict == TRN_CONFLICT_DB || pTrans->conflict == TRN_CONFLICT_DB_INSIDE) {
if (strlen(pTrans->dbname) == 0 && strlen(pTrans->stbname) == 0) { if (strlen(pTrans->dbname) == 0 && strlen(pTrans->stbname) == 0) {
code = TSDB_CODE_MND_TRANS_CONFLICT; 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); TAOS_RETURN(code);
} }
} }
if (mndCheckTransConflict(pMnode, pTrans)) { if (mndCheckTransConflict(pMnode, pTrans)) {
code = TSDB_CODE_MND_TRANS_CONFLICT; 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); TAOS_RETURN(code);
} }
@ -948,7 +951,7 @@ int32_t mndTransCheckConflictWithCompact(SMnode *pMnode, STrans *pTrans) {
if (conflict) { if (conflict) {
code = TSDB_CODE_MND_TRANS_CONFLICT_COMPACT; 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); TAOS_RETURN(code);
} }

1
source/dnode/mnode/sdb/inc/sdb.h
View File

@ -280,6 +280,7 @@ int32_t sdbReadFile(SSdb *pSdb);
*/ */
int32_t sdbWriteFile(SSdb *pSdb, int32_t delta); 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 * @brief Parse and write raw data to sdb, then free the pRaw object
* *

13
source/dnode/mnode/sdb/src/sdbFile.c
View File

@ -381,7 +381,7 @@ int32_t sdbReadFile(SSdb *pSdb) {
return code; return code;
} }
static int32_t sdbWriteFileImp(SSdb *pSdb) { static int32_t sdbWriteFileImp(SSdb *pSdb, int32_t skip_type) {
int32_t code = 0; int32_t code = 0;
char tmpfile[PATH_MAX] = {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) { for (int32_t i = SDB_MAX - 1; i >= 0; --i) {
if (i == skip_type) continue;
SdbEncodeFp encodeFp = pSdb->encodeFps[i]; SdbEncodeFp encodeFp = pSdb->encodeFps[i];
if (encodeFp == NULL) continue; if (encodeFp == NULL) continue;
@ -550,7 +551,7 @@ int32_t sdbWriteFile(SSdb *pSdb, int32_t delta) {
} }
} }
if (code == 0) { if (code == 0) {
code = sdbWriteFileImp(pSdb); code = sdbWriteFileImp(pSdb, -1);
} }
if (code == 0) { if (code == 0) {
if (pSdb->pWal != NULL) { if (pSdb->pWal != NULL) {
@ -566,6 +567,14 @@ int32_t sdbWriteFile(SSdb *pSdb, int32_t delta) {
return code; return code;
} }
int32_t sdbWriteFileForDump(SSdb *pSdb) {
int32_t code = 0;
code = sdbWriteFileImp(pSdb, 0);
return code;
}
int32_t sdbDeploy(SSdb *pSdb) { int32_t sdbDeploy(SSdb *pSdb) {
int32_t code = 0; int32_t code = 0;
code = sdbDeployData(pSdb); code = sdbDeployData(pSdb);

4
source/dnode/vnode/src/tsdb/tsdbRead2.c
View File

@ -4749,13 +4749,13 @@ int32_t tsdbReaderOpen2(void* pVnode, SQueryTableDataCond* pCond, void* pTableLi
if (pCond->suid != 0) { if (pCond->suid != 0) {
pReader->info.pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, -1, 1); pReader->info.pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, -1, 1);
if (pReader->info.pSchema == NULL) { 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) { } else if (numOfTables > 0) {
STableKeyInfo* pKey = pTableList; STableKeyInfo* pKey = pTableList;
pReader->info.pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1, 1); pReader->info.pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1, 1);
if (pReader->info.pSchema == NULL) { 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);
} }
} }

2
source/libs/parser/src/parTranslater.c
View File

@ -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)); return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_GET_META_ERROR, tstrerror(code));
} }
#ifdef TD_ENTERPRISE #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); return translateView(pCxt, pTable, &name);
} }
code = translateAudit(pCxt, pRealTable, &name); code = translateAudit(pCxt, pRealTable, &name);

3
source/libs/sync/inc/syncUtil.h
View File

@ -113,7 +113,8 @@ void syncLogRecvSyncSnapshotRsp(SSyncNode* pSyncNode, const SyncSnapshotRsp* pMs
void syncLogRecvAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s); void syncLogRecvAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s);
void syncLogSendAppendEntries(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 syncLogSendRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, const char* s);
void syncLogRecvRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteReply* pMsg, const char* s); void syncLogRecvRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteReply* pMsg, const char* s);

12
source/libs/sync/src/syncMain.c
View File

@ -61,6 +61,7 @@ static int32_t syncDoLeaderTransfer(SSyncNode* ths, SRpcMsg* pRpcMsg, SSyncRaftE
static ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode); static ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode);
int64_t syncOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) { int64_t syncOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
sInfo("vgId:%d, start to open sync", pSyncInfo->vgId);
SSyncNode* pSyncNode = syncNodeOpen(pSyncInfo, vnodeVersion); SSyncNode* pSyncNode = syncNodeOpen(pSyncInfo, vnodeVersion);
if (pSyncNode == NULL) { if (pSyncNode == NULL) {
sError("vgId:%d, failed to open sync node", pSyncInfo->vgId); 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->hbBaseLine = pSyncInfo->heartbeatMs;
pSyncNode->heartbeatTimerMS = pSyncInfo->heartbeatMs; pSyncNode->heartbeatTimerMS = pSyncInfo->heartbeatMs;
pSyncNode->msgcb = pSyncInfo->msgcb; pSyncNode->msgcb = pSyncInfo->msgcb;
sInfo("vgId:%d, sync opened", pSyncInfo->vgId);
return pSyncNode->rid; return pSyncNode->rid;
} }
@ -91,6 +93,7 @@ int32_t syncStart(int64_t rid) {
sError("failed to acquire rid:%" PRId64 " of tsNodeReftId for pSyncNode", rid); sError("failed to acquire rid:%" PRId64 " of tsNodeReftId for pSyncNode", rid);
TAOS_RETURN(code); TAOS_RETURN(code);
} }
sInfo("vgId:%d, begin to start sync", pSyncNode->vgId);
if ((code = syncNodeRestore(pSyncNode)) < 0) { if ((code = syncNodeRestore(pSyncNode)) < 0) {
sError("vgId:%d, failed to restore sync log buffer since %s", pSyncNode->vgId, tstrerror(code)); 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); syncNodeRelease(pSyncNode);
sInfo("vgId:%d, sync started", pSyncNode->vgId);
TAOS_RETURN(code); TAOS_RETURN(code);
_err: _err:
@ -1370,7 +1376,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
pSyncNode->hbrSlowNum = 0; pSyncNode->hbrSlowNum = 0;
pSyncNode->tmrRoutineNum = 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); tsElectInterval, tsHeartbeatInterval, tsHeartbeatTimeout);
return pSyncNode; return pSyncNode;
@ -1434,6 +1440,7 @@ int32_t syncNodeRestore(SSyncNode* pSyncNode) {
int32_t syncNodeStart(SSyncNode* pSyncNode) { int32_t syncNodeStart(SSyncNode* pSyncNode) {
// start raft // 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) { if (pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex].nodeRole == TAOS_SYNC_ROLE_LEARNER) {
syncNodeBecomeLearner(pSyncNode, "first start"); syncNodeBecomeLearner(pSyncNode, "first start");
} else { } else {
@ -1453,6 +1460,7 @@ int32_t syncNodeStart(SSyncNode* pSyncNode) {
if (ret != 0) { if (ret != 0) {
sError("vgId:%d, failed to start ping timer since %s", pSyncNode->vgId, tstrerror(ret)); sError("vgId:%d, failed to start ping timer since %s", pSyncNode->vgId, tstrerror(ret));
} }
sInfo("vgId:%d, sync node started", pSyncNode->vgId);
return ret; return ret;
} }
@ -2034,6 +2042,8 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) {
// reset elect timer // reset elect timer
syncNodeResetElectTimer(pSyncNode); syncNodeResetElectTimer(pSyncNode);
sInfo("vgId:%d, become follower. %s", pSyncNode->vgId, debugStr);
} }
void syncNodeBecomeLearner(SSyncNode* pSyncNode, const char* debugStr) { void syncNodeBecomeLearner(SSyncNode* pSyncNode, const char* debugStr) {

6
source/libs/sync/src/syncRequestVote.c
View File

@ -91,9 +91,11 @@ int32_t syncNodeOnRequestVote(SSyncNode* ths, const SRpcMsg* pRpcMsg) {
SyncRequestVote* pMsg = pRpcMsg->pCont; SyncRequestVote* pMsg = pRpcMsg->pCont;
bool resetElect = false; bool resetElect = false;
syncLogRecvRequestVote(ths, pMsg, -1, "", "recv");
// if already drop replica, do not process // if already drop replica, do not process
if (!syncNodeInRaftGroup(ths, &pMsg->srcId)) { 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); 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; if (!(!grant || pMsg->term == pReply->term)) return TSDB_CODE_SYN_INTERNAL_ERROR;
// trace log // trace log
syncLogRecvRequestVote(ths, pMsg, pReply->voteGranted, ""); syncLogRecvRequestVote(ths, pMsg, pReply->voteGranted, "", "proceed");
syncLogSendRequestVoteReply(ths, pReply, ""); syncLogSendRequestVoteReply(ths, pReply, "");
(void)syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg); (void)syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg);

8
source/libs/sync/src/syncUtil.c
View File

@ -470,13 +470,13 @@ void syncLogSendAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMs
pMsg->commitIndex, pMsg->dataLen, s); pMsg->commitIndex, pMsg->dataLen, s);
} }
void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, int32_t voteGranted, void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, int32_t voteGranted, const char* errmsg,
const char* errmsg) { const char* opt) {
char statusMsg[64]; char statusMsg[64];
snprintf(statusMsg, sizeof(statusMsg), "granted:%d", voteGranted); snprintf(statusMsg, sizeof(statusMsg), "granted:%d", voteGranted);
sNInfo(pSyncNode, sNInfo(pSyncNode,
"recv sync-request-vote from dnode:%d, {term:%" PRId64 ", last-index:%" PRId64 ", last-term:%" PRId64 "}, %s", "%s sync-request-vote from dnode:%d, {term:%" PRId64 ", last-index:%" PRId64 ", last-term:%" PRId64 "}, %s",
DID(&pMsg->srcId), pMsg->term, pMsg->lastLogIndex, pMsg->lastLogTerm, opt, DID(&pMsg->srcId), pMsg->term, pMsg->lastLogIndex, pMsg->lastLogTerm,
(voteGranted != -1) ? statusMsg : errmsg); (voteGranted != -1) ? statusMsg : errmsg);
} }

34
tests/army/insert/test_column_tag_boundary.py
View File

@ -22,6 +22,9 @@ class TDTestCase(TBase):
self.child_table_num = 1 self.child_table_num = 1
self.insert_round_num = 300 self.insert_round_num = 300
self.row_num_per_round = 15 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 self.start_ts = 1704082431000
def prepare_data(self): def prepare_data(self):
@ -47,8 +50,8 @@ class TDTestCase(TBase):
# check the data # check the data
for i in range(self.child_table_num): for i in range(self.child_table_num):
tdSql.query(f"select * from ct_binary{i+1};") tdSql.query(f"select * from ct_binary{i+1};")
tdSql.checkRows(4500) tdSql.checkRows(self.rows_all1)
row_num = random.randint(0, 3999) row_num = random.randint(0, self.rows_all1-1)
tdSql.checkData(row_num, 1, 'a' * self.max_column_length) tdSql.checkData(row_num, 1, 'a' * self.max_column_length)
tdSql.query(f"show tags from ct_binary{i+1};") tdSql.query(f"show tags from ct_binary{i+1};")
tdSql.checkData(0, 5, tag) tdSql.checkData(0, 5, tag)
@ -71,8 +74,8 @@ class TDTestCase(TBase):
# check the data # check the data
for i in range(self.child_table_num): for i in range(self.child_table_num):
tdSql.query(f"select * from ct_varchar{i+1};") tdSql.query(f"select * from ct_varchar{i+1};")
tdSql.checkRows(4500) tdSql.checkRows(self.rows_all1)
row_num = random.randint(0, 3999) row_num = random.randint(0, self.rows_all1-1)
tdSql.checkData(row_num, 1, 'b' * self.max_column_length) tdSql.checkData(row_num, 1, 'b' * self.max_column_length)
tdSql.query(f"show tags from ct_varchar{i+1};") tdSql.query(f"show tags from ct_varchar{i+1};")
tdSql.checkData(0, 5, tag) tdSql.checkData(0, 5, tag)
@ -106,14 +109,14 @@ class TDTestCase(TBase):
# check the data # check the data
for i in range(self.child_table_num): for i in range(self.child_table_num):
tdSql.query(f"select * from ct_nchar{i+1};") tdSql.query(f"select * from ct_nchar{i+1};")
tdSql.checkRows(4500) tdSql.checkRows(self.rows_all1)
row_num = random.randint(0, 3999) row_num = random.randint(0, self.rows_all1-1)
tdSql.checkData(row_num, 1, column) tdSql.checkData(row_num, 1, column)
tdSql.query(f"show tags from ct_nchar{i+1};") tdSql.query(f"show tags from ct_nchar{i+1};")
tdSql.checkData(0, 5, tag) tdSql.checkData(0, 5, tag)
def test_varbinary_boundary(self): def test_varbinary_boundary(self):
row_num_per_round = 8
# create tables # create tables
tdSql.execute(f"create table st_varbinary (ts timestamp, c1 varbinary({self.max_column_length})) tags (t1 varbinary({self.max_tag_length}));") 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): for i in range(self.child_table_num):
@ -124,22 +127,21 @@ class TDTestCase(TBase):
# insert data # insert data
for j in range(self.insert_round_num): for j in range(self.insert_round_num):
sql = "insert into ct_varbinary%s values" % (i+1) 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) sql += "(%s, '%s')," % (str(self.start_ts + (j * self.insert_round_num + k * self.row_num_per_round + 1)), '\\x' + column)
tdSql.execute(sql) 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;") tdSql.execute("flush database db;")
# check the data # check the data
for i in range(self.child_table_num): for i in range(self.child_table_num):
tdSql.query(f"select * from ct_varbinary{i+1};") tdSql.query(f"select * from ct_varbinary{i+1};")
tdSql.checkRows(2400) tdSql.checkRows(self.rows_all2)
row_num = random.randint(0, 2399) row_num = random.randint(0, self.rows_all2-1)
tdSql.checkData(row_num, 1, bytes.fromhex(column)) tdSql.checkData(row_num, 1, bytes.fromhex(column))
tdSql.query(f"show tags from ct_varbinary{i+1};") tdSql.query(f"show tags from ct_varbinary{i+1};")
tdSql.checkData(0, 5, '\\x' + tag.upper()) tdSql.checkData(0, 5, '\\x' + tag.upper())
def test_json_tag_boundary(self): def test_json_tag_boundary(self):
row_num_per_round = 8
max_json_tag_length = 4095 max_json_tag_length = 4095
max_json_tag_key_length = 256 max_json_tag_key_length = 256
# create tables # create tables
@ -153,16 +155,16 @@ class TDTestCase(TBase):
# insert data # insert data
for j in range(self.insert_round_num): for j in range(self.insert_round_num):
sql = "insert into ct_json_tag%s values" % (i+1) 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) sql += "(%s, '%s')," % (str(self.start_ts + (j * self.insert_round_num + k * self.row_num_per_round + 1)), '\\x' + column)
tdSql.execute(sql) 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;") tdSql.execute("flush database db;")
# check the data # check the data
for i in range(self.child_table_num): 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.query(f"select * from ct_json_tag{i+1} where t1->'{tag_key}' = '{tag_value}';")
tdSql.checkRows(2400) tdSql.checkRows(self.rows_all2)
row_num = random.randint(0, 2399) row_num = random.randint(0, self.rows_all2-1)
tdSql.checkData(row_num, 1, bytes.fromhex(column)) tdSql.checkData(row_num, 1, bytes.fromhex(column))
def run(self): def run(self):

89
tests/ci/count_assert.py
View File

@ -1,23 +1,45 @@
import os import os
import re import re
from loguru import logger
# List of source directories to search # 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 = [ source_dirs = [
"community/source", f"{TD_project_path}/community/source",
"community/include", f"{TD_project_path}/community/include",
"enterprise/src/plugins/" f"{TD_project_path}/enterprise/src/plugins/"
] ]
# List of directories to exclude # List of directories to exclude
exclude_dirs = [ exclude_dirs = [
"community/source/client/jni" f"{TD_project_path}/community/source/client/jni"
] ]
# List of files to exclude # List of files to exclude
exclude_source_files = [ exclude_source_files = [
"community/source/libs/parser/src/sql.c", f"{TD_project_path}/community/source/libs/parser/src/sql.c",
"community/source/util/src/tlog.c", f"{TD_project_path}/community/source/util/src/tlog.c",
"community/include/util/tlog.h" f"{TD_project_path}/community/include/util/tlog.h"
] ]
def grep_asserts_in_file(file_path, summary_list, detaild_list): 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: with open(file_path, 'r') as file:
for line_number, line in enumerate(file, start=1): for line_number, line in enumerate(file, start=1):
if re.search(r'\bassert\(.*\)|\bASSERT\(.*\)|\bASSERTS\(.*\)|\bASSERT_CORE\(.*\)', line): 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 match_count += 1
if match_count > 0: 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): 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.""" """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) grep_asserts_in_file(file_path, summary_list, detaild_list)
return 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__": if __name__ == "__main__":
summary_list, detaild_list = traverse_and_grep(source_dirs, exclude_dirs, exclude_source_files) summary_list, detaild_list = traverse_and_grep(source_dirs, exclude_dirs, exclude_source_files)
print("\n".join(summary_list)) check_list_result(summary_list,detaild_list)
# print("\n".join(detaild_list))

54
tests/parallel_test/run_check_assert_container.sh Executable file
View File

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