diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h index dff212b15c..5f322be99b 100644 --- a/include/libs/stream/tstream.h +++ b/include/libs/stream/tstream.h @@ -686,7 +686,7 @@ int32_t streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration); bool streamHistoryTaskSetVerRangeStep2(SStreamTask* pTask, int64_t latestVer); // checkpoint related -int32_t streamTaskGetActiveCheckpointInfo(const SStreamTask* pTask, int32_t* pTransId, int64_t* pCheckpointId); +void streamTaskGetActiveCheckpointInfo(const SStreamTask* pTask, int32_t* pTransId, int64_t* pCheckpointId); int32_t streamTaskSetActiveCheckpointInfo(SStreamTask* pTask, int64_t activeCheckpointId); int32_t streamTaskSetFailedChkptInfo(SStreamTask* pTask, int32_t transId, int64_t checkpointId); bool streamTaskAlreadySendTrigger(SStreamTask* pTask, int32_t downstreamNodeId); @@ -770,9 +770,9 @@ bool streamMetaAllTasksReady(const SStreamMeta* pMeta); int32_t streamTaskSendRestoreChkptMsg(SStreamTask* pTask); // timer -tmr_h streamTimerGetInstance(); -void streamTmrReset(TAOS_TMR_CALLBACK fp, int32_t mseconds, void* param, void* handle, tmr_h* pTmrId, int32_t vgId, - const char* pMsg); +int32_t streamTimerGetInstance(tmr_h* pTmr); +void streamTmrReset(TAOS_TMR_CALLBACK fp, int32_t mseconds, void* param, void* handle, tmr_h* pTmrId, int32_t vgId, + const char* pMsg); // checkpoint int32_t streamProcessCheckpointSourceReq(SStreamTask* pTask, SStreamCheckpointSourceReq* pReq); @@ -809,6 +809,9 @@ void streamTaskSendRetrieveRsp(SStreamRetrieveReq* pReq, SRpcMsg* pRsp); int32_t streamProcessHeartbeatRsp(SStreamMeta* pMeta, SMStreamHbRspMsg* pRsp); int32_t streamTaskSendCheckpointsourceRsp(SStreamTask* pTask); +void streamMutexLock(TdThreadMutex *pMutex); +void streamMutexUnlock(TdThreadMutex *pMutex); +void streamMutexDestroy(TdThreadMutex *pMutex); #ifdef __cplusplus } diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c index d12db23a43..6746d0343b 100644 --- a/source/common/src/tdatablock.c +++ b/source/common/src/tdatablock.c @@ -2491,7 +2491,7 @@ int32_t buildCtbNameByGroupIdImpl(const char* stbFullName, uint64_t groupId, cha .tags = tags, .stbFullName = stbFullName, .stbFullNameLen = strlen(stbFullName), .ctbShortName = cname}; int32_t code = buildChildTableName(&rname); - if(code != TSDB_CODE_SUCCESS){ + if (code != TSDB_CODE_SUCCESS) { return code; } taosArrayDestroy(tags); diff --git a/source/common/src/tmisce.c b/source/common/src/tmisce.c index 7b349e91b0..154fcc3f6b 100644 --- a/source/common/src/tmisce.c +++ b/source/common/src/tmisce.c @@ -150,7 +150,6 @@ int32_t epsetToStr(const SEpSet* pEpSet, char* pBuf, int32_t cap) { cap -= nwrite; for (int _i = 0; (_i < pEpSet->numOfEps) && (cap > 0); _i++) { - int32_t ret = 0; if (_i == pEpSet->numOfEps - 1) { ret = snprintf(pBuf + nwrite, cap, "%d. %s:%d", _i, pEpSet->eps[_i].fqdn, pEpSet->eps[_i].port); } else { diff --git a/source/dnode/mnode/impl/inc/mndStream.h b/source/dnode/mnode/impl/inc/mndStream.h index 0b6b6a9ef2..bd0d97e34d 100644 --- a/source/dnode/mnode/impl/inc/mndStream.h +++ b/source/dnode/mnode/impl/inc/mndStream.h @@ -96,57 +96,58 @@ typedef struct STaskChkptInfo { int8_t dropHTask; }STaskChkptInfo; -int32_t mndInitStream(SMnode *pMnode); -void mndCleanupStream(SMnode *pMnode); -SStreamObj *mndAcquireStream(SMnode *pMnode, char *streamName); -void mndReleaseStream(SMnode *pMnode, SStreamObj *pStream); -int32_t mndDropStreamByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb); -int32_t mndPersistStream(STrans *pTrans, SStreamObj *pStream); -int32_t mndStreamRegisterTrans(STrans *pTrans, const char *pTransName, int64_t streamId); -int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt); -bool mndStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char *pTransName, bool lock); -int32_t mndStreamGetRelTrans(SMnode *pMnode, int64_t streamId); +int32_t mndInitStream(SMnode *pMnode); +void mndCleanupStream(SMnode *pMnode); +int32_t mndAcquireStream(SMnode *pMnode, char *streamName, SStreamObj **pStream); +void mndReleaseStream(SMnode *pMnode, SStreamObj *pStream); +int32_t mndDropStreamByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb); +int32_t mndPersistStream(STrans *pTrans, SStreamObj *pStream); +int32_t mndStreamRegisterTrans(STrans *pTrans, const char *pTransName, int64_t streamId); +int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt); +bool mndStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char *pTransName, bool lock); +int32_t mndStreamGetRelTrans(SMnode *pMnode, int64_t streamId); int32_t mndGetNumOfStreams(SMnode *pMnode, char *dbName, int32_t *pNumOfStreams); int32_t mndGetNumOfStreamTasks(const SStreamObj *pStream); -SArray *mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady); +int32_t mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady, SArray** pList); void mndKillTransImpl(SMnode *pMnode, int32_t transId, const char *pDbName); int32_t setTransAction(STrans *pTrans, void *pCont, int32_t contLen, int32_t msgType, const SEpSet *pEpset, int32_t retryCode, int32_t acceptCode); -STrans *doCreateTrans(SMnode *pMnode, SStreamObj *pStream, SRpcMsg *pReq, ETrnConflct conflict, const char *name, const char *pMsg); +int32_t doCreateTrans(SMnode *pMnode, SStreamObj *pStream, SRpcMsg *pReq, ETrnConflct conflict, const char *name, + const char *pMsg, STrans **pTrans1); int32_t mndPersistTransLog(SStreamObj *pStream, STrans *pTrans, int32_t status); SSdbRaw *mndStreamActionEncode(SStreamObj *pStream); void killAllCheckpointTrans(SMnode *pMnode, SVgroupChangeInfo *pChangeInfo); int32_t mndStreamSetUpdateEpsetAction(SMnode *pMnode, SStreamObj *pStream, SVgroupChangeInfo *pInfo, STrans *pTrans); -SStreamObj *mndGetStreamObj(SMnode *pMnode, int64_t streamId); -int32_t extractNodeEpset(SMnode *pMnode, SEpSet *pEpSet, bool *hasEpset, int32_t taskId, int32_t nodeId); -int32_t mndProcessStreamHb(SRpcMsg *pReq); -void saveTaskAndNodeInfoIntoBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode); -int32_t extractStreamNodeList(SMnode *pMnode); -int32_t mndStreamSetResumeAction(STrans *pTrans, SMnode *pMnode, SStreamObj *pStream, int8_t igUntreated); -int32_t mndStreamSetPauseAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); -int32_t mndStreamSetDropAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); -int32_t mndStreamSetDropActionFromList(SMnode *pMnode, STrans *pTrans, SArray *pList); -int32_t mndStreamSetResetTaskAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); -int32_t mndCreateStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream); -int32_t mndStreamSetUpdateChkptAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); -int32_t mndCreateStreamChkptInfoUpdateTrans(SMnode *pMnode, SStreamObj *pStream, SArray *pChkptInfoList); -int32_t mndScanCheckpointReportInfo(SRpcMsg *pReq); -int32_t mndCreateSetConsensusChkptIdTrans(SMnode *pMnode, SStreamObj *pStream, int32_t taskId, int64_t checkpointId, - int64_t ts); -void removeTasksInBuf(SArray *pTaskIds, SStreamExecInfo *pExecInfo); +int32_t mndGetStreamObj(SMnode *pMnode, int64_t streamId, SStreamObj** pStream); +int32_t extractNodeEpset(SMnode *pMnode, SEpSet *pEpSet, bool *hasEpset, int32_t taskId, int32_t nodeId); +int32_t mndProcessStreamHb(SRpcMsg *pReq); +void saveTaskAndNodeInfoIntoBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode); +int32_t extractStreamNodeList(SMnode *pMnode); +int32_t mndStreamSetResumeAction(STrans *pTrans, SMnode *pMnode, SStreamObj *pStream, int8_t igUntreated); +int32_t mndStreamSetPauseAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); +int32_t mndStreamSetDropAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); +int32_t mndStreamSetDropActionFromList(SMnode *pMnode, STrans *pTrans, SArray *pList); +int32_t mndStreamSetResetTaskAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); +int32_t mndCreateStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream); +int32_t mndStreamSetUpdateChkptAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream); +int32_t mndCreateStreamChkptInfoUpdateTrans(SMnode *pMnode, SStreamObj *pStream, SArray *pChkptInfoList); +int32_t mndScanCheckpointReportInfo(SRpcMsg *pReq); +int32_t mndCreateSetConsensusChkptIdTrans(SMnode *pMnode, SStreamObj *pStream, int32_t taskId, int64_t checkpointId, + int64_t ts); +void removeTasksInBuf(SArray *pTaskIds, SStreamExecInfo *pExecInfo); -SStreamTaskIter *createStreamTaskIter(SStreamObj *pStream); -void destroyStreamTaskIter(SStreamTaskIter *pIter); -bool streamTaskIterNextTask(SStreamTaskIter *pIter); -SStreamTask *streamTaskIterGetCurrent(SStreamTaskIter *pIter); -void mndInitExecInfo(); -void mndInitStreamExecInfo(SMnode *pMnode, SStreamExecInfo *pExecInfo); -int32_t removeExpiredNodeEntryAndTaskInBuf(SArray *pNodeSnapshot); -void removeStreamTasksInBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode); +int32_t createStreamTaskIter(SStreamObj *pStream, SStreamTaskIter **pIter); +void destroyStreamTaskIter(SStreamTaskIter *pIter); +bool streamTaskIterNextTask(SStreamTaskIter *pIter); +int32_t streamTaskIterGetCurrent(SStreamTaskIter *pIter, SStreamTask **pTask); +int32_t mndInitExecInfo(); +void mndInitStreamExecInfo(SMnode *pMnode, SStreamExecInfo *pExecInfo); +int32_t removeExpiredNodeEntryAndTaskInBuf(SArray *pNodeSnapshot); +void removeStreamTasksInBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode); -SCheckpointConsensusInfo *mndGetConsensusInfo(SHashObj *pHash, int64_t streamId, int32_t numOfTasks); +int32_t mndGetConsensusInfo(SHashObj *pHash, int64_t streamId, int32_t numOfTasks, SCheckpointConsensusInfo **pInfo); void mndAddConsensusTasks(SCheckpointConsensusInfo *pInfo, const SRestoreCheckpointInfo *pRestoreInfo); void mndClearConsensusRspEntry(SCheckpointConsensusInfo *pInfo); int64_t mndClearConsensusCheckpointId(SHashObj* pHash, int64_t streamId); diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c index 9dc5f920ad..aacf391236 100644 --- a/source/dnode/mnode/impl/src/mndDef.c +++ b/source/dnode/mnode/impl/src/mndDef.c @@ -12,173 +12,179 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ - #define _DEFAULT_SOURCE #include "mndDef.h" #include "mndConsumer.h" +#include "taoserror.h" static void *freeStreamTasks(SArray *pTaskLevel); int32_t tEncodeSStreamObj(SEncoder *pEncoder, const SStreamObj *pObj) { - if (tStartEncode(pEncoder) < 0) return -1; - if (tEncodeCStr(pEncoder, pObj->name) < 0) return -1; + TAOS_CHECK_RETURN(tStartEncode(pEncoder)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->name)); - if (tEncodeI64(pEncoder, pObj->createTime) < 0) return -1; - if (tEncodeI64(pEncoder, pObj->updateTime) < 0) return -1; - if (tEncodeI32(pEncoder, pObj->version) < 0) return -1; - if (tEncodeI32(pEncoder, pObj->totalLevel) < 0) return -1; - if (tEncodeI64(pEncoder, pObj->smaId) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->createTime)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->updateTime)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pObj->version)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pObj->totalLevel)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->smaId)); - if (tEncodeI64(pEncoder, pObj->uid) < 0) return -1; - if (tEncodeI8(pEncoder, pObj->status) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->uid)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->status)); - if (tEncodeI8(pEncoder, pObj->conf.igExpired) < 0) return -1; - if (tEncodeI8(pEncoder, pObj->conf.trigger) < 0) return -1; - if (tEncodeI8(pEncoder, pObj->conf.fillHistory) < 0) return -1; - if (tEncodeI64(pEncoder, pObj->conf.triggerParam) < 0) return -1; - if (tEncodeI64(pEncoder, pObj->conf.watermark) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->conf.igExpired)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->conf.trigger)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->conf.fillHistory)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->conf.triggerParam)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->conf.watermark)); - if (tEncodeI64(pEncoder, pObj->sourceDbUid) < 0) return -1; - if (tEncodeI64(pEncoder, pObj->targetDbUid) < 0) return -1; - if (tEncodeCStr(pEncoder, pObj->sourceDb) < 0) return -1; - if (tEncodeCStr(pEncoder, pObj->targetDb) < 0) return -1; - if (tEncodeCStr(pEncoder, pObj->targetSTbName) < 0) return -1; - if (tEncodeI64(pEncoder, pObj->targetStbUid) < 0) return -1; - if (tEncodeI32(pEncoder, pObj->fixedSinkVgId) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->sourceDbUid)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->targetDbUid)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->sourceDb)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->targetDb)); + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->targetSTbName)); + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->targetStbUid)); + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pObj->fixedSinkVgId)); if (pObj->sql != NULL) { - if (tEncodeCStr(pEncoder, pObj->sql) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->sql)); } else { - if (tEncodeCStr(pEncoder, "") < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, "")); } if (pObj->ast != NULL) { - if (tEncodeCStr(pEncoder, pObj->ast) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->ast)); } else { - if (tEncodeCStr(pEncoder, "") < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, "")); } if (pObj->physicalPlan != NULL) { - if (tEncodeCStr(pEncoder, pObj->physicalPlan) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->physicalPlan)); } else { - if (tEncodeCStr(pEncoder, "") < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, "")); } int32_t sz = taosArrayGetSize(pObj->tasks); - if (tEncodeI32(pEncoder, sz) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, sz)); for (int32_t i = 0; i < sz; i++) { SArray *pArray = taosArrayGetP(pObj->tasks, i); int32_t innerSz = taosArrayGetSize(pArray); - if (tEncodeI32(pEncoder, innerSz) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32(pEncoder, innerSz)); for (int32_t j = 0; j < innerSz; j++) { SStreamTask *pTask = taosArrayGetP(pArray, j); if (pTask->ver < SSTREAM_TASK_SUBTABLE_CHANGED_VER){ pTask->ver = SSTREAM_TASK_VER; } - if (tEncodeStreamTask(pEncoder, pTask) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeStreamTask(pEncoder, pTask)); } } - if (tEncodeSSchemaWrapper(pEncoder, &pObj->outputSchema) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pEncoder, &pObj->outputSchema)); // 3.0.20 ver =2 - if (tEncodeI64(pEncoder, pObj->checkpointFreq) < 0) return -1; - if (tEncodeI8(pEncoder, pObj->igCheckUpdate) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->checkpointFreq)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->igCheckUpdate)); // 3.0.50 ver = 3 - if (tEncodeI64(pEncoder, pObj->checkpointId) < 0) return -1; - if (tEncodeI8(pEncoder, pObj->subTableWithoutMd5) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->checkpointId)); + TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->subTableWithoutMd5)); - if (tEncodeCStrWithLen(pEncoder, pObj->reserve, sizeof(pObj->reserve) - 1) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStrWithLen(pEncoder, pObj->reserve, sizeof(pObj->reserve) - 1)); tEndEncode(pEncoder); return pEncoder->pos; } int32_t tDecodeSStreamObj(SDecoder *pDecoder, SStreamObj *pObj, int32_t sver) { - if (tStartDecode(pDecoder) < 0) return -1; - if (tDecodeCStrTo(pDecoder, pObj->name) < 0) return -1; + int32_t code = 0; + TAOS_CHECK_RETURN(tStartDecode(pDecoder)); + TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->name)); - if (tDecodeI64(pDecoder, &pObj->createTime) < 0) return -1; - if (tDecodeI64(pDecoder, &pObj->updateTime) < 0) return -1; - if (tDecodeI32(pDecoder, &pObj->version) < 0) return -1; - if (tDecodeI32(pDecoder, &pObj->totalLevel) < 0) return -1; - if (tDecodeI64(pDecoder, &pObj->smaId) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->createTime)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->updateTime)); + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pObj->version)); + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pObj->totalLevel)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->smaId)); - if (tDecodeI64(pDecoder, &pObj->uid) < 0) return -1; - if (tDecodeI8(pDecoder, &pObj->status) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->uid)); + TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->status)); - if (tDecodeI8(pDecoder, &pObj->conf.igExpired) < 0) return -1; - if (tDecodeI8(pDecoder, &pObj->conf.trigger) < 0) return -1; - if (tDecodeI8(pDecoder, &pObj->conf.fillHistory) < 0) return -1; - if (tDecodeI64(pDecoder, &pObj->conf.triggerParam) < 0) return -1; - if (tDecodeI64(pDecoder, &pObj->conf.watermark) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->conf.igExpired)); + TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->conf.trigger)); + TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->conf.fillHistory)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->conf.triggerParam)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->conf.watermark)); - if (tDecodeI64(pDecoder, &pObj->sourceDbUid) < 0) return -1; - if (tDecodeI64(pDecoder, &pObj->targetDbUid) < 0) return -1; - if (tDecodeCStrTo(pDecoder, pObj->sourceDb) < 0) return -1; - if (tDecodeCStrTo(pDecoder, pObj->targetDb) < 0) return -1; - if (tDecodeCStrTo(pDecoder, pObj->targetSTbName) < 0) return -1; - if (tDecodeI64(pDecoder, &pObj->targetStbUid) < 0) return -1; - if (tDecodeI32(pDecoder, &pObj->fixedSinkVgId) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->sourceDbUid)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->targetDbUid)); + TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->sourceDb)); + TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->targetDb)); + TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->targetSTbName)); + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->targetStbUid)); + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pObj->fixedSinkVgId)); - if (tDecodeCStrAlloc(pDecoder, &pObj->sql) < 0) return -1; - if (tDecodeCStrAlloc(pDecoder, &pObj->ast) < 0) return -1; - if (tDecodeCStrAlloc(pDecoder, &pObj->physicalPlan) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeCStrAlloc(pDecoder, &pObj->sql)); + TAOS_CHECK_RETURN(tDecodeCStrAlloc(pDecoder, &pObj->ast)); + TAOS_CHECK_RETURN(tDecodeCStrAlloc(pDecoder, &pObj->physicalPlan)); if (pObj->tasks != NULL) { pObj->tasks = freeStreamTasks(pObj->tasks); } int32_t sz; - if (tDecodeI32(pDecoder, &sz) < 0) { - return -1; - } + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &sz)); if (sz != 0) { pObj->tasks = taosArrayInit(sz, sizeof(void *)); + if (pObj->tasks == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TAOS_RETURN(code); + } for (int32_t i = 0; i < sz; i++) { int32_t innerSz; - if (tDecodeI32(pDecoder, &innerSz) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &innerSz)); SArray *pArray = taosArrayInit(innerSz, sizeof(void *)); - for (int32_t j = 0; j < innerSz; j++) { - SStreamTask *pTask = taosMemoryCalloc(1, sizeof(SStreamTask)); - if (pTask == NULL) { - taosArrayDestroy(pArray); - return -1; + if (pArray != NULL) { + for (int32_t j = 0; j < innerSz; j++) { + SStreamTask *pTask = taosMemoryCalloc(1, sizeof(SStreamTask)); + if (pTask == NULL) { + taosArrayDestroy(pArray); + code = TSDB_CODE_OUT_OF_MEMORY; + TAOS_RETURN(code); + } + if ((code = tDecodeStreamTask(pDecoder, pTask)) < 0) { + taosMemoryFree(pTask); + taosArrayDestroy(pArray); + TAOS_RETURN(code); + } + taosArrayPush(pArray, &pTask); } - if (tDecodeStreamTask(pDecoder, pTask) < 0) { - taosMemoryFree(pTask); - taosArrayDestroy(pArray); - return -1; - } - taosArrayPush(pArray, &pTask); } taosArrayPush(pObj->tasks, &pArray); } } - if (tDecodeSSchemaWrapper(pDecoder, &pObj->outputSchema) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeSSchemaWrapper(pDecoder, &pObj->outputSchema)); // 3.0.20 if (sver >= 2) { - if (tDecodeI64(pDecoder, &pObj->checkpointFreq) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->checkpointFreq)); if (!tDecodeIsEnd(pDecoder)) { - if (tDecodeI8(pDecoder, &pObj->igCheckUpdate) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->igCheckUpdate)); } } if (sver >= 3) { - if (tDecodeI64(pDecoder, &pObj->checkpointId) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->checkpointId)); } if (sver >= 5) { - if (tDecodeI8(pDecoder, &pObj->subTableWithoutMd5) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->subTableWithoutMd5)); } - if (tDecodeCStrTo(pDecoder, pObj->reserve) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->reserve)); tEndDecode(pDecoder); - return 0; + TAOS_RETURN(code); } void *freeStreamTasks(SArray *pTaskLevel) { @@ -220,7 +226,10 @@ void tFreeStreamObj(SStreamObj *pStream) { SMqVgEp *tCloneSMqVgEp(const SMqVgEp *pVgEp) { SMqVgEp *pVgEpNew = taosMemoryMalloc(sizeof(SMqVgEp)); - if (pVgEpNew == NULL) return NULL; + if (pVgEpNew == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } pVgEpNew->vgId = pVgEp->vgId; // pVgEpNew->qmsg = taosStrdup(pVgEp->qmsg); pVgEpNew->epSet = pVgEp->epSet; @@ -256,6 +265,7 @@ void *tDecodeSMqVgEp(const void *buf, SMqVgEp *pVgEp, int8_t sver) { static void *topicNameDup(void *p) { return taosStrdup((char *)p); } SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, char *topic, SCMSubscribeReq *subscribe) { + terrno = 0; SMqConsumerObj *pConsumer = taosMemoryCalloc(1, sizeof(SMqConsumerObj)); if (pConsumer == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -531,8 +541,10 @@ void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t s } SMqSubscribeObj *tNewSubscribeObj(const char *key) { + terrno = 0; SMqSubscribeObj *pSubObj = taosMemoryCalloc(1, sizeof(SMqSubscribeObj)); if (pSubObj == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } @@ -548,8 +560,12 @@ SMqSubscribeObj *tNewSubscribeObj(const char *key) { } SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) { + terrno = 0; SMqSubscribeObj *pSubNew = taosMemoryMalloc(sizeof(SMqSubscribeObj)); - if (pSubNew == NULL) return NULL; + if (pSubNew == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN); taosInitRWLatch(&pSubNew->lock); diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c index a0163f9d4f..cd3b613ff6 100644 --- a/source/dnode/mnode/impl/src/mndDnode.c +++ b/source/dnode/mnode/impl/src/mndDnode.c @@ -166,15 +166,24 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) { } pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, NULL, "create-dnode"); - if (pTrans == NULL) goto _OVER; + if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } mInfo("trans:%d, used to create dnode:%s on first deploy", pTrans->id, dnodeObj.ep); pRaw = mndDnodeActionEncode(&dnodeObj); - if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER; + if (pRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pRaw), NULL, _OVER); (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); pRaw = NULL; - if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); code = 0; mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); // TODO: check the return value @@ -575,10 +584,7 @@ static int32_t mndProcessStatisReq(SRpcMsg *pReq) { SStatisReq statisReq = {0}; int32_t code = -1; - if (tDeserializeSStatisReq(pReq->pCont, pReq->contLen, &statisReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - return code; - } + TAOS_CHECK_RETURN(tDeserializeSStatisReq(pReq->pCont, pReq->contLen, &statisReq)); if (tsMonitorLogProtocol) { mInfo("process statis req,\n %s", statisReq.pCont); @@ -598,23 +604,28 @@ static int32_t mndUpdateDnodeObj(SMnode *pMnode, SDnodeObj *pDnode) { int32_t code = 0; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, NULL, "update-dnode-obj"); if (pTrans == NULL) { - code = terrno; + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; goto _exit; } pDnode->updateTime = taosGetTimestampMs(); SSdbRaw *pCommitRaw = mndDnodeActionEncode(pDnode); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { - mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr()); + if (pCommitRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _exit; + } + if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) { + mError("trans:%d, failed to append commit log since %s", pTrans->id, tstrerror(code)); code = terrno; goto _exit; } (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); - if (mndTransPrepare(pMnode, pTrans) != 0) { - mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - code = terrno; + if ((code = mndTransPrepare(pMnode, pTrans)) != 0) { + mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code)); goto _exit; } @@ -629,10 +640,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) { SDnodeObj *pDnode = NULL; int32_t code = -1; - if (tDeserializeSStatusReq(pReq->pCont, pReq->contLen, &statusReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - goto _OVER; - } + TAOS_CHECK_GOTO(tDeserializeSStatusReq(pReq->pCont, pReq->contLen, &statusReq), NULL, _OVER); int64_t clusterid = mndGetClusterId(pMnode); if (statusReq.clusterId != 0 && statusReq.clusterId != clusterid) { @@ -646,6 +654,8 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) { pDnode = mndAcquireDnodeByEp(pMnode, statusReq.dnodeEp); if (pDnode == NULL) { mInfo("dnode:%s, not created yet", statusReq.dnodeEp); + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; goto _OVER; } } else { @@ -883,16 +893,25 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", pCreate->fqdn, pCreate->port); pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_GLOBAL, pReq, "create-dnode"); - if (pTrans == NULL) goto _OVER; + if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } mInfo("trans:%d, used to create dnode:%s", pTrans->id, dnodeObj.ep); - if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER); pRaw = mndDnodeActionEncode(&dnodeObj); - if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER; + if (pRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pRaw), NULL, _OVER); (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); pRaw = NULL; - if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); code = 0; mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); // TODO: check the return value @@ -913,7 +932,7 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) { rsp.dnodeList = taosArrayInit(5, sizeof(SEpSet)); if (NULL == rsp.dnodeList) { mError("failed to alloc epSet while process dnode list req"); - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto _OVER; } @@ -934,7 +953,7 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) { int32_t rspLen = tSerializeSDnodeListRsp(NULL, 0, &rsp); void *pRsp = rpcMallocCont(rspLen); if (pRsp == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto _OVER; } @@ -947,12 +966,12 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) { _OVER: if (code != 0) { - mError("failed to get dnode list since %s", terrstr()); + mError("failed to get dnode list since %s", tstrerror(code)); } tFreeSDnodeListRsp(&rsp); - return code; + TAOS_RETURN(code); } static void getSlowLogScopeString(int32_t scope, char* result){ @@ -992,7 +1011,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) { rsp.variables = taosArrayInit(16, sizeof(SVariablesInfo)); if (NULL == rsp.variables) { mError("failed to alloc SVariablesInfo array while process show variables req"); - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto _OVER; } @@ -1048,7 +1067,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) { int32_t rspLen = tSerializeSShowVariablesRsp(NULL, 0, &rsp); void *pRsp = rpcMallocCont(rspLen); if (pRsp == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto _OVER; } @@ -1061,11 +1080,11 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) { _OVER: if (code != 0) { - mError("failed to get show variables info since %s", terrstr()); + mError("failed to get show variables info since %s", tstrerror(code)); } tFreeSShowVariablesRsp(&rsp); - return code; + TAOS_RETURN(code); } static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) { @@ -1074,23 +1093,17 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) { SDnodeObj *pDnode = NULL; SCreateDnodeReq createReq = {0}; - if ((terrno = grantCheck(TSDB_GRANT_DNODE)) != 0 || (terrno = grantCheck(TSDB_GRANT_CPU_CORES)) != 0) { - code = terrno; + if ((code = grantCheck(TSDB_GRANT_DNODE)) != 0 || (code = grantCheck(TSDB_GRANT_CPU_CORES)) != 0) { goto _OVER; } - if (tDeserializeSCreateDnodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - goto _OVER; - } + TAOS_CHECK_GOTO(tDeserializeSCreateDnodeReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER); mInfo("dnode:%s:%d, start to create", createReq.fqdn, createReq.port); - if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DNODE) != 0) { - goto _OVER; - } + TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DNODE), NULL, _OVER); if (createReq.fqdn[0] == 0 || createReq.port <= 0 || createReq.port > UINT16_MAX) { - terrno = TSDB_CODE_MND_INVALID_DNODE_EP; + code = TSDB_CODE_MND_INVALID_DNODE_EP; goto _OVER; } @@ -1098,7 +1111,7 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) { snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port); pDnode = mndAcquireDnodeByEp(pMnode, ep); if (pDnode != NULL) { - terrno = TSDB_CODE_MND_DNODE_ALREADY_EXIST; + code = TSDB_CODE_MND_DNODE_ALREADY_EXIST; goto _OVER; } @@ -1115,12 +1128,12 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) { _OVER: if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("dnode:%s:%d, failed to create since %s", createReq.fqdn, createReq.port, terrstr()); + mError("dnode:%s:%d, failed to create since %s", createReq.fqdn, createReq.port, tstrerror(code)); } mndReleaseDnode(pMnode, pDnode); tFreeSCreateDnodeReq(&createReq); - return code; + TAOS_RETURN(code); } extern int32_t mndProcessRestoreDnodeReqImpl(SRpcMsg *pReq); @@ -1138,44 +1151,56 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM STrans *pTrans = NULL; pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "drop-dnode"); - if (pTrans == NULL) goto _OVER; + if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } mndTransSetSerial(pTrans); mInfo("trans:%d, used to drop dnode:%d, force:%d", pTrans->id, pDnode->id, force); - if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER); pRaw = mndDnodeActionEncode(pDnode); - if (pRaw == NULL) goto _OVER; - if (mndTransAppendRedolog(pTrans, pRaw) != 0) goto _OVER; + if (pRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRaw), NULL, _OVER); (void)sdbSetRawStatus(pRaw, SDB_STATUS_DROPPING); pRaw = NULL; pRaw = mndDnodeActionEncode(pDnode); - if (pRaw == NULL) goto _OVER; - if (mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER; + if (pRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pRaw), NULL, _OVER); (void)sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED); pRaw = NULL; if (pMObj != NULL) { mInfo("trans:%d, mnode on dnode:%d will be dropped", pTrans->id, pDnode->id); - if (mndSetDropMnodeInfoToTrans(pMnode, pTrans, pMObj, force) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndSetDropMnodeInfoToTrans(pMnode, pTrans, pMObj, force), NULL, _OVER); } if (pQObj != NULL) { mInfo("trans:%d, qnode on dnode:%d will be dropped", pTrans->id, pDnode->id); - if (mndSetDropQnodeInfoToTrans(pMnode, pTrans, pQObj, force) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndSetDropQnodeInfoToTrans(pMnode, pTrans, pQObj, force), NULL, _OVER); } if (pSObj != NULL) { mInfo("trans:%d, snode on dnode:%d will be dropped", pTrans->id, pDnode->id); - if (mndSetDropSnodeInfoToTrans(pMnode, pTrans, pSObj, force) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndSetDropSnodeInfoToTrans(pMnode, pTrans, pSObj, force), NULL, _OVER); } if (numOfVnodes > 0) { mInfo("trans:%d, %d vnodes on dnode:%d will be dropped", pTrans->id, numOfVnodes, pDnode->id); - if (mndSetMoveVgroupsInfoToTrans(pMnode, pTrans, pDnode->id, force, unsafe) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndSetMoveVgroupsInfoToTrans(pMnode, pTrans, pDnode->id, force, unsafe), NULL, _OVER); } - if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1); // TODO: check the return value code = 0; @@ -1183,7 +1208,7 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM _OVER: mndTransDrop(pTrans); sdbFreeRaw(pRaw); - return code; + TAOS_RETURN(code); } static bool mndIsEmptyDnode(SMnode *pMnode, int32_t dnodeId) { @@ -1221,16 +1246,11 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) { SSnodeObj *pSObj = NULL; SDropDnodeReq dropReq = {0}; - if (tDeserializeSDropDnodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - goto _OVER; - } + TAOS_CHECK_GOTO(tDeserializeSDropDnodeReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER); mInfo("dnode:%d, start to drop, ep:%s:%d, force:%s, unsafe:%s", dropReq.dnodeId, dropReq.fqdn, dropReq.port, dropReq.force ? "true" : "false", dropReq.unsafe ? "true" : "false"); - if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_MNODE) != 0) { - goto _OVER; - } + TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_MNODE), NULL, _OVER); bool force = dropReq.force; if (dropReq.unsafe) { @@ -1244,7 +1264,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) { snprintf(ep, sizeof(ep), dropReq.fqdn, dropReq.port); pDnode = mndAcquireDnodeByEp(pMnode, ep); if (pDnode == NULL) { - terrno = err; + code = err; goto _OVER; } } @@ -1254,11 +1274,11 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) { pMObj = mndAcquireMnode(pMnode, dropReq.dnodeId); if (pMObj != NULL) { if (sdbGetSize(pMnode->pSdb, SDB_MNODE) <= 1) { - terrno = TSDB_CODE_MND_TOO_FEW_MNODES; + code = TSDB_CODE_MND_TOO_FEW_MNODES; goto _OVER; } if (pMnode->selfDnodeId == dropReq.dnodeId) { - terrno = TSDB_CODE_MND_CANT_DROP_LEADER; + code = TSDB_CODE_MND_CANT_DROP_LEADER; goto _OVER; } } @@ -1267,16 +1287,16 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) { bool isonline = mndIsDnodeOnline(pDnode, taosGetTimestampMs()); if (isonline && force) { - terrno = TSDB_CODE_DNODE_ONLY_USE_WHEN_OFFLINE; - mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, terrstr(), + code = TSDB_CODE_DNODE_ONLY_USE_WHEN_OFFLINE; + mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, tstrerror(code), numOfVnodes, pMObj != NULL, pQObj != NULL, pSObj != NULL); goto _OVER; } bool isEmpty = mndIsEmptyDnode(pMnode, pDnode->id); if (!isonline && !force && !isEmpty) { - terrno = TSDB_CODE_DNODE_OFFLINE; - mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, terrstr(), + code = TSDB_CODE_DNODE_OFFLINE; + mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, tstrerror(code), numOfVnodes, pMObj != NULL, pQObj != NULL, pSObj != NULL); goto _OVER; } @@ -1291,7 +1311,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) { _OVER: if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("dnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr()); + mError("dnode:%d, failed to drop since %s", dropReq.dnodeId, tstrerror(code)); } mndReleaseDnode(pMnode, pDnode); @@ -1299,11 +1319,11 @@ _OVER: mndReleaseQnode(pMnode, pQObj); mndReleaseSnode(pMnode, pSObj); tFreeSDropDnodeReq(&dropReq); - return code; + TAOS_RETURN(code); } static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) { - terrno = 0; + int32_t code = 0; char *p = pMCfgReq->config; while (*p) { if (*p == ' ') { @@ -1326,12 +1346,12 @@ static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) { strcpy(pDCfgReq->value, pMCfgReq->value); } - return 0; + TAOS_RETURN(code); _err: mError("dnode:%d, failed to config since invalid conf:%s", pMCfgReq->dnodeId, pMCfgReq->config); - terrno = TSDB_CODE_INVALID_CFG; - return -1; + code = TSDB_CODE_INVALID_CFG; + TAOS_RETURN(code); } static int32_t mndSendCfgDnodeReq(SMnode *pMnode, int32_t dnodeId, SDCfgDnodeReq *pDcfgReq) { @@ -1361,23 +1381,21 @@ static int32_t mndSendCfgDnodeReq(SMnode *pMnode, int32_t dnodeId, SDCfgDnodeReq } if (code == -1) { - terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; + code = TSDB_CODE_MND_DNODE_NOT_EXIST; } - return code; + TAOS_RETURN(code); } static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) { + int32_t code = 0; SMnode *pMnode = pReq->info.node; SMCfgDnodeReq cfgReq = {0}; - if (tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; - } + TAOS_CHECK_RETURN(tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq)); int8_t updateIpWhiteList = 0; mInfo("dnode:%d, start to config, option:%s, value:%s", cfgReq.dnodeId, cfgReq.config, cfgReq.value); - if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE) != 0) { + if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE)) != 0) { tFreeSMCfgDnodeReq(&cfgReq); - return -1; + TAOS_RETURN(code); } SDCfgDnodeReq dcfgReq = {0}; @@ -1393,26 +1411,26 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) { if (flag > 1024 * 1024 || (flag > -1 && flag < 1024) || flag < -1) { mError("dnode:%d, failed to config s3blocksize since value:%d. Valid range: -1 or [1024, 1024 * 1024]", cfgReq.dnodeId, flag); - terrno = TSDB_CODE_INVALID_CFG; + code = TSDB_CODE_INVALID_CFG; tFreeSMCfgDnodeReq(&cfgReq); - return -1; + TAOS_RETURN(code); } strcpy(dcfgReq.config, "s3blocksize"); snprintf(dcfgReq.value, TSDB_DNODE_VALUE_LEN, "%d", flag); #endif } else { - if (mndMCfg2DCfg(&cfgReq, &dcfgReq)) goto _err_out; + TAOS_CHECK_GOTO (mndMCfg2DCfg(&cfgReq, &dcfgReq), NULL, _err_out); if (strlen(dcfgReq.config) > TSDB_DNODE_CONFIG_LEN) { mError("dnode:%d, failed to config since config is too long", cfgReq.dnodeId); - terrno = TSDB_CODE_INVALID_CFG; + code = TSDB_CODE_INVALID_CFG; goto _err_out; } if (strncasecmp(dcfgReq.config, "enableWhiteList", strlen("enableWhiteList")) == 0) { updateIpWhiteList = 1; } - if (cfgCheckRangeForDynUpdate(taosGetCfg(), dcfgReq.config, dcfgReq.value, true) != 0) goto _err_out; + TAOS_CHECK_GOTO(cfgCheckRangeForDynUpdate(taosGetCfg(), dcfgReq.config, dcfgReq.value, true), NULL, _err_out); } { // audit @@ -1424,15 +1442,15 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) { tFreeSMCfgDnodeReq(&cfgReq); - int32_t code = mndSendCfgDnodeReq(pMnode, cfgReq.dnodeId, &dcfgReq); + code = mndSendCfgDnodeReq(pMnode, cfgReq.dnodeId, &dcfgReq); // dont care suss or succ; if (updateIpWhiteList) mndRefreshUserIpWhiteList(pMnode); - return code; + TAOS_RETURN(code); _err_out: tFreeSMCfgDnodeReq(&cfgReq); - return -1; + TAOS_RETURN(code); } static int32_t mndProcessConfigDnodeRsp(SRpcMsg *pRsp) { @@ -1515,17 +1533,16 @@ _exit: } static int32_t mndProcessCreateEncryptKeyReq(SRpcMsg *pReq) { + int32_t code = 0; + #ifdef TD_ENTERPRISE SMnode *pMnode = pReq->info.node; SMCfgDnodeReq cfgReq = {0}; - if (tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; - } + TAOS_CHECK_RETURN(tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq)); - if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE) != 0) { + if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE)) != 0) { tFreeSMCfgDnodeReq(&cfgReq); - return -1; + TAOS_RETURN(code); } const STraceId *trace = &pReq->info.traceId; SDCfgDnodeReq dcfgReq = {0}; @@ -1535,13 +1552,13 @@ static int32_t mndProcessCreateEncryptKeyReq(SRpcMsg *pReq) { tFreeSMCfgDnodeReq(&cfgReq); return mndProcessCreateEncryptKeyReqImpl(pReq, cfgReq.dnodeId, &dcfgReq); } else { - terrno = TSDB_CODE_PAR_INTERNAL_ERROR; + code = TSDB_CODE_PAR_INTERNAL_ERROR; tFreeSMCfgDnodeReq(&cfgReq); - return -1; + TAOS_RETURN(code); } #else - return 0; + TAOS_RETURN(code); #endif } @@ -1722,7 +1739,7 @@ static void mndCancelGetNextDnode(SMnode *pMnode, void *pIter) { // get int32_t value from 'SMCfgDnodeReq' static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pMCfgReq, int32_t optLen, int32_t *pOutValue) { - terrno = 0; + int32_t code = 0; if (' ' != pMCfgReq->config[optLen] && 0 != pMCfgReq->config[optLen]) { goto _err; } @@ -1737,12 +1754,12 @@ static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pMCfgReq, int32_t optLen, int32 *pOutValue = atoi(pMCfgReq->value); } - return 0; + TAOS_RETURN(code); _err: mError("dnode:%d, failed to config since invalid conf:%s", pMCfgReq->dnodeId, pMCfgReq->config); - terrno = TSDB_CODE_INVALID_CFG; - return -1; + code = TSDB_CODE_INVALID_CFG; + TAOS_RETURN(code); } SArray *mndGetAllDnodeFqdns(SMnode *pMnode) { diff --git a/source/dnode/mnode/impl/src/mndDump.c b/source/dnode/mnode/impl/src/mndDump.c index 5561eea405..22dbc8eb57 100644 --- a/source/dnode/mnode/impl/src/mndDump.c +++ b/source/dnode/mnode/impl/src/mndDump.c @@ -29,12 +29,14 @@ void reportStartup(const char *name, const char *desc) {} void sendRsp(SRpcMsg *pMsg) { rpcFreeCont(pMsg->pCont); } int32_t sendReq(const SEpSet *pEpSet, SRpcMsg *pMsg) { - terrno = TSDB_CODE_INVALID_PTR; - return -1; + int32_t code = 0; + code = TSDB_CODE_INVALID_PTR; + TAOS_RETURN(code); } int32_t sendSyncReq(const SEpSet *pEpSet, SRpcMsg *pMsg) { - terrno = TSDB_CODE_INVALID_PTR; - return -1; + int32_t code = 0; + code = TSDB_CODE_INVALID_PTR; + TAOS_RETURN(code); } char *i642str(int64_t val) { diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c index ffbfc7fef7..0642cb0153 100644 --- a/source/dnode/mnode/impl/src/mndFunc.c +++ b/source/dnode/mnode/impl/src/mndFunc.c @@ -227,6 +227,7 @@ static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew) { } static SFuncObj *mndAcquireFunc(SMnode *pMnode, char *funcName) { + terrno = 0; SSdb *pSdb = pMnode->pSdb; SFuncObj *pFunc = sdbAcquire(pSdb, SDB_FUNC, funcName); if (pFunc == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) { @@ -244,7 +245,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre int32_t code = -1; STrans *pTrans = NULL; - if ((terrno = grantCheck(TSDB_GRANT_USER)) < 0) { + if ((code = grantCheck(TSDB_GRANT_USER)) < 0) { return code; } @@ -264,7 +265,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre func.codeSize = pCreate->codeLen; func.pCode = taosMemoryMalloc(func.codeSize); if (func.pCode == NULL || func.pCode == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto _OVER; } @@ -274,7 +275,11 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre memcpy(func.pCode, pCreate->pCode, func.codeSize); pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pReq, "create-func"); - if (pTrans == NULL) goto _OVER; + if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } mInfo("trans:%d, used to create func:%s", pTrans->id, pCreate->name); SFuncObj *oldFunc = mndAcquireFunc(pMnode, pCreate->name); @@ -283,31 +288,61 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre func.createdTime = oldFunc->createdTime; SSdbRaw *pRedoRaw = mndFuncActionEncode(oldFunc); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER; - if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY) != 0) goto _OVER; + if (pRedoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRedoRaw), NULL, _OVER); + TAOS_CHECK_GOTO(sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY), NULL, _OVER); SSdbRaw *pUndoRaw = mndFuncActionEncode(oldFunc); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER; - if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY) != 0) goto _OVER; + if (pUndoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendUndolog(pTrans, pUndoRaw), NULL, _OVER); + TAOS_CHECK_GOTO(sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY), NULL, _OVER); SSdbRaw *pCommitRaw = mndFuncActionEncode(&func); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER; + if (pCommitRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pCommitRaw), NULL, _OVER); + TAOS_CHECK_GOTO(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY), NULL, _OVER); } else { SSdbRaw *pRedoRaw = mndFuncActionEncode(&func); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER; - if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto _OVER; + if (pRedoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRedoRaw), NULL, _OVER); + TAOS_CHECK_GOTO(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING), NULL, _OVER); SSdbRaw *pUndoRaw = mndFuncActionEncode(&func); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER; - if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto _OVER; + if (pUndoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendUndolog(pTrans, pUndoRaw), NULL, _OVER); + TAOS_CHECK_GOTO(sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED), NULL, _OVER); SSdbRaw *pCommitRaw = mndFuncActionEncode(&func); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER; + if (pCommitRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pCommitRaw), NULL, _OVER); + TAOS_CHECK_GOTO(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY), NULL, _OVER); } - if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); code = 0; @@ -319,32 +354,48 @@ _OVER: taosMemoryFree(func.pCode); taosMemoryFree(func.pComment); mndTransDrop(pTrans); - return code; + TAOS_RETURN(code); } static int32_t mndDropFunc(SMnode *pMnode, SRpcMsg *pReq, SFuncObj *pFunc) { int32_t code = -1; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pReq, "drop-func"); - if (pTrans == NULL) goto _OVER; + if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } mInfo("trans:%d, used to drop user:%s", pTrans->id, pFunc->name); SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc); - if (pRedoRaw == NULL) goto _OVER; - if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER; + if (pRedoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRedoRaw), NULL, _OVER); (void)sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING); SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc); - if (pUndoRaw == NULL) goto _OVER; - if (mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER; + if (pUndoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendUndolog(pTrans, pUndoRaw), NULL, _OVER); (void)sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY); SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc); - if (pCommitRaw == NULL) goto _OVER; - if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; + if (pCommitRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pCommitRaw), NULL, _OVER); (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED); - if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; + TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); code = 0; @@ -359,18 +410,14 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) { SFuncObj *pFunc = NULL; SCreateFuncReq createReq = {0}; - if (tDeserializeSCreateFuncReq(pReq->pCont, pReq->contLen, &createReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - goto _OVER; - } + TAOS_CHECK_GOTO(tDeserializeSCreateFuncReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER); + #ifdef WINDOWS - terrno = TSDB_CODE_MND_INVALID_PLATFORM; + code = TSDB_CODE_MND_INVALID_PLATFORM; goto _OVER; #endif mInfo("func:%s, start to create, size:%d", createReq.name, createReq.codeLen); - if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_FUNC) != 0) { - goto _OVER; - } + TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_FUNC), NULL, _OVER); pFunc = mndAcquireFunc(pMnode, createReq.name); if (pFunc != NULL) { @@ -382,7 +429,7 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) { mInfo("func:%s, replace function is set", createReq.name); code = 0; } else { - terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST; + code = TSDB_CODE_MND_FUNC_ALREADY_EXIST; goto _OVER; } } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) { @@ -390,22 +437,22 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) { } if (createReq.name[0] == 0) { - terrno = TSDB_CODE_MND_INVALID_FUNC_NAME; + code = TSDB_CODE_MND_INVALID_FUNC_NAME; goto _OVER; } if (createReq.pCode == NULL) { - terrno = TSDB_CODE_MND_INVALID_FUNC_CODE; + code = TSDB_CODE_MND_INVALID_FUNC_CODE; goto _OVER; } if (createReq.codeLen <= 1) { - terrno = TSDB_CODE_MND_INVALID_FUNC_CODE; + code = TSDB_CODE_MND_INVALID_FUNC_CODE; goto _OVER; } if (createReq.bufSize < 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) { - terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE; + code = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE; goto _OVER; } @@ -414,12 +461,12 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) { _OVER: if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("func:%s, failed to create since %s", createReq.name, terrstr()); + mError("func:%s, failed to create since %s", createReq.name, tstrerror(code)); } mndReleaseFunc(pMnode, pFunc); tFreeSCreateFuncReq(&createReq); - return code; + TAOS_RETURN(code); } static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) { @@ -428,18 +475,13 @@ static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) { SFuncObj *pFunc = NULL; SDropFuncReq dropReq = {0}; - if (tDeserializeSDropFuncReq(pReq->pCont, pReq->contLen, &dropReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - goto _OVER; - } + TAOS_CHECK_GOTO(tDeserializeSDropFuncReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER); mInfo("func:%s, start to drop", dropReq.name); - if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_FUNC) != 0) { - goto _OVER; - } + TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_FUNC), NULL, _OVER); if (dropReq.name[0] == 0) { - terrno = TSDB_CODE_MND_INVALID_FUNC_NAME; + code = TSDB_CODE_MND_INVALID_FUNC_NAME; goto _OVER; } @@ -450,7 +492,7 @@ static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) { code = 0; goto _OVER; } else { - terrno = TSDB_CODE_MND_FUNC_NOT_EXIST; + code = TSDB_CODE_MND_FUNC_NOT_EXIST; goto _OVER; } } @@ -460,11 +502,11 @@ static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) { _OVER: if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("func:%s, failed to drop since %s", dropReq.name, terrstr()); + mError("func:%s, failed to drop since %s", dropReq.name, tstrerror(code)); } mndReleaseFunc(pMnode, pFunc); - return code; + TAOS_RETURN(code); } static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) { @@ -474,25 +516,25 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) { SRetrieveFuncRsp retrieveRsp = {0}; if (tDeserializeSRetrieveFuncReq(pReq->pCont, pReq->contLen, &retrieveReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; + code = TSDB_CODE_INVALID_MSG; goto RETRIEVE_FUNC_OVER; } if (retrieveReq.numOfFuncs <= 0 || retrieveReq.numOfFuncs > TSDB_FUNC_MAX_RETRIEVE) { - terrno = TSDB_CODE_MND_INVALID_FUNC_RETRIEVE; + code = TSDB_CODE_MND_INVALID_FUNC_RETRIEVE; goto RETRIEVE_FUNC_OVER; } retrieveRsp.numOfFuncs = retrieveReq.numOfFuncs; retrieveRsp.pFuncInfos = taosArrayInit(retrieveReq.numOfFuncs, sizeof(SFuncInfo)); if (retrieveRsp.pFuncInfos == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto RETRIEVE_FUNC_OVER; } retrieveRsp.pFuncExtraInfos = taosArrayInit(retrieveReq.numOfFuncs, sizeof(SFuncExtraInfo)); if (retrieveRsp.pFuncExtraInfos == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto RETRIEVE_FUNC_OVER; } @@ -501,6 +543,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) { SFuncObj *pFunc = mndAcquireFunc(pMnode, funcName); if (pFunc == NULL) { + if (terrno != 0) code = terrno; goto RETRIEVE_FUNC_OVER; } @@ -545,7 +588,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) { int32_t contLen = tSerializeSRetrieveFuncRsp(NULL, 0, &retrieveRsp); void *pRsp = rpcMallocCont(contLen); if (pRsp == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto RETRIEVE_FUNC_OVER; } @@ -560,7 +603,7 @@ RETRIEVE_FUNC_OVER: tFreeSRetrieveFuncReq(&retrieveReq); tFreeSRetrieveFuncRsp(&retrieveRsp); - return code; + TAOS_RETURN(code); } static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int32_t len) { diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c index ec4534021a..ecd64ff475 100644 --- a/source/dnode/mnode/impl/src/mndSma.c +++ b/source/dnode/mnode/impl/src/mndSma.c @@ -819,8 +819,8 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) { char streamName[TSDB_TABLE_FNAME_LEN] = {0}; mndGetStreamNameFromSmaName(streamName, createReq.name); - pStream = mndAcquireStream(pMnode, streamName); - if (pStream != NULL) { + code = mndAcquireStream(pMnode, streamName, &pStream); + if (pStream != NULL || code == 0) { mError("sma:%s, failed to create since stream:%s already exist", createReq.name, streamName); code = TSDB_CODE_MND_STREAM_ALREADY_EXIST; goto _OVER; @@ -995,8 +995,10 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p char streamName[TSDB_TABLE_FNAME_LEN] = {0}; mndGetStreamNameFromSmaName(streamName, pSma->name); - SStreamObj *pStream = mndAcquireStream(pMnode, streamName); - if (pStream == NULL || pStream->smaId != pSma->uid) { + SStreamObj *pStream = NULL; + + code = mndAcquireStream(pMnode, streamName, &pStream); + if (pStream == NULL || pStream->smaId != pSma->uid || code != 0) { sdbRelease(pMnode->pSdb, pStream); goto _OVER; } else { @@ -1054,10 +1056,11 @@ int32_t mndDropSmasByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *p char streamName[TSDB_TABLE_FNAME_LEN] = {0}; mndGetStreamNameFromSmaName(streamName, pSma->name); - SStreamObj *pStream = mndAcquireStream(pMnode, streamName); - if (pStream != NULL && pStream->smaId == pSma->uid) { + SStreamObj *pStream = NULL; + code = mndAcquireStream(pMnode, streamName, &pStream); + if ((pStream != NULL && pStream->smaId == pSma->uid) || code != 0) { if ((code = mndStreamSetDropAction(pMnode, pTrans, pStream)) < 0) { - mError("stream:%s, failed to drop task since %s", pStream->name, tstrerror(code)); + mError("stream:%s, failed to drop task since %s", pStream->name, terrstr()); mndReleaseStream(pMnode, pStream); goto _OVER; } @@ -1804,6 +1807,7 @@ static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) { code = 0; goto _OVER; } + if (pSma) { code = TSDB_CODE_MND_SMA_ALREADY_EXIST; goto _OVER; @@ -1817,8 +1821,8 @@ static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) { goto _OVER; } - pStream = mndAcquireStream(pMnode, streamName); - if (pStream != NULL) { + code = mndAcquireStream(pMnode, streamName, &pStream); + if (pStream != NULL || code != TSDB_CODE_MND_STREAM_NOT_EXIST) { mError("tsma:%s, failed to create since stream:%s already exist", createReq.name, streamName); code = TSDB_CODE_MND_SMA_ALREADY_EXIST; goto _OVER; @@ -2296,7 +2300,7 @@ static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilt SSmaObj * pBaseTsma = NULL; SSdb * pSdb = pMnode->pSdb; void * pIter = NULL; - SStreamObj * pStreamObj = NULL; + SStreamObj * pStream = NULL; SStbObj * pStb = NULL; while (1) { @@ -2318,14 +2322,16 @@ static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilt char streamName[TSDB_TABLE_FNAME_LEN] = {0}; tNameFromString(&smaName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); sprintf(streamName, "%d.%s", smaName.acctId, smaName.tname); - pStreamObj = mndAcquireStream(pMnode, streamName); - if (!pStreamObj) { + pStream = NULL; + + code = mndAcquireStream(pMnode, streamName, &pStream); + if (!pStream || (code != 0)) { sdbRelease(pSdb, pSma); continue; } - int64_t streamId = pStreamObj->uid; - mndReleaseStream(pMnode, pStreamObj); + int64_t streamId = pStream->uid; + mndReleaseStream(pMnode, pStream); STableTSMAInfo *pTsma = taosMemoryCalloc(1, sizeof(STableTSMAInfo)); if (!pTsma) { diff --git a/source/dnode/mnode/impl/src/mndStream.c b/source/dnode/mnode/impl/src/mndStream.c index 32a76afa5b..c8a7fb0b51 100644 --- a/source/dnode/mnode/impl/src/mndStream.c +++ b/source/dnode/mnode/impl/src/mndStream.c @@ -134,17 +134,18 @@ int32_t mndInitStream(SMnode *pMnode) { mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_STREAM_TASKS, mndRetrieveStreamTask); mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_STREAM_TASKS, mndCancelGetNextStreamTask); - mndInitExecInfo(); - - if (sdbSetTable(pMnode->pSdb, table) != 0) { - return -1; + int32_t code = mndInitExecInfo(); + if (code) { + return code; } - if (sdbSetTable(pMnode->pSdb, tableSeq) != 0) { - return -1; + code = sdbSetTable(pMnode->pSdb, table); + if (code) { + return terrno; } - return 0; + code = sdbSetTable(pMnode->pSdb, tableSeq); + return code; } void mndCleanupStream(SMnode *pMnode) { @@ -253,13 +254,15 @@ static int32_t mndStreamActionUpdate(SSdb *pSdb, SStreamObj *pOldStream, SStream return 0; } -SStreamObj *mndAcquireStream(SMnode *pMnode, char *streamName) { - SSdb *pSdb = pMnode->pSdb; - SStreamObj *pStream = sdbAcquire(pSdb, SDB_STREAM, streamName); - if (pStream == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) { +int32_t mndAcquireStream(SMnode *pMnode, char *streamName, SStreamObj **pStream) { + terrno = 0; + + SSdb *pSdb = pMnode->pSdb; + (*pStream) = sdbAcquire(pSdb, SDB_STREAM, streamName); + if ((*pStream) == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) { terrno = TSDB_CODE_MND_STREAM_NOT_EXIST; } - return pStream; + return terrno; } void mndReleaseStream(SMnode *pMnode, SStreamObj *pStream) { @@ -532,9 +535,21 @@ int32_t mndPersistTaskDeployReq(STrans *pTrans, SStreamTask *pTask) { } int32_t mndPersistStreamTasks(STrans *pTrans, SStreamObj *pStream) { - SStreamTaskIter *pIter = createStreamTaskIter(pStream); + SStreamTaskIter *pIter = NULL; + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + mError("failed to create task iter for stream:%s", pStream->name); + return code; + } + while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { + destroyStreamTaskIter(pIter); + return code; + } + if (mndPersistTaskDeployReq(pTrans, pTask) < 0) { destroyStreamTaskIter(pIter); return -1; @@ -708,7 +723,7 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) { char *sql = NULL; int32_t sqlLen = 0; const char *pMsg = "create stream tasks on dnodes"; - + int32_t code = 0; terrno = TSDB_CODE_SUCCESS; SCMCreateStreamReq createReq = {0}; @@ -728,8 +743,8 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) { goto _OVER; } - pStream = mndAcquireStream(pMnode, createReq.name); - if (pStream != NULL) { + code = mndAcquireStream(pMnode, createReq.name, &pStream); + if (pStream != NULL || code == 0) { if (createReq.igExists) { mInfo("stream:%s, already exist, ignore exist is set", createReq.name); goto _OVER; @@ -762,8 +777,9 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) { goto _OVER; } - STrans *pTrans = doCreateTrans(pMnode, &streamObj, pReq, TRN_CONFLICT_DB, MND_STREAM_CREATE_NAME, pMsg); - if (pTrans == NULL) { + STrans *pTrans = NULL; + code = doCreateTrans(pMnode, &streamObj, pReq, TRN_CONFLICT_DB, MND_STREAM_CREATE_NAME, pMsg, &pTrans); + if (pTrans == NULL || code) { goto _OVER; } @@ -804,11 +820,10 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) { // add into buffer firstly // to make sure when the hb from vnode arrived, the newly created tasks have been in the task map already. - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); mDebug("stream stream:%s start to register tasks into task nodeList and set initial checkpointId", createReq.name); saveTaskAndNodeInfoIntoBuf(&streamObj, &execInfo); -// mndRegisterConsensusChkptId(execInfo.pStreamConsensus, streamObj.uid); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); // execute creation if (mndTransPrepare(pMnode, pTrans) != 0) { @@ -869,7 +884,7 @@ int64_t mndStreamGenChkptId(SMnode *pMnode, bool lock) { { // check the max checkpoint id from all vnodes. int64_t maxCheckpointId = -1; if (lock) { - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); } for (int32_t i = 0; i < taosArrayGetSize(execInfo.pTaskList); ++i) { @@ -890,7 +905,7 @@ int64_t mndStreamGenChkptId(SMnode *pMnode, bool lock) { } if (lock) { - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); } if (maxCheckpointId > maxChkptId) { @@ -991,11 +1006,13 @@ static int32_t mndProcessStreamCheckpointTrans(SMnode *pMnode, SStreamObj *pStre return -1; } - STrans *pTrans = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_CHECKPOINT_NAME, - "gen checkpoint for stream"); - if (pTrans == NULL) { + STrans *pTrans = NULL; + code = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_CHECKPOINT_NAME, + "gen checkpoint for stream", &pTrans); + if (pTrans == NULL || code) { + code = TSDB_CODE_MND_TRANS_CONFLICT; mError("failed to checkpoint of stream name%s, checkpointId: %" PRId64 ", reason:%s", pStream->name, checkpointId, - tstrerror(TSDB_CODE_MND_TRANS_CONFLICT)); + tstrerror(code)); goto _ERR; } @@ -1035,7 +1052,7 @@ static int32_t mndProcessStreamCheckpointTrans(SMnode *pMnode, SStreamObj *pStre taosWUnLockLatch(&pStream->lock); if ((code = mndPersistTransLog(pStream, pTrans, SDB_STATUS_READY)) != TSDB_CODE_SUCCESS) { - return code; + goto _ERR; } if ((code = mndTransPrepare(pMnode, pTrans)) != TSDB_CODE_SUCCESS) { @@ -1059,13 +1076,13 @@ int32_t extractStreamNodeList(SMnode *pMnode) { static bool taskNodeIsUpdated(SMnode *pMnode) { // check if the node update happens or not - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); int32_t numOfNodes = extractStreamNodeList(pMnode); if (numOfNodes == 0) { mDebug("stream task node change checking done, no vgroups exist, do nothing"); execInfo.ts = taosGetTimestampSec(); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); return false; } @@ -1073,17 +1090,22 @@ static bool taskNodeIsUpdated(SMnode *pMnode) { SNodeEntry *pNodeEntry = taosArrayGet(execInfo.pNodeList, i); if (pNodeEntry->stageUpdated) { mDebug("stream task not ready due to node update detected, checkpoint not issued"); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); return true; } } bool allReady = true; - SArray *pNodeSnapshot = mndTakeVgroupSnapshot(pMnode, &allReady); + SArray *pNodeSnapshot = NULL; + + int32_t code = mndTakeVgroupSnapshot(pMnode, &allReady, &pNodeSnapshot); + if (code) { + mError("failed to get the vgroup snapshot, ignore it and continue"); + } if (!allReady) { mWarn("not all vnodes ready, quit from vnodes status check"); taosArrayDestroy(pNodeSnapshot); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); return true; } @@ -1099,7 +1121,7 @@ static bool taskNodeIsUpdated(SMnode *pMnode) { mDebug("stream tasks not ready due to node update"); } - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); return nodeUpdated; } @@ -1109,7 +1131,7 @@ static int32_t mndCheckTaskAndNodeStatus(SMnode *pMnode) { return -1; } - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); if (taosArrayGetSize(execInfo.pNodeList) == 0) { mDebug("stream task node change checking done, no vgroups exist, do nothing"); ASSERT(taosArrayGetSize(execInfo.pTaskList) == 0); @@ -1154,7 +1176,7 @@ static int32_t mndCheckTaskAndNodeStatus(SMnode *pMnode) { removeTasksInBuf(pInvalidList, &execInfo); taosArrayDestroy(pInvalidList); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); return ready ? 0 : -1; } @@ -1217,14 +1239,14 @@ static int32_t mndProcessStreamCheckpoint(SRpcMsg *pReq) { continue; } - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); int64_t startTs = getStreamTaskLastReadyState(execInfo.pTaskList, pStream->uid); if (startTs != -1 && (now - startTs) < tsStreamCheckpointInterval * 1000) { - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); sdbRelease(pSdb, pStream); continue; } - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); SCheckpointInterval in = {.streamId = pStream->uid, .duration = duration}; taosArrayPush(pList, &in); @@ -1267,8 +1289,9 @@ static int32_t mndProcessStreamCheckpoint(SRpcMsg *pReq) { for (int32_t i = 0; i < numOfQual; ++i) { SCheckpointInterval *pCheckpointInfo = taosArrayGet(pList, i); - SStreamObj *p = mndGetStreamObj(pMnode, pCheckpointInfo->streamId); - if (p != NULL) { + SStreamObj *p = NULL; + code = mndGetStreamObj(pMnode, pCheckpointInfo->streamId, &p); + if (p != NULL && code == 0) { code = mndProcessStreamCheckpointTrans(pMnode, p, checkpointId, 1, true); sdbRelease(pSdb, p); @@ -1291,6 +1314,7 @@ static int32_t mndProcessStreamCheckpoint(SRpcMsg *pReq) { static int32_t mndProcessDropStreamReq(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; SStreamObj *pStream = NULL; + int32_t code = 0; SMDropStreamReq dropReq = {0}; if (tDeserializeSMDropStreamReq(pReq->pCont, pReq->contLen, &dropReq) < 0) { @@ -1301,8 +1325,8 @@ static int32_t mndProcessDropStreamReq(SRpcMsg *pReq) { mDebug("recv drop stream:%s msg", dropReq.name); - pStream = mndAcquireStream(pMnode, dropReq.name); - if (pStream == NULL) { + code = mndAcquireStream(pMnode, dropReq.name, &pStream); + if (pStream == NULL || code != 0) { if (dropReq.igNotExists) { mInfo("stream:%s not exist, ignore not exist is set, drop stream exec done with success", dropReq.name); sdbRelease(pMnode->pSdb, pStream); @@ -1358,15 +1382,16 @@ static int32_t mndProcessDropStreamReq(SRpcMsg *pReq) { return -1; } - STrans *pTrans = doCreateTrans(pMnode, pStream, pReq, TRN_CONFLICT_NOTHING, MND_STREAM_DROP_NAME, "drop stream"); - if (pTrans == NULL) { + STrans *pTrans = NULL; + code = doCreateTrans(pMnode, pStream, pReq, TRN_CONFLICT_NOTHING, MND_STREAM_DROP_NAME, "drop stream", &pTrans); + if (pTrans == NULL || code) { mError("stream:%s uid:0x%" PRIx64 " failed to drop since %s", dropReq.name, pStream->uid, terrstr()); sdbRelease(pMnode->pSdb, pStream); tFreeMDropStreamReq(&dropReq); return -1; } - int32_t code = mndStreamRegisterTrans(pTrans, MND_STREAM_DROP_NAME, pStream->uid); + code = mndStreamRegisterTrans(pTrans, MND_STREAM_DROP_NAME, pStream->uid); // drop all tasks if (mndStreamSetDropAction(pMnode, pTrans, pStream) < 0) { @@ -1859,9 +1884,9 @@ static int32_t mndRetrieveStreamTask(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock int32_t numOfRows = 0; SStreamObj *pStream = NULL; - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); mndInitStreamExecInfo(pMnode, &execInfo); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); while (numOfRows < rowsCapacity) { pShow->pIter = sdbFetch(pSdb, SDB_STREAM, pShow->pIter, (void **)&pStream); @@ -1878,11 +1903,24 @@ static int32_t mndRetrieveStreamTask(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock } // add row for each task - SStreamTaskIter *pIter = createStreamTaskIter(pStream); - while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); + SStreamTaskIter *pIter = NULL; + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + taosRUnLockLatch(&pStream->lock); + sdbRelease(pSdb, pStream); + mError("failed to create task iter for stream:%s", pStream->name); + continue; + } - int32_t code = setTaskAttrInResBlock(pStream, pTask, pBlock, numOfRows); + while (streamTaskIterNextTask(pIter)) { + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { + destroyStreamTaskIter(pIter); + break; + } + + code = setTaskAttrInResBlock(pStream, pTask, pBlock, numOfRows); if (code == TSDB_CODE_SUCCESS) { numOfRows++; } @@ -1908,6 +1946,7 @@ static void mndCancelGetNextStreamTask(SMnode *pMnode, void *pIter) { static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; SStreamObj *pStream = NULL; + int32_t code = 0; SMPauseStreamReq pauseReq = {0}; if (tDeserializeSMPauseStreamReq(pReq->pCont, pReq->contLen, &pauseReq) < 0) { @@ -1915,9 +1954,8 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { return -1; } - pStream = mndAcquireStream(pMnode, pauseReq.name); - - if (pStream == NULL) { + code = mndAcquireStream(pMnode, pauseReq.name, &pStream); + if (pStream == NULL || code != 0) { if (pauseReq.igNotExists) { mInfo("stream:%s, not exist, not pause stream", pauseReq.name); return 0; @@ -1957,7 +1995,7 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { { // check for tasks, if tasks are not ready, not allowed to pause bool found = false; bool readyToPause = true; - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); for (int32_t i = 0; i < taosArrayGetSize(execInfo.pTaskList); ++i) { STaskId *p = taosArrayGet(execInfo.pTaskList, i); @@ -1980,7 +2018,7 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { found = true; } - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); if (!found) { mError("stream:%s task not report status yet, not ready for pause", pauseReq.name); sdbRelease(pMnode->pSdb, pStream); @@ -1994,42 +2032,49 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { } } - STrans *pTrans = - doCreateTrans(pMnode, pStream, pReq, TRN_CONFLICT_NOTHING, MND_STREAM_PAUSE_NAME, "pause the stream"); - if (pTrans == NULL) { + STrans *pTrans = NULL; + code = doCreateTrans(pMnode, pStream, pReq, TRN_CONFLICT_NOTHING, MND_STREAM_PAUSE_NAME, "pause the stream", &pTrans); + if (pTrans == NULL || code) { mError("stream:%s failed to pause stream since %s", pauseReq.name, terrstr()); sdbRelease(pMnode->pSdb, pStream); - return -1; + return code; } - int32_t code = mndStreamRegisterTrans(pTrans, MND_STREAM_PAUSE_NAME, pStream->uid); + code = mndStreamRegisterTrans(pTrans, MND_STREAM_PAUSE_NAME, pStream->uid); + if (code) { + sdbRelease(pMnode->pSdb, pStream); + mndTransDrop(pTrans); + return code; + } // if nodeUpdate happened, not send pause trans - if (mndStreamSetPauseAction(pMnode, pTrans, pStream) < 0) { + code = mndStreamSetPauseAction(pMnode, pTrans, pStream); + if (code) { mError("stream:%s, failed to pause task since %s", pauseReq.name, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } // pause stream taosWLockLatch(&pStream->lock); pStream->status = STREAM_STATUS__PAUSE; - if (mndPersistTransLog(pStream, pTrans, SDB_STATUS_READY) < 0) { + code = mndPersistTransLog(pStream, pTrans, SDB_STATUS_READY); + if (code) { taosWUnLockLatch(&pStream->lock); - sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } taosWUnLockLatch(&pStream->lock); - if (mndTransPrepare(pMnode, pTrans) != 0) { + code = mndTransPrepare(pMnode, pTrans); + if (code) { mError("trans:%d, failed to prepare pause stream trans since %s", pTrans->id, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } sdbRelease(pMnode->pSdb, pStream); @@ -2041,6 +2086,7 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; SStreamObj *pStream = NULL; + int32_t code = 0; if ((terrno = grantCheckExpire(TSDB_GRANT_STREAMS)) < 0) { return -1; @@ -2052,9 +2098,8 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) { return -1; } - pStream = mndAcquireStream(pMnode, resumeReq.name); - - if (pStream == NULL) { + code = mndAcquireStream(pMnode, resumeReq.name, &pStream); + if (pStream == NULL || code != 0) { if (resumeReq.igNotExists) { mInfo("stream:%s not exist, not resume stream", resumeReq.name); sdbRelease(pMnode->pSdb, pStream); @@ -2083,22 +2128,28 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) { return -1; } - STrans *pTrans = - doCreateTrans(pMnode, pStream, pReq, TRN_CONFLICT_NOTHING, MND_STREAM_RESUME_NAME, "resume the stream"); - if (pTrans == NULL) { + STrans *pTrans = NULL; + code = + doCreateTrans(pMnode, pStream, pReq, TRN_CONFLICT_NOTHING, MND_STREAM_RESUME_NAME, "resume the stream", &pTrans); + if (pTrans == NULL || code) { mError("stream:%s, failed to resume stream since %s", resumeReq.name, terrstr()); sdbRelease(pMnode->pSdb, pStream); - return -1; + return code; } - int32_t code = mndStreamRegisterTrans(pTrans, MND_STREAM_RESUME_NAME, pStream->uid); + code = mndStreamRegisterTrans(pTrans, MND_STREAM_RESUME_NAME, pStream->uid); + if (code) { + sdbRelease(pMnode->pSdb, pStream); + mndTransDrop(pTrans); + return code; + } // set the resume action if (mndStreamSetResumeAction(pTrans, pMnode, pStream, resumeReq.igUntreated) < 0) { mError("stream:%s, failed to drop task since %s", resumeReq.name, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } // resume stream @@ -2109,7 +2160,7 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) { sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } taosWUnLockLatch(&pStream->lock); @@ -2117,7 +2168,7 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) { mError("trans:%d, failed to prepare pause stream trans since %s", pTrans->id, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } sdbRelease(pMnode->pSdb, pStream); @@ -2191,6 +2242,7 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange SStreamObj *pStream = NULL; void *pIter = NULL; STrans *pTrans = NULL; + int32_t code = 0; // conflict check for nodeUpdate trans, here we randomly chose one stream to add into the trans pool while (1) { @@ -2217,12 +2269,11 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange // here create only one trans if (pTrans == NULL) { - pTrans = - doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_TASK_UPDATE_NAME, "update task epsets"); - if (pTrans == NULL) { + code = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_TASK_UPDATE_NAME, "update task epsets", &pTrans); + if (pTrans == NULL || code) { sdbRelease(pSdb, pStream); sdbCancelFetch(pSdb, pIter); - return terrno; + return terrno = code; } mndStreamRegisterTrans(pTrans, MND_STREAM_TASK_UPDATE_NAME, pStream->uid); @@ -2239,7 +2290,7 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange mDebug("stream:0x%" PRIx64 " %s involved node changed, create update trans, transId:%d", pStream->uid, pStream->name, pTrans->id); - int32_t code = mndStreamSetUpdateEpsetAction(pMnode, pStream, pChangeInfo, pTrans); + code = mndStreamSetUpdateEpsetAction(pMnode, pStream, pChangeInfo, pTrans); // todo: not continue, drop all and retry again if (code != TSDB_CODE_SUCCESS) { @@ -2254,7 +2305,7 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange if (code != TSDB_CODE_SUCCESS) { sdbCancelFetch(pSdb, pIter); - return -1; + return code; } } @@ -2263,16 +2314,17 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange return 0; } - if (mndTransPrepare(pMnode, pTrans) != 0) { + code = mndTransPrepare(pMnode, pTrans); + if (code) { mError("trans:%d, failed to prepare update stream trans since %s", pTrans->id, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return 0; + return code; } static int32_t extractNodeListFromStream(SMnode *pMnode, SArray *pNodeList) { @@ -2289,9 +2341,21 @@ static int32_t extractNodeListFromStream(SMnode *pMnode, SArray *pNodeList) { taosWLockLatch(&pStream->lock); - SStreamTaskIter *pTaskIter = createStreamTaskIter(pStream); + SStreamTaskIter *pTaskIter = NULL; + int32_t code = createStreamTaskIter(pStream, &pTaskIter); + if (code) { + taosWUnLockLatch(&pStream->lock); + sdbRelease(pSdb, pStream); + mError("failed to create task iter for stream:%s", pStream->name); + continue; + } + while (streamTaskIterNextTask(pTaskIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pTaskIter); + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pTaskIter, &pTask); + if (code) { + break; + } SNodeEntry entry = {.hbTimestamp = -1, .nodeId = pTask->info.nodeId}; epsetAssign(&entry.epset, &pTask->info.epSet); @@ -2338,9 +2402,9 @@ static int32_t mndProcessNodeCheckReq(SRpcMsg *pMsg) { SMnode *pMnode = pMsg->info.node; - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); int32_t numOfNodes = extractStreamNodeList(pMnode); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); if (numOfNodes == 0) { mDebug("end to do stream task(s) node change checking, no stream tasks exist, do nothing"); @@ -2350,7 +2414,13 @@ static int32_t mndProcessNodeCheckReq(SRpcMsg *pMsg) { } bool allReady = true; - SArray *pNodeSnapshot = mndTakeVgroupSnapshot(pMnode, &allReady); + SArray *pNodeSnapshot = NULL; + + code = mndTakeVgroupSnapshot(pMnode, &allReady, &pNodeSnapshot); + if (code) { + mError("failed to take the vgroup snapshot, ignore it and continue"); + } + if (!allReady) { taosArrayDestroy(pNodeSnapshot); atomic_store_32(&mndNodeCheckSentinel, 0); @@ -2358,7 +2428,7 @@ static int32_t mndProcessNodeCheckReq(SRpcMsg *pMsg) { return 0; } - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); removeExpiredNodeEntryAndTaskInBuf(pNodeSnapshot); @@ -2382,7 +2452,7 @@ static int32_t mndProcessNodeCheckReq(SRpcMsg *pMsg) { } taosArrayDestroy(pNodeSnapshot); - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); taosArrayDestroy(changeInfo.pUpdateNodeList); taosHashCleanup(changeInfo.pDBMap); @@ -2408,9 +2478,19 @@ static int32_t mndProcessNodeCheck(SRpcMsg *pReq) { } void saveTaskAndNodeInfoIntoBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode) { - SStreamTaskIter *pIter = createStreamTaskIter(pStream); + SStreamTaskIter *pIter = NULL; + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + mError("failed to create task iter for stream:%s", pStream->name); + return; + } + while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { + break; + } STaskId id = {.streamId = pTask->id.streamId, .taskId = pTask->id.taskId}; void *p = taosHashGet(pExecNode->pTaskMap, &id, sizeof(id)); @@ -2480,10 +2560,11 @@ int32_t mndProcessStreamReqCheckpoint(SRpcMsg *pReq) { mDebug("receive stream task checkpoint req msg, vgId:%d, s-task:0x%x", req.nodeId, req.taskId); // register to the stream task done map, if all tasks has sent this kinds of message, start the checkpoint trans. - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); - SStreamObj *pStream = mndGetStreamObj(pMnode, req.streamId); - if (pStream == NULL) { + SStreamObj *pStream = NULL; + int32_t code = mndGetStreamObj(pMnode, req.streamId, &pStream); + if (pStream == NULL || code != 0) { mWarn("failed to find the stream:0x%" PRIx64 ", not handle the checkpoint req, try to acquire in buf", req.streamId); @@ -2494,7 +2575,7 @@ int32_t mndProcessStreamReqCheckpoint(SRpcMsg *pReq) { if (p == NULL) { mError("failed to find the stream:0x%" PRIx64 " in buf, not handle the checkpoint req", req.streamId); terrno = TSDB_CODE_MND_STREAM_NOT_EXIST; - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); return -1; } else { mDebug("s-task:0x%" PRIx64 "-0x%x in buf not in mnode/meta, create stream trans may not complete yet", @@ -2539,7 +2620,7 @@ int32_t mndProcessStreamReqCheckpoint(SRpcMsg *pReq) { mndReleaseStream(pMnode, pStream); } - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); { SRpcMsg rsp = {.code = 0, .info = pReq->info, .contLen = sizeof(SMStreamReqCheckpointRsp)}; @@ -2599,10 +2680,11 @@ int32_t mndProcessCheckpointReport(SRpcMsg *pReq) { req.nodeId, req.taskId, req.checkpointId, req.checkpointVer, req.transId); // register to the stream task done map, if all tasks has sent this kinds of message, start the checkpoint trans. - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); - SStreamObj *pStream = mndGetStreamObj(pMnode, req.streamId); - if (pStream == NULL) { + SStreamObj *pStream = NULL; + int32_t code = mndGetStreamObj(pMnode, req.streamId, &pStream); + if (pStream == NULL || code != 0) { mWarn("failed to find the stream:0x%" PRIx64 ", not handle checkpoint-report, try to acquire in buf", req.streamId); // not in meta-store yet, try to acquire the task in exec buffer @@ -2612,7 +2694,7 @@ int32_t mndProcessCheckpointReport(SRpcMsg *pReq) { if (p == NULL) { mError("failed to find the stream:0x%" PRIx64 " in buf, not handle the checkpoint-report", req.streamId); terrno = TSDB_CODE_MND_STREAM_NOT_EXIST; - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); return -1; } else { mDebug("s-task:0x%" PRIx64 "-0x%x in buf not in mnode/meta, create stream trans may not complete yet", @@ -2644,7 +2726,7 @@ int32_t mndProcessCheckpointReport(SRpcMsg *pReq) { mndReleaseStream(pMnode, pStream); } - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); doSendQuickRsp(&pReq->info, sizeof(SMStreamUpdateChkptRsp), req.nodeId, TSDB_CODE_SUCCESS); return 0; @@ -2709,7 +2791,7 @@ static void doSendQuickRsp(SRpcHandleInfo *pInfo, int32_t msgSize, int32_t vgId, // req.nodeId, req.streamId, req.taskId, req.checkpointId); // // // register to the stream task done map, if all tasks has sent this kinds of message, start the checkpoint trans. -// taosThreadMutexLock(&execInfo.lock); +// streamMutexLock(&execInfo.lock); // // // mnode handle the create stream transaction too slow may cause this problem // SStreamObj *pStream = mndGetStreamObj(pMnode, req.streamId); @@ -2723,7 +2805,7 @@ static void doSendQuickRsp(SRpcHandleInfo *pInfo, int32_t msgSize, int32_t vgId, // if (p == NULL) { // mError("failed to find the stream:0x%" PRIx64 " in buf, not handle consensus-checkpointId", req.streamId); // terrno = TSDB_CODE_MND_STREAM_NOT_EXIST; -// taosThreadMutexUnlock(&execInfo.lock); +// streamMutexUnlock(&execInfo.lock); // // doSendQuickRsp(&pMsg->info, sizeof(SMStreamReqConsensChkptRsp), req.nodeId, terrno); // return -1; @@ -2739,7 +2821,7 @@ static void doSendQuickRsp(SRpcHandleInfo *pInfo, int32_t msgSize, int32_t vgId, // // int32_t numOfTasks = (pStream == NULL) ? 0 : mndGetNumOfStreamTasks(pStream); // if ((pStream != NULL) && (pStream->checkpointId == 0)) { // not generated checkpoint yet, return 0 directly -// taosThreadMutexUnlock(&execInfo.lock); +// streamMutexUnlock(&execInfo.lock); // mndCreateSetConsensusChkptIdTrans(pMnode, pStream, req.taskId, 0, req.startTs); // // doSendQuickRsp(&pMsg->info, sizeof(SMStreamReqConsensChkptRsp), req.nodeId, terrno); @@ -2756,7 +2838,7 @@ static void doSendQuickRsp(SRpcHandleInfo *pInfo, int32_t msgSize, int32_t vgId, // SCheckpointConsensusInfo *pInfo = mndGetConsensusInfo(execInfo.pStreamConsensus, req.streamId, numOfTasks); // mndAddConsensusTasks(pInfo, &req); // -// taosThreadMutexUnlock(&execInfo.lock); +// streamMutexUnlock(&execInfo.lock); // doSendQuickRsp(&pMsg->info, sizeof(SMStreamReqConsensChkptRsp), req.nodeId, terrno); // return 0; // } @@ -2766,7 +2848,7 @@ static void doSendQuickRsp(SRpcHandleInfo *pInfo, int32_t msgSize, int32_t vgId, // req.nodeId, req.streamId, pStream->name, chkId, pStream->checkpointId); // mndCreateSetConsensusChkptIdTrans(pMnode, pStream, req.taskId, chkId, req.startTs); // -// taosThreadMutexUnlock(&execInfo.lock); +// streamMutexUnlock(&execInfo.lock); // doSendQuickRsp(&pMsg->info, sizeof(SMStreamReqConsensChkptRsp), req.nodeId, terrno); // return 0; // } @@ -2779,7 +2861,7 @@ static void doSendQuickRsp(SRpcHandleInfo *pInfo, int32_t msgSize, int32_t vgId, // mndReleaseStream(pMnode, pStream); // } // -// taosThreadMutexUnlock(&execInfo.lock); +// streamMutexUnlock(&execInfo.lock); // doSendQuickRsp(&pMsg->info, sizeof(SMStreamReqConsensChkptRsp), req.nodeId, terrno); // return 0; //} @@ -2792,15 +2874,21 @@ int32_t mndProcessConsensusInTmr(SRpcMsg *pMsg) { mDebug("start to process consensus-checkpointId in tmr"); bool allReady = true; - SArray *pNodeSnapshot = mndTakeVgroupSnapshot(pMnode, &allReady); + SArray *pNodeSnapshot = NULL; + + int32_t code = mndTakeVgroupSnapshot(pMnode, &allReady, &pNodeSnapshot); taosArrayDestroy(pNodeSnapshot); + if (code) { + mError("failed to get the vgroup snapshot, ignore it and continue"); + } + if (!allReady) { mWarn("not all vnodes are ready, end to process the consensus-checkpointId in tmr process"); taosArrayDestroy(pStreamList); return 0; } - taosThreadMutexLock(&execInfo.lock); + streamMutexLock(&execInfo.lock); void *pIter = NULL; while ((pIter = taosHashIterate(execInfo.pStreamConsensus, pIter)) != NULL) { @@ -2810,8 +2898,9 @@ int32_t mndProcessConsensusInTmr(SRpcMsg *pMsg) { int32_t num = taosArrayGetSize(pInfo->pTaskList); SArray *pList = taosArrayInit(4, sizeof(int32_t)); - SStreamObj *pStream = mndGetStreamObj(pMnode, pInfo->streamId); - if (pStream == NULL) { // stream has been dropped already + SStreamObj *pStream = NULL; + code = mndGetStreamObj(pMnode, pInfo->streamId, &pStream); + if (pStream == NULL || code != 0) { // stream has been dropped already mDebug("stream:0x%" PRIx64 " dropped already, continue", pInfo->streamId); taosArrayDestroy(pList); continue; @@ -2870,14 +2959,14 @@ int32_t mndProcessConsensusInTmr(SRpcMsg *pMsg) { for (int32_t i = 0; i < taosArrayGetSize(pStreamList); ++i) { int64_t *pStreamId = (int64_t *)taosArrayGet(pStreamList, i); - mndClearConsensusCheckpointId(execInfo.pStreamConsensus, *pStreamId); + code = mndClearConsensusCheckpointId(execInfo.pStreamConsensus, *pStreamId); } - taosThreadMutexUnlock(&execInfo.lock); + streamMutexUnlock(&execInfo.lock); taosArrayDestroy(pStreamList); mDebug("end to process consensus-checkpointId in tmr"); - return TSDB_CODE_SUCCESS; + return code; } static int32_t mndProcessCreateStreamReqFromMNode(SRpcMsg *pReq) { @@ -2928,32 +3017,41 @@ void addAllStreamTasksIntoBuf(SMnode *pMnode, SStreamExecInfo *pExecInfo) { } int32_t mndCreateStreamChkptInfoUpdateTrans(SMnode *pMnode, SStreamObj *pStream, SArray *pChkptInfoList) { - STrans *pTrans = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_CHKPT_UPDATE_NAME, - "update checkpoint-info"); - if (pTrans == NULL) { - return terrno; + STrans *pTrans = NULL; + int32_t code = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_CHKPT_UPDATE_NAME, + "update checkpoint-info", &pTrans); + if (pTrans == NULL || code) { + sdbRelease(pMnode->pSdb, pStream); + return code; } - /*int32_t code = */ mndStreamRegisterTrans(pTrans, MND_STREAM_CHKPT_UPDATE_NAME, pStream->uid); - int32_t code = mndStreamSetUpdateChkptAction(pMnode, pTrans, pStream); - if (code != 0) { + code = mndStreamRegisterTrans(pTrans, MND_STREAM_CHKPT_UPDATE_NAME, pStream->uid); + if (code){ + sdbRelease(pMnode->pSdb, pStream); + mndTransDrop(pTrans); + return code; + } + + code = mndStreamSetUpdateChkptAction(pMnode, pTrans, pStream); + if (code) { sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); return code; } code = mndPersistTransLog(pStream, pTrans, SDB_STATUS_READY); - if (code != TSDB_CODE_SUCCESS) { + if (code) { sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } - if (mndTransPrepare(pMnode, pTrans) != 0) { + code = mndTransPrepare(pMnode, pTrans); + if (code) { mError("trans:%d, failed to prepare update checkpoint-info meta trans since %s", pTrans->id, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } sdbRelease(pMnode->pSdb, pStream); diff --git a/source/dnode/mnode/impl/src/mndStreamHb.c b/source/dnode/mnode/impl/src/mndStreamHb.c index bc10ec211d..c5297b5ba8 100644 --- a/source/dnode/mnode/impl/src/mndStreamHb.c +++ b/source/dnode/mnode/impl/src/mndStreamHb.c @@ -61,15 +61,23 @@ void addIntoCheckpointList(SArray *pList, const SFailedCheckpointInfo *pInfo) { } int32_t mndCreateStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream) { - STrans *pTrans = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_TASK_RESET_NAME, - " reset from failed checkpoint"); - if (pTrans == NULL) { + STrans *pTrans = NULL; + int32_t code = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_TASK_RESET_NAME, + " reset from failed checkpoint", &pTrans); + if (pTrans == NULL || code) { + sdbRelease(pMnode->pSdb, pStream); return terrno; } - /*int32_t code = */ mndStreamRegisterTrans(pTrans, MND_STREAM_TASK_RESET_NAME, pStream->uid); - int32_t code = mndStreamSetResetTaskAction(pMnode, pTrans, pStream); - if (code != 0) { + code = mndStreamRegisterTrans(pTrans, MND_STREAM_TASK_RESET_NAME, pStream->uid); + if (code) { + sdbRelease(pMnode->pSdb, pStream); + mndTransDrop(pTrans); + return code; + } + + code = mndStreamSetResetTaskAction(pMnode, pTrans, pStream); + if (code) { sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); return code; @@ -79,14 +87,15 @@ int32_t mndCreateStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream) { if (code != TSDB_CODE_SUCCESS) { sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } - if (mndTransPrepare(pMnode, pTrans) != 0) { + code = mndTransPrepare(pMnode, pTrans); + if (code != 0) { mError("trans:%d, failed to prepare update stream trans since %s", pTrans->id, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } sdbRelease(pMnode->pSdb, pStream); @@ -99,8 +108,9 @@ int32_t mndResetStatusFromCheckpoint(SMnode *pMnode, int64_t streamId, int32_t t int32_t code = TSDB_CODE_SUCCESS; mndKillTransImpl(pMnode, transId, ""); - SStreamObj *pStream = mndGetStreamObj(pMnode, streamId); - if (pStream == NULL) { + SStreamObj *pStream = NULL; + code = mndGetStreamObj(pMnode, streamId, &pStream); + if (pStream == NULL || code != 0) { code = TSDB_CODE_STREAM_TASK_NOT_EXIST; mError("failed to acquire the streamObj:0x%" PRIx64 " to reset checkpoint, may have been dropped", pStream->uid); } else { @@ -159,34 +169,39 @@ int32_t mndDropOrphanTasks(SMnode *pMnode, SArray *pList) { } SStreamObj dummyObj = {.uid = pTask->streamId, .sourceDb = "", .targetSTbName = ""}; - STrans *pTrans = doCreateTrans(pMnode, &dummyObj, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_DROP_NAME, "drop stream"); - if (pTrans == NULL) { + STrans *pTrans = NULL; + int32_t code = + doCreateTrans(pMnode, &dummyObj, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_DROP_NAME, "drop stream", &pTrans); + if (pTrans == NULL || code != 0) { mError("failed to create trans to drop orphan tasks since %s", terrstr()); - return -1; + return code; } - int32_t code = mndStreamRegisterTrans(pTrans, MND_STREAM_DROP_NAME, pTask->streamId); - + code = mndStreamRegisterTrans(pTrans, MND_STREAM_DROP_NAME, pTask->streamId); + if (code) { + return code; + } // drop all tasks - if (mndStreamSetDropActionFromList(pMnode, pTrans, pList) < 0) { + if ((code = mndStreamSetDropActionFromList(pMnode, pTrans, pList)) < 0) { mError("failed to create trans to drop orphan tasks since %s", terrstr()); mndTransDrop(pTrans); - return -1; + return code; } // drop stream - if (mndPersistTransLog(&dummyObj, pTrans, SDB_STATUS_DROPPED) < 0) { + if ((code = mndPersistTransLog(&dummyObj, pTrans, SDB_STATUS_DROPPED)) < 0) { mndTransDrop(pTrans); - return -1; + return code; } - if (mndTransPrepare(pMnode, pTrans) != 0) { + if ((code = mndTransPrepare(pMnode, pTrans)) != 0) { mError("trans:%d, failed to prepare drop stream trans since %s", pTrans->id, terrstr()); mndTransDrop(pTrans); - return -1; + return code; } + mndTransDrop(pTrans); - return 0; + return code; } int32_t suspendAllStreams(SMnode *pMnode, SRpcHandleInfo *info) { @@ -228,10 +243,11 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) { SStreamHbMsg req = {0}; SArray *pFailedChkpt = NULL; SArray *pOrphanTasks = NULL; + int32_t code = 0; - if ((terrno = grantCheckExpire(TSDB_GRANT_STREAMS)) < 0) { + if ((code = grantCheckExpire(TSDB_GRANT_STREAMS)) < 0) { if (suspendAllStreams(pMnode, &pReq->info) < 0) { - return -1; + return code; } } @@ -241,8 +257,8 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) { if (tDecodeStreamHbMsg(&decoder, &req) < 0) { tCleanupStreamHbMsg(&req); tDecoderClear(&decoder); - terrno = TSDB_CODE_INVALID_MSG; - return -1; + code = terrno = TSDB_CODE_INVALID_MSG; + return code; } tDecoderClear(&decoder); @@ -257,12 +273,12 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) { if (!validateHbMsg(execInfo.pNodeList, req.vgId)) { mError("vgId:%d not exists in nodeList buf, discarded", req.vgId); - terrno = TSDB_CODE_INVALID_MSG; + code = terrno = TSDB_CODE_INVALID_MSG; doSendHbMsgRsp(terrno, &pReq->info, req.vgId, req.msgId); taosThreadMutexUnlock(&execInfo.lock); cleanupAfterProcessHbMsg(&req, pFailedChkpt, pOrphanTasks); - return -1; + return code; } int32_t numOfUpdated = taosArrayGetSize(req.pUpdateNodes); @@ -293,11 +309,23 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) { .startTs = pChkInfo->consensusTs, }; - SStreamObj *pStream = mndGetStreamObj(pMnode, p->id.streamId); - int32_t numOfTasks = mndGetNumOfStreamTasks(pStream); + SStreamObj *pStream = NULL; + code = mndGetStreamObj(pMnode, p->id.streamId, &pStream); + if (code) { + code = TSDB_CODE_STREAM_TASK_NOT_EXIST; + continue; + } + + int32_t numOfTasks = mndGetNumOfStreamTasks(pStream); + SCheckpointConsensusInfo *pInfo = NULL; + + code = mndGetConsensusInfo(execInfo.pStreamConsensus, p->id.streamId, numOfTasks, &pInfo); + if (code == 0) { + mndAddConsensusTasks(pInfo, &cp); + } else { + mError("failed to get consensus checkpoint-info"); + } - SCheckpointConsensusInfo *pInfo = mndGetConsensusInfo(execInfo.pStreamConsensus, p->id.streamId, numOfTasks); - mndAddConsensusTasks(pInfo, &cp); mndReleaseStream(pMnode, pStream); } @@ -338,9 +366,15 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) { // kill the checkpoint trans and then set all tasks status to be normal if (taosArrayGetSize(pFailedChkpt) > 0) { bool allReady = true; + if (pMnode != NULL) { - SArray *p = mndTakeVgroupSnapshot(pMnode, &allReady); + SArray *p = NULL; + + code = mndTakeVgroupSnapshot(pMnode, &allReady, &p); taosArrayDestroy(p); + if (code) { + mError("failed to get the vgroup snapshot, ignore it and continue"); + } } else { allReady = false; } @@ -374,7 +408,7 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) { doSendHbMsgRsp(terrno, &pReq->info, req.vgId, req.msgId); cleanupAfterProcessHbMsg(&req, pFailedChkpt, pOrphanTasks); - return TSDB_CODE_SUCCESS; + return terrno; } void mndStreamStartUpdateCheckpointInfo(SMnode *pMnode) { // here reuse the doCheckpointmsg diff --git a/source/dnode/mnode/impl/src/mndStreamTrans.c b/source/dnode/mnode/impl/src/mndStreamTrans.c index b39487b79f..fd5de2ec86 100644 --- a/source/dnode/mnode/impl/src/mndStreamTrans.c +++ b/source/dnode/mnode/impl/src/mndStreamTrans.c @@ -153,27 +153,30 @@ int32_t mndStreamGetRelTrans(SMnode *pMnode, int64_t streamId) { return 0; } -STrans *doCreateTrans(SMnode *pMnode, SStreamObj *pStream, SRpcMsg *pReq, ETrnConflct conflict, const char *name, - const char *pMsg) { - STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, conflict, pReq, name); - if (pTrans == NULL) { +int32_t doCreateTrans(SMnode *pMnode, SStreamObj *pStream, SRpcMsg *pReq, ETrnConflct conflict, const char *name, + const char *pMsg, STrans ** pTrans1) { + *pTrans1 = NULL; + terrno = 0; + + STrans *p = mndTransCreate(pMnode, TRN_POLICY_RETRY, conflict, pReq, name); + if (p == NULL) { mError("failed to build trans:%s, reason: %s", name, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return terrno; } - mInfo("stream:0x%" PRIx64 " start to build trans %s, transId:%d", pStream->uid, pMsg, pTrans->id); + mInfo("stream:0x%" PRIx64 " start to build trans %s, transId:%d", pStream->uid, pMsg, p->id); - mndTransSetDbName(pTrans, pStream->sourceDb, pStream->targetSTbName); - if (mndTransCheckConflict(pMnode, pTrans) != 0) { + mndTransSetDbName(p, pStream->sourceDb, pStream->targetSTbName); + if (mndTransCheckConflict(pMnode, p) != 0) { terrno = TSDB_CODE_MND_TRANS_CONFLICT; mError("failed to build trans:%s for stream:0x%" PRIx64 " code:%s", name, pStream->uid, tstrerror(terrno)); - mndTransDrop(pTrans); - return NULL; + mndTransDrop(p); + return terrno; } - terrno = 0; - return pTrans; + *pTrans1 = p; + return 0; } SSdbRaw *mndStreamActionEncode(SStreamObj *pStream) { @@ -274,8 +277,9 @@ int32_t doKillCheckpointTrans(SMnode *pMnode, const char *pDBName, size_t len) { continue; } - SStreamObj *pStream = mndGetStreamObj(pMnode, pTransInfo->streamId); - if (pStream != NULL) { + SStreamObj *pStream = NULL; + int32_t code = mndGetStreamObj(pMnode, pTransInfo->streamId, &pStream); + if (pStream != NULL && code == 0) { if (identicalName(pStream->sourceDb, pDBName, len)) { mndKillTransImpl(pMnode, pTransInfo->transId, pStream->sourceDb); } else if (identicalName(pStream->targetDb, pDBName, len)) { diff --git a/source/dnode/mnode/impl/src/mndStreamUtil.c b/source/dnode/mnode/impl/src/mndStreamUtil.c index 843c024286..0b96626536 100644 --- a/source/dnode/mnode/impl/src/mndStreamUtil.c +++ b/source/dnode/mnode/impl/src/mndStreamUtil.c @@ -28,20 +28,20 @@ struct SStreamTaskIter { int32_t doRemoveTasks(SStreamExecInfo *pExecNode, STaskId *pRemovedId); -SStreamTaskIter* createStreamTaskIter(SStreamObj* pStream) { - SStreamTaskIter* pIter = taosMemoryCalloc(1, sizeof(SStreamTaskIter)); - if (pIter == NULL) { +int32_t createStreamTaskIter(SStreamObj* pStream, SStreamTaskIter** pIter) { + *pIter = taosMemoryCalloc(1, sizeof(SStreamTaskIter)); + if (*pIter == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return terrno; } - pIter->level = -1; - pIter->ordinalIndex = 0; - pIter->pStream = pStream; - pIter->totalLevel = taosArrayGetSize(pStream->tasks); - pIter->pTask = NULL; + (*pIter)->level = -1; + (*pIter)->ordinalIndex = 0; + (*pIter)->pStream = pStream; + (*pIter)->totalLevel = taosArrayGetSize(pStream->tasks); + (*pIter)->pTask = NULL; - return pIter; + return 0; } bool streamTaskIterNextTask(SStreamTaskIter* pIter) { @@ -72,19 +72,27 @@ bool streamTaskIterNextTask(SStreamTaskIter* pIter) { return false; } -SStreamTask* streamTaskIterGetCurrent(SStreamTaskIter* pIter) { - return pIter->pTask; +int32_t streamTaskIterGetCurrent(SStreamTaskIter* pIter, SStreamTask** pTask) { + if (pTask) { + *pTask = pIter->pTask; + if (*pTask != NULL) { + return TSDB_CODE_SUCCESS; + } + } + + return TSDB_CODE_INVALID_PARA; } void destroyStreamTaskIter(SStreamTaskIter* pIter) { taosMemoryFree(pIter); } -SArray *mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady) { +int32_t mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady, SArray** pList) { SSdb *pSdb = pMnode->pSdb; void *pIter = NULL; SVgObj *pVgroup = NULL; int32_t replica = -1; // do the replica check + int32_t code = 0; *allReady = true; SArray *pVgroupList = taosArrayInit(4, sizeof(SNodeEntry)); @@ -131,10 +139,15 @@ SArray *mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady) { } char buf[256] = {0}; - epsetToStr(&entry.epset, buf, tListLen(buf)); + (void) epsetToStr(&entry.epset, buf, tListLen(buf)); + + void* p = taosArrayPush(pVgroupList, &entry); + if (p == NULL) { + mError("failed to put entry in vgroup list, nodeId:%d code:out of memory", entry.nodeId); + } else { + mDebug("take node snapshot, nodeId:%d %s", entry.nodeId, buf); + } - mDebug("take node snapshot, nodeId:%d %s", entry.nodeId, buf); - taosArrayPush(pVgroupList, &entry); sdbRelease(pSdb, pVgroup); } @@ -145,43 +158,57 @@ SArray *mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady) { break; } - SNodeEntry entry = {0}; - addEpIntoEpSet(&entry.epset, pObj->pDnode->fqdn, pObj->pDnode->port); - entry.nodeId = SNODE_HANDLE; + SNodeEntry entry = {.nodeId = SNODE_HANDLE}; + code = addEpIntoEpSet(&entry.epset, pObj->pDnode->fqdn, pObj->pDnode->port); + if (code) { + sdbRelease(pSdb, pObj); + continue; + } char buf[256] = {0}; - epsetToStr(&entry.epset, buf, tListLen(buf)); - mDebug("take snode snapshot, nodeId:%d %s", entry.nodeId, buf); + (void) epsetToStr(&entry.epset, buf, tListLen(buf)); + + void* p = taosArrayPush(pVgroupList, &entry); + if (p == NULL) { + mError("failed to put entry in vgroup list, nodeId:%d code:out of memory", entry.nodeId); + } else { + mDebug("take snode snapshot, nodeId:%d %s", entry.nodeId, buf); + } - taosArrayPush(pVgroupList, &entry); sdbRelease(pSdb, pObj); } - return pVgroupList; + *pList = pVgroupList; + return code; } -SStreamObj *mndGetStreamObj(SMnode *pMnode, int64_t streamId) { - void *pIter = NULL; - SSdb *pSdb = pMnode->pSdb; - SStreamObj *pStream = NULL; +int32_t mndGetStreamObj(SMnode *pMnode, int64_t streamId, SStreamObj **pStream) { + void *pIter = NULL; + SSdb *pSdb = pMnode->pSdb; + *pStream = NULL; - while ((pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream)) != NULL) { - if (pStream->uid == streamId) { + SStreamObj *p = NULL; + while ((pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&p)) != NULL) { + if (p->uid == streamId) { sdbCancelFetch(pSdb, pIter); - return pStream; + *pStream = p; + return TSDB_CODE_SUCCESS; } - sdbRelease(pSdb, pStream); + sdbRelease(pSdb, p); } - return NULL; + return TSDB_CODE_STREAM_TASK_NOT_EXIST; } void mndKillTransImpl(SMnode *pMnode, int32_t transId, const char *pDbName) { STrans *pTrans = mndAcquireTrans(pMnode, transId); if (pTrans != NULL) { mInfo("kill active transId:%d in Db:%s", transId, pDbName); - mndKillTrans(pMnode, pTrans); + int32_t code = mndKillTrans(pMnode, pTrans); mndReleaseTrans(pMnode, pTrans); + if (code) { + mError("failed to kill trans:%d", pTrans->id); + } } else { mError("failed to acquire trans in Db:%s, transId:%d", pDbName, transId); } @@ -197,11 +224,16 @@ int32_t extractNodeEpset(SMnode *pMnode, SEpSet *pEpSet, bool *hasEpset, int32_t pIter = sdbFetch(pMnode->pSdb, SDB_SNODE, pIter, (void **)&pObj); if (pIter != NULL) { - addEpIntoEpSet(pEpSet, pObj->pDnode->fqdn, pObj->pDnode->port); + int32_t code = addEpIntoEpSet(pEpSet, pObj->pDnode->fqdn, pObj->pDnode->port); sdbRelease(pMnode->pSdb, pObj); sdbCancelFetch(pMnode->pSdb, pIter); - *hasEpset = true; - return TSDB_CODE_SUCCESS; + if (code) { + *hasEpset = false; + mError("failed to set epset"); + } else { + *hasEpset = true; + } + return code; } else { mError("failed to acquire snode epset"); return TSDB_CODE_INVALID_PARA; @@ -223,12 +255,14 @@ int32_t extractNodeEpset(SMnode *pMnode, SEpSet *pEpSet, bool *hasEpset, int32_t } static int32_t doSetResumeAction(STrans *pTrans, SMnode *pMnode, SStreamTask *pTask, int8_t igUntreated) { + terrno = 0; + SVResumeStreamTaskReq *pReq = taosMemoryCalloc(1, sizeof(SVResumeStreamTaskReq)); if (pReq == NULL) { mError("failed to malloc in resume stream, size:%" PRIzu ", code:%s", sizeof(SVResumeStreamTaskReq), tstrerror(TSDB_CODE_OUT_OF_MEMORY)); terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno; } pReq->head.vgId = htonl(pTask->info.nodeId); @@ -242,31 +276,45 @@ static int32_t doSetResumeAction(STrans *pTrans, SMnode *pMnode, SStreamTask *pT if (code != TSDB_CODE_SUCCESS || (!hasEpset)) { terrno = code; taosMemoryFree(pReq); - return -1; + return terrno; } code = setTransAction(pTrans, pReq, sizeof(SVResumeStreamTaskReq), TDMT_STREAM_TASK_RESUME, &epset, 0, 0); if (code != 0) { taosMemoryFree(pReq); - return -1; + return terrno; } mDebug("set the resume action for trans:%d", pTrans->id); return 0; } -SStreamTask *mndGetStreamTask(STaskId *pId, SStreamObj *pStream) { - SStreamTaskIter *pIter = createStreamTaskIter(pStream); +int32_t mndGetStreamTask(STaskId *pId, SStreamObj *pStream, SStreamTask **pTask) { + *pTask = NULL; + + SStreamTask *p = NULL; + SStreamTaskIter *pIter = NULL; + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + mError("failed to create stream task iter:%s", pStream->name); + return code; + } + while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); - if (pTask->id.taskId == pId->taskId) { + code = streamTaskIterGetCurrent(pIter, &p); + if (code) { + continue; + } + + if (p->id.taskId == pId->taskId) { destroyStreamTaskIter(pIter); - return pTask; + *pTask = p; + return 0; } } destroyStreamTaskIter(pIter); - return NULL; + return TSDB_CODE_FAILED; } int32_t mndGetNumOfStreamTasks(const SStreamObj *pStream) { @@ -280,13 +328,25 @@ int32_t mndGetNumOfStreamTasks(const SStreamObj *pStream) { } int32_t mndStreamSetResumeAction(STrans *pTrans, SMnode *pMnode, SStreamObj *pStream, int8_t igUntreated) { - SStreamTaskIter *pIter = createStreamTaskIter(pStream); + SStreamTaskIter *pIter = NULL; + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + mError("failed to create stream task iter:%s", pStream->name); + return code; + } while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); - if (doSetResumeAction(pTrans, pMnode, pTask, igUntreated) < 0) { + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code || pTask == NULL) { destroyStreamTaskIter(pIter); - return -1; + return code; + } + + code = doSetResumeAction(pTrans, pMnode, pTask, igUntreated); + if (code) { + destroyStreamTaskIter(pIter); + return code; } if (atomic_load_8(&pTask->status.taskStatus) == TASK_STATUS__PAUSE) { @@ -303,7 +363,7 @@ static int32_t doSetPauseAction(SMnode *pMnode, STrans *pTrans, SStreamTask *pTa mError("failed to malloc in pause stream, size:%" PRIzu ", code:%s", sizeof(SVPauseStreamTaskReq), tstrerror(TSDB_CODE_OUT_OF_MEMORY)); terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno; } pReq->head.vgId = htonl(pTask->info.nodeId); @@ -320,25 +380,38 @@ static int32_t doSetPauseAction(SMnode *pMnode, STrans *pTrans, SStreamTask *pTa } char buf[256] = {0}; - epsetToStr(&epset, buf, tListLen(buf)); + (void) epsetToStr(&epset, buf, tListLen(buf)); mDebug("pause stream task in node:%d, epset:%s", pTask->info.nodeId, buf); code = setTransAction(pTrans, pReq, sizeof(SVPauseStreamTaskReq), TDMT_STREAM_TASK_PAUSE, &epset, 0, 0); if (code != 0) { taosMemoryFree(pReq); - return -1; + return code; } return 0; } int32_t mndStreamSetPauseAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream) { - SStreamTaskIter *pIter = createStreamTaskIter(pStream); + SStreamTaskIter *pIter = NULL; + + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + mError("failed to create stream task iter:%s", pStream->name); + return code; + } while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); - if (doSetPauseAction(pMnode, pTrans, pTask) < 0) { + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { destroyStreamTaskIter(pIter); - return -1; + return code; + } + + code = doSetPauseAction(pMnode, pTrans, pTask); + if (code) { + destroyStreamTaskIter(pIter); + return code; } if (atomic_load_8(&pTask->status.taskStatus) != TASK_STATUS__PAUSE) { @@ -348,14 +421,14 @@ int32_t mndStreamSetPauseAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStr } destroyStreamTaskIter(pIter); - return 0; + return code; } static int32_t doSetDropAction(SMnode *pMnode, STrans *pTrans, SStreamTask *pTask) { SVDropStreamTaskReq *pReq = taosMemoryCalloc(1, sizeof(SVDropStreamTaskReq)); if (pReq == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno; } pReq->head.vgId = htonl(pTask->info.nodeId); @@ -366,28 +439,40 @@ static int32_t doSetDropAction(SMnode *pMnode, STrans *pTrans, SStreamTask *pTas bool hasEpset = false; int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId); if (code != TSDB_CODE_SUCCESS || !hasEpset) { // no valid epset, return directly without redoAction - terrno = code; - return -1; + return code; } // The epset of nodeId of this task may have been expired now, let's use the newest epset from mnode. code = setTransAction(pTrans, pReq, sizeof(SVDropStreamTaskReq), TDMT_STREAM_TASK_DROP, &epset, 0, 0); if (code != 0) { taosMemoryFree(pReq); - return -1; + return code; } return 0; } int32_t mndStreamSetDropAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream) { - SStreamTaskIter *pIter = createStreamTaskIter(pStream); + SStreamTaskIter *pIter = NULL; + + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + mError("failed to create stream task iter:%s", pStream->name); + return code; + } while(streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); - if (doSetDropAction(pMnode, pTrans, pTask) < 0) { + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { destroyStreamTaskIter(pIter); - return -1; + return code; + } + + code = doSetDropAction(pMnode, pTrans, pTask); + if (code) { + destroyStreamTaskIter(pIter); + return code; } } destroyStreamTaskIter(pIter); @@ -398,7 +483,7 @@ static int32_t doSetDropActionFromId(SMnode *pMnode, STrans *pTrans, SOrphanTask SVDropStreamTaskReq *pReq = taosMemoryCalloc(1, sizeof(SVDropStreamTaskReq)); if (pReq == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno; } pReq->head.vgId = htonl(pTask->nodeId); @@ -409,16 +494,15 @@ static int32_t doSetDropActionFromId(SMnode *pMnode, STrans *pTrans, SOrphanTask bool hasEpset = false; int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->taskId, pTask->nodeId); if (code != TSDB_CODE_SUCCESS || (!hasEpset)) { // no valid epset, return directly without redoAction - terrno = code; taosMemoryFree(pReq); - return -1; + return code; } // The epset of nodeId of this task may have been expired now, let's use the newest epset from mnode. code = setTransAction(pTrans, pReq, sizeof(SVDropStreamTaskReq), TDMT_STREAM_TASK_DROP, &epset, 0, 0); if (code != 0) { taosMemoryFree(pReq); - return -1; + return code; } return 0; @@ -427,19 +511,35 @@ static int32_t doSetDropActionFromId(SMnode *pMnode, STrans *pTrans, SOrphanTask int32_t mndStreamSetDropActionFromList(SMnode *pMnode, STrans *pTrans, SArray* pList) { for(int32_t i = 0; i < taosArrayGetSize(pList); ++i) { SOrphanTask* pTask = taosArrayGet(pList, i); - mDebug("add drop task:0x%x action to drop orphan task", pTask->taskId); - doSetDropActionFromId(pMnode, pTrans, pTask); + int32_t code = doSetDropActionFromId(pMnode, pTrans, pTask); + if (code != 0) { + return code; + } else { + mDebug("add drop task:0x%x action to drop orphan task", pTask->taskId); + } } return 0; } static void initNodeUpdateMsg(SStreamTaskNodeUpdateMsg *pMsg, const SVgroupChangeInfo *pInfo, SStreamTaskId *pId, int32_t transId) { + int32_t code = 0; + pMsg->streamId = pId->streamId; pMsg->taskId = pId->taskId; pMsg->transId = transId; pMsg->pNodeList = taosArrayInit(taosArrayGetSize(pInfo->pUpdateNodeList), sizeof(SNodeUpdateInfo)); - taosArrayAddAll(pMsg->pNodeList, pInfo->pUpdateNodeList); + if (pMsg->pNodeList == NULL) { + mError("failed to prepare node list, code:out of memory"); + code = TSDB_CODE_OUT_OF_MEMORY; + } + + if (code == 0) { + void *p = taosArrayAddAll(pMsg->pNodeList, pInfo->pUpdateNodeList); + if (p == NULL) { + mError("failed to add update node list into nodeList"); + } + } } static int32_t doBuildStreamTaskUpdateMsg(void **pBuf, int32_t *pLen, SVgroupChangeInfo *pInfo, int32_t nodeId, @@ -454,7 +554,7 @@ static int32_t doBuildStreamTaskUpdateMsg(void **pBuf, int32_t *pLen, SVgroupCha if (code < 0) { terrno = TSDB_CODE_OUT_OF_MEMORY; taosArrayDestroy(req.pNodeList); - return -1; + return terrno; } int32_t tlen = sizeof(SMsgHead) + blen; @@ -463,13 +563,18 @@ static int32_t doBuildStreamTaskUpdateMsg(void **pBuf, int32_t *pLen, SVgroupCha if (buf == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; taosArrayDestroy(req.pNodeList); - return -1; + return terrno; } void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead)); SEncoder encoder; tEncoderInit(&encoder, abuf, tlen); - tEncodeStreamTaskUpdateMsg(&encoder, &req); + code = tEncodeStreamTaskUpdateMsg(&encoder, &req); + if (code == -1) { + tEncoderClear(&encoder); + taosArrayDestroy(req.pNodeList); + return code; + } SMsgHead *pMsgHead = (SMsgHead *)buf; pMsgHead->contLen = htonl(tlen); @@ -487,15 +592,20 @@ static int32_t doBuildStreamTaskUpdateMsg(void **pBuf, int32_t *pLen, SVgroupCha static int32_t doSetUpdateTaskAction(SMnode *pMnode, STrans *pTrans, SStreamTask *pTask, SVgroupChangeInfo *pInfo) { void *pBuf = NULL; int32_t len = 0; - streamTaskUpdateEpsetInfo(pTask, pInfo->pUpdateNodeList); + int32_t code = streamTaskUpdateEpsetInfo(pTask, pInfo->pUpdateNodeList); + if (code) { + return code; + } - doBuildStreamTaskUpdateMsg(&pBuf, &len, pInfo, pTask->info.nodeId, &pTask->id, pTrans->id); + code = doBuildStreamTaskUpdateMsg(&pBuf, &len, pInfo, pTask->info.nodeId, &pTask->id, pTrans->id); + if (code) { + return code; + } SEpSet epset = {0}; bool hasEpset = false; - int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId); + code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId); if (code != TSDB_CODE_SUCCESS || !hasEpset) { - terrno = code; return code; } @@ -510,16 +620,30 @@ static int32_t doSetUpdateTaskAction(SMnode *pMnode, STrans *pTrans, SStreamTask // build trans to update the epset int32_t mndStreamSetUpdateEpsetAction(SMnode *pMnode, SStreamObj *pStream, SVgroupChangeInfo *pInfo, STrans *pTrans) { mDebug("stream:0x%" PRIx64 " set tasks epset update action", pStream->uid); - taosWLockLatch(&pStream->lock); + SStreamTaskIter *pIter = NULL; + + taosWLockLatch(&pStream->lock); + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + taosWUnLockLatch(&pStream->lock); + mError("failed to create stream task iter:%s", pStream->name); + return code; + } - SStreamTaskIter *pIter = createStreamTaskIter(pStream); while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); - int32_t code = doSetUpdateTaskAction(pMnode, pTrans, pTask, pInfo); + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { + destroyStreamTaskIter(pIter); + taosWUnLockLatch(&pStream->lock); + return code; + } + + code = doSetUpdateTaskAction(pMnode, pTrans, pTask, pInfo); if (code != TSDB_CODE_SUCCESS) { destroyStreamTaskIter(pIter); taosWUnLockLatch(&pStream->lock); - return -1; + return code; } } @@ -558,16 +682,30 @@ static int32_t doSetResetAction(SMnode *pMnode, STrans *pTrans, SStreamTask *pTa } int32_t mndStreamSetResetTaskAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream) { - taosWLockLatch(&pStream->lock); + SStreamTaskIter *pIter = NULL; + + taosWLockLatch(&pStream->lock); + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + taosWUnLockLatch(&pStream->lock); + mError("failed to create stream task iter:%s", pStream->name); + return code; + } - SStreamTaskIter *pIter = createStreamTaskIter(pStream); while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); - int32_t code = doSetResetAction(pMnode, pTrans, pTask); + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { + destroyStreamTaskIter(pIter); + taosWUnLockLatch(&pStream->lock); + return code; + } + + code = doSetResetAction(pMnode, pTrans, pTask); if (code != TSDB_CODE_SUCCESS) { destroyStreamTaskIter(pIter); taosWUnLockLatch(&pStream->lock); - return -1; + return code; } } @@ -581,8 +719,12 @@ static void freeTaskList(void* param) { taosArrayDestroy(*pList); } -void mndInitExecInfo() { - taosThreadMutexInit(&execInfo.lock, NULL); +int32_t mndInitExecInfo() { + int32_t code = taosThreadMutexInit(&execInfo.lock, NULL); + if (code) { + return code; + } + _hash_fn_t fn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR); execInfo.pTaskList = taosArrayInit(4, sizeof(STaskId)); @@ -596,6 +738,7 @@ void mndInitExecInfo() { taosHashSetFreeFp(execInfo.pTransferStateStreams, freeTaskList); taosHashSetFreeFp(execInfo.pChkptStreams, freeTaskList); taosHashSetFreeFp(execInfo.pStreamConsensus, freeTaskList); + return 0; } void removeExpiredNodeInfo(const SArray *pNodeSnapshot) { @@ -608,7 +751,10 @@ void removeExpiredNodeInfo(const SArray *pNodeSnapshot) { for (int32_t j = 0; j < size; ++j) { SNodeEntry *pEntry = taosArrayGet(pNodeSnapshot, j); if (pEntry->nodeId == p->nodeId) { - taosArrayPush(pValidList, p); + void* px = taosArrayPush(pValidList, p); + if (px == NULL) { + mError("failed to put node into list, nodeId:%d", p->nodeId); + } break; } } @@ -626,7 +772,10 @@ int32_t doRemoveTasks(SStreamExecInfo *pExecNode, STaskId *pRemovedId) { return TSDB_CODE_SUCCESS; } - taosHashRemove(pExecNode->pTaskMap, pRemovedId, sizeof(*pRemovedId)); + int32_t code = taosHashRemove(pExecNode->pTaskMap, pRemovedId, sizeof(*pRemovedId)); + if (code) { + return code; + } for (int32_t k = 0; k < taosArrayGetSize(pExecNode->pTaskList); ++k) { STaskId *pId = taosArrayGet(pExecNode->pTaskList, k); @@ -645,28 +794,45 @@ int32_t doRemoveTasks(SStreamExecInfo *pExecNode, STaskId *pRemovedId) { void removeTasksInBuf(SArray *pTaskIds, SStreamExecInfo* pExecInfo) { for (int32_t i = 0; i < taosArrayGetSize(pTaskIds); ++i) { STaskId *pId = taosArrayGet(pTaskIds, i); - doRemoveTasks(pExecInfo, pId); + int32_t code = doRemoveTasks(pExecInfo, pId); + if (code) { + mError("failed to remove task in buffer list, 0x%"PRIx64, pId->taskId); + } } } void removeStreamTasksInBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode) { - taosThreadMutexLock(&pExecNode->lock); + SStreamTaskIter *pIter = NULL; + streamMutexLock(&pExecNode->lock); // 1. remove task entries - SStreamTaskIter *pIter = createStreamTaskIter(pStream); + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + streamMutexUnlock(&pExecNode->lock); + mError("failed to create stream task iter:%s", pStream->name); + return; + } + while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { + continue; + } STaskId id = {.streamId = pTask->id.streamId, .taskId = pTask->id.taskId}; - doRemoveTasks(pExecNode, &id); + code = doRemoveTasks(pExecNode, &id); + if (code) { + mError("failed to remove task in buffer list, 0x%"PRIx64, id.taskId); + } } ASSERT(taosHashGetSize(pExecNode->pTaskMap) == taosArrayGetSize(pExecNode->pTaskList)); // 2. remove stream entry in consensus hash table - mndClearConsensusCheckpointId(execInfo.pStreamConsensus, pStream->uid); + (void) mndClearConsensusCheckpointId(execInfo.pStreamConsensus, pStream->uid); - taosThreadMutexUnlock(&pExecNode->lock); + streamMutexUnlock(&pExecNode->lock); destroyStreamTaskIter(pIter); } @@ -697,7 +863,10 @@ int32_t removeExpiredNodeEntryAndTaskInBuf(SArray *pNodeSnapshot) { bool existed = taskNodeExists(pNodeSnapshot, pEntry->nodeId); if (!existed) { - taosArrayPush(pRemovedTasks, pId); + void* p = taosArrayPush(pRemovedTasks, pId); + if (p == NULL) { + mError("failed to put task entry into remove list, taskId:0x%" PRIx64, pId->taskId); + } } } @@ -759,45 +928,64 @@ static int32_t doSetUpdateChkptAction(SMnode *pMnode, STrans *pTrans, SStreamTas } int32_t mndStreamSetUpdateChkptAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream) { + SStreamTaskIter *pIter = NULL; + taosWLockLatch(&pStream->lock); + int32_t code = createStreamTaskIter(pStream, &pIter); + if (code) { + taosWUnLockLatch(&pStream->lock); + mError("failed to create stream task iter:%s", pStream->name); + return code; + } - SStreamTaskIter *pIter = createStreamTaskIter(pStream); while (streamTaskIterNextTask(pIter)) { - SStreamTask *pTask = streamTaskIterGetCurrent(pIter); + SStreamTask *pTask = NULL; + code = streamTaskIterGetCurrent(pIter, &pTask); + if (code) { + destroyStreamTaskIter(pIter); + taosWUnLockLatch(&pStream->lock); + return code; + } - int32_t code = doSetUpdateChkptAction(pMnode, pTrans, pTask); + code = doSetUpdateChkptAction(pMnode, pTrans, pTask); if (code != TSDB_CODE_SUCCESS) { destroyStreamTaskIter(pIter); taosWUnLockLatch(&pStream->lock); - return -1; + return code; } } destroyStreamTaskIter(pIter); taosWUnLockLatch(&pStream->lock); - return 0; + return code; } int32_t mndScanCheckpointReportInfo(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; void *pIter = NULL; SArray *pDropped = taosArrayInit(4, sizeof(int64_t)); + int32_t code = 0; mDebug("start to scan checkpoint report info"); while ((pIter = taosHashIterate(execInfo.pChkptStreams, pIter)) != NULL) { SArray *pList = *(SArray **)pIter; - STaskChkptInfo* pInfo = taosArrayGet(pList, 0); - SStreamObj* pStream = mndGetStreamObj(pMnode, pInfo->streamId); - if (pStream == NULL) { + STaskChkptInfo *pInfo = taosArrayGet(pList, 0); + SStreamObj *pStream = NULL; + code = mndGetStreamObj(pMnode, pInfo->streamId, &pStream); + if (pStream == NULL || code != 0) { mDebug("failed to acquire stream:0x%" PRIx64 " remove it from checkpoint-report list", pInfo->streamId); - taosArrayPush(pDropped, &pInfo->streamId); + void* p = taosArrayPush(pDropped, &pInfo->streamId); + if (p == NULL) { + mError("failed to put stream into drop list:0x%" PRIx64, pInfo->streamId); + } + continue; } int32_t total = mndGetNumOfStreamTasks(pStream); - int32_t existed = (int32_t) taosArrayGetSize(pList); + int32_t existed = (int32_t)taosArrayGetSize(pList); if (total == existed) { mDebug("stream:0x%" PRIx64 " %s all %d tasks send checkpoint-report, start to update checkpoint-info", @@ -805,17 +993,21 @@ int32_t mndScanCheckpointReportInfo(SRpcMsg *pReq) { bool conflict = mndStreamTransConflictCheck(pMnode, pStream->uid, MND_STREAM_CHKPT_UPDATE_NAME, false); if (!conflict) { - int32_t code = mndCreateStreamChkptInfoUpdateTrans(pMnode, pStream, pList); - if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_ACTION_IN_PROGRESS) { // remove this entry - taosArrayPush(pDropped, &pInfo->streamId); - mDebug("stream:0x%" PRIx64 " removed", pInfo->streamId); + code = mndCreateStreamChkptInfoUpdateTrans(pMnode, pStream, pList); + if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_ACTION_IN_PROGRESS) { // remove this entry + void* p = taosArrayPush(pDropped, &pInfo->streamId); + if (p == NULL) { + mError("failed to remove stream:0x%" PRIx64, pInfo->streamId); + } else { + mDebug("stream:0x%" PRIx64 " removed", pInfo->streamId); + } } else { mDebug("stream:0x%" PRIx64 " not launch chkpt-meta update trans, due to checkpoint not finished yet", pInfo->streamId); } break; } else { - mDebug("stream:0x%"PRIx64" active checkpoint trans not finished yet, wait", pInfo->streamId); + mDebug("stream:0x%" PRIx64 " active checkpoint trans not finished yet, wait", pInfo->streamId); } } else { mDebug("stream:0x%" PRIx64 " %s %d/%d tasks send checkpoint-report, %d not send", pInfo->streamId, pStream->name, @@ -829,7 +1021,10 @@ int32_t mndScanCheckpointReportInfo(SRpcMsg *pReq) { if (size > 0) { for (int32_t i = 0; i < size; ++i) { int64_t streamId = *(int64_t *)taosArrayGet(pDropped, i); - taosHashRemove(execInfo.pChkptStreams, &streamId, sizeof(streamId)); + code = taosHashRemove(execInfo.pChkptStreams, &streamId, sizeof(streamId)); + if (code) { + mError("failed to remove stream in buf:0x%"PRIx64, streamId); + } } int32_t numOfStreams = taosHashGetSize(execInfo.pChkptStreams); @@ -854,29 +1049,30 @@ static int32_t mndStreamSetChkptIdAction(SMnode *pMnode, STrans *pTrans, SStream int32_t blen; tEncodeSize(tEncodeRestoreCheckpointInfo, &req, blen, code); if (code < 0) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno = TSDB_CODE_OUT_OF_MEMORY; } int32_t tlen = sizeof(SMsgHead) + blen; void *pBuf = taosMemoryMalloc(tlen); if (pBuf == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno = TSDB_CODE_OUT_OF_MEMORY; } void *abuf = POINTER_SHIFT(pBuf, sizeof(SMsgHead)); SEncoder encoder; tEncoderInit(&encoder, abuf, tlen); - tEncodeRestoreCheckpointInfo(&encoder, &req); + code = tEncodeRestoreCheckpointInfo(&encoder, &req); + tEncoderClear(&encoder); + if (code == -1) { + taosMemoryFree(pBuf); + return code; + } SMsgHead *pMsgHead = (SMsgHead *)pBuf; pMsgHead->contLen = htonl(tlen); pMsgHead->vgId = htonl(pTask->info.nodeId); - tEncoderClear(&encoder); - SEpSet epset = {0}; bool hasEpset = false; code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId); @@ -898,17 +1094,28 @@ int32_t mndCreateSetConsensusChkptIdTrans(SMnode *pMnode, SStreamObj *pStream, i char msg[128] = {0}; snprintf(msg, tListLen(msg), "set consen-chkpt-id for task:0x%x", taskId); - STrans *pTrans = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_CHKPT_CONSEN_NAME, msg); - if (pTrans == NULL) { + STrans *pTrans = NULL; + int32_t code = doCreateTrans(pMnode, pStream, NULL, TRN_CONFLICT_NOTHING, MND_STREAM_CHKPT_CONSEN_NAME, msg, &pTrans); + if (pTrans == NULL || code != 0) { return terrno; } STaskId id = {.streamId = pStream->uid, .taskId = taskId}; - SStreamTask *pTask = mndGetStreamTask(&id, pStream); - ASSERT(pTask); + SStreamTask *pTask = NULL; + code = mndGetStreamTask(&id, pStream, &pTask); + if (code) { + mError("failed to get task:0x%x in stream:%s, failed to create consensus-checkpointId", taskId, pStream->name); + sdbRelease(pMnode->pSdb, pStream); + return code; + } - /*int32_t code = */ mndStreamRegisterTrans(pTrans, MND_STREAM_CHKPT_CONSEN_NAME, pStream->uid); - int32_t code = mndStreamSetChkptIdAction(pMnode, pTrans, pTask, checkpointId, ts); + code = mndStreamRegisterTrans(pTrans, MND_STREAM_CHKPT_CONSEN_NAME, pStream->uid); + if (code) { + sdbRelease(pMnode->pSdb, pStream); + return code; + } + + code = mndStreamSetChkptIdAction(pMnode, pTrans, pTask, checkpointId, ts); if (code != 0) { sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); @@ -916,17 +1123,18 @@ int32_t mndCreateSetConsensusChkptIdTrans(SMnode *pMnode, SStreamObj *pStream, i } code = mndPersistTransLog(pStream, pTrans, SDB_STATUS_READY); - if (code != TSDB_CODE_SUCCESS) { + if (code) { sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } - if (mndTransPrepare(pMnode, pTrans) != 0) { + code = mndTransPrepare(pMnode, pTrans); + if (code) { mError("trans:%d, failed to prepare set consensus-chkptId trans since %s", pTrans->id, terrstr()); sdbRelease(pMnode->pSdb, pStream); mndTransDrop(pTrans); - return -1; + return code; } sdbRelease(pMnode->pSdb, pStream); @@ -935,10 +1143,13 @@ int32_t mndCreateSetConsensusChkptIdTrans(SMnode *pMnode, SStreamObj *pStream, i return TSDB_CODE_ACTION_IN_PROGRESS; } -SCheckpointConsensusInfo* mndGetConsensusInfo(SHashObj* pHash, int64_t streamId, int32_t numOfTasks) { - void* pInfo = taosHashGet(pHash, &streamId, sizeof(streamId)); - if (pInfo != NULL) { - return (SCheckpointConsensusInfo*)pInfo; +int32_t mndGetConsensusInfo(SHashObj* pHash, int64_t streamId, int32_t numOfTasks, SCheckpointConsensusInfo **pInfo) { + *pInfo = NULL; + + void* px = taosHashGet(pHash, &streamId, sizeof(streamId)); + if (px != NULL) { + *pInfo = px; + return 0; } SCheckpointConsensusInfo p = { @@ -947,10 +1158,14 @@ SCheckpointConsensusInfo* mndGetConsensusInfo(SHashObj* pHash, int64_t streamId, .streamId = streamId, }; - taosHashPut(pHash, &streamId, sizeof(streamId), &p, sizeof(p)); - - void* pChkptInfo = (SCheckpointConsensusInfo*)taosHashGet(pHash, &streamId, sizeof(streamId)); - return pChkptInfo; + int32_t code = taosHashPut(pHash, &streamId, sizeof(streamId), &p, sizeof(p)); + if (code == 0) { + void *pChkptInfo = (SCheckpointConsensusInfo *)taosHashGet(pHash, &streamId, sizeof(streamId)); + *pInfo = pChkptInfo; + } else { + *pInfo = NULL; + } + return code; } // no matter existed or not, add the request into info list anyway, since we need to send rsp mannually @@ -971,11 +1186,15 @@ void mndAddConsensusTasks(SCheckpointConsensusInfo *pInfo, const SRestoreCheckpo } } - taosArrayPush(pInfo->pTaskList, &info); - int32_t num = taosArrayGetSize(pInfo->pTaskList); - mDebug("s-task:0x%x checkpointId:%" PRId64 " added into consensus-checkpointId list, stream:0x%" PRIx64 - " waiting tasks:%d", - pRestoreInfo->taskId, pRestoreInfo->checkpointId, pRestoreInfo->streamId, num); + void *p = taosArrayPush(pInfo->pTaskList, &info); + if (p == NULL) { + mError("s-task:0x%x failed to put task into consensus-checkpointId list, code: out of memory", info.req.taskId); + } else { + int32_t num = taosArrayGetSize(pInfo->pTaskList); + mDebug("s-task:0x%x checkpointId:%" PRId64 " added into consensus-checkpointId list, stream:0x%" PRIx64 + " waiting tasks:%d", + pRestoreInfo->taskId, pRestoreInfo->checkpointId, pRestoreInfo->streamId, num); + } } void mndClearConsensusRspEntry(SCheckpointConsensusInfo* pInfo) { @@ -984,22 +1203,14 @@ void mndClearConsensusRspEntry(SCheckpointConsensusInfo* pInfo) { } int64_t mndClearConsensusCheckpointId(SHashObj* pHash, int64_t streamId) { - taosHashRemove(pHash, &streamId, sizeof(streamId)); - int32_t numOfStreams = taosHashGetSize(pHash); - mDebug("drop stream:0x%" PRIx64 " in consensus-checkpointId list after new checkpoint generated, remain:%d", streamId, - numOfStreams); - return TSDB_CODE_SUCCESS; -} + int32_t code = taosHashRemove(pHash, &streamId, sizeof(streamId)); + if (code == 0) { + int32_t numOfStreams = taosHashGetSize(pHash); + mDebug("drop stream:0x%" PRIx64 " in consensus-checkpointId list after new checkpoint generated, remain:%d", + streamId, numOfStreams); + } else { + mError("failed to remove stream:0x%"PRIx64" in consensus-checkpointId list", streamId); + } -//int32_t mndRegisterConsensusChkptId(SHashObj* pHash, int64_t streamId) { -// void* pInfo = taosHashGet(pHash, &streamId, sizeof(streamId)); -// ASSERT(pInfo == NULL); -// -// SCheckpointConsensusInfo p = {.genTs = taosGetTimestampMs(), .checkpointId = 0, .pTaskList = NULL}; -// taosHashPut(pHash, &streamId, sizeof(streamId), &p, sizeof(p)); -// -// SCheckpointConsensusInfo* pChkptInfo = (SCheckpointConsensusInfo*)taosHashGet(pHash, &streamId, sizeof(streamId)); -// ASSERT(pChkptInfo->genTs > 0 && pChkptInfo->checkpointId == 0); -// mDebug("s-task:0x%" PRIx64 " set the initial consensus-checkpointId:0", streamId); -// return TSDB_CODE_SUCCESS; -//} \ No newline at end of file + return code; +} \ No newline at end of file diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index 43e291dc6b..efa7ef3912 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -44,11 +44,16 @@ static void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter); static void mndCheckConsumer(SRpcMsg *pMsg, SHashObj *hash); static int32_t mndSetSubCommitLogs(STrans *pTrans, SMqSubscribeObj *pSub) { + int32_t code = 0; SSdbRaw *pCommitRaw = mndSubActionEncode(pSub); - if (pCommitRaw == NULL) return -1; - if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1; - return 0; + if (pCommitRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + TAOS_RETURN(code); + } + TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw)); + TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY)); + TAOS_RETURN(code); } int32_t mndInitSubscribe(SMnode *pMnode) { @@ -75,6 +80,7 @@ int32_t mndInitSubscribe(SMnode *pMnode) { } static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *subKey) { + int32_t code = 0; SMqSubscribeObj *pSub = tNewSubscribeObj(subKey); if (pSub == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -86,7 +92,7 @@ static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj pSub->subType = pTopic->subType; pSub->withMeta = pTopic->withMeta; - if (mndSchedInitSubEp(pMnode, pTopic, pSub) < 0) { + if ((terrno = mndSchedInitSubEp(pMnode, pTopic, pSub)) < 0) { tDeleteSubscribeObj(pSub); taosMemoryFree(pSub); return NULL; @@ -97,6 +103,7 @@ static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg, SSubplan *pPlan) { + int32_t code = 0; SMqRebVgReq req = {0}; req.oldConsumerId = pRebVg->oldConsumerId; req.newConsumerId = pRebVg->newConsumerId; @@ -106,8 +113,8 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj pPlan->execNode.nodeId = pRebVg->pVgEp->vgId; int32_t msgLen; if (qSubPlanToString(pPlan, &req.qmsg, &msgLen) < 0) { - terrno = TSDB_CODE_QRY_INVALID_INPUT; - return -1; + code = TSDB_CODE_QRY_INVALID_INPUT; + TAOS_RETURN(code); } } else { req.qmsg = taosStrdup(""); @@ -122,7 +129,7 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj tEncodeSize(tEncodeSMqRebVgReq, &req, tlen, ret); if (ret < 0) { taosMemoryFree(req.qmsg); - return -1; + TAOS_RETURN(ret); } tlen += sizeof(SMsgHead); @@ -130,7 +137,7 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj if (buf == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; taosMemoryFree(req.qmsg); - return -1; + TAOS_RETURN(ret); } SMsgHead *pMsgHead = (SMsgHead *)buf; @@ -140,40 +147,41 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj SEncoder encoder = {0}; tEncoderInit(&encoder, POINTER_SHIFT(buf, sizeof(SMsgHead)), tlen); - if (tEncodeSMqRebVgReq(&encoder, &req) < 0) { + if ((code = tEncodeSMqRebVgReq(&encoder, &req)) < 0) { taosMemoryFreeClear(buf); tEncoderClear(&encoder); taosMemoryFree(req.qmsg); - return -1; + TAOS_RETURN(code); } tEncoderClear(&encoder); *pBuf = buf; *pLen = tlen; taosMemoryFree(req.qmsg); - return 0; + TAOS_RETURN(code); } static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg, SSubplan *pPlan) { + int32_t code = 0; if (pRebVg->oldConsumerId == pRebVg->newConsumerId) { if (pRebVg->oldConsumerId == -1) return 0; // drop stream, no consumer, while split vnode,all consumerId is -1 - terrno = TSDB_CODE_MND_INVALID_SUB_OPTION; - return -1; + code = TSDB_CODE_MND_INVALID_SUB_OPTION; + TAOS_RETURN(code); } void *buf; int32_t tlen; - if (mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan) < 0) { - return -1; + if ((code = mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan)) < 0) { + TAOS_RETURN(code); } int32_t vgId = pRebVg->pVgEp->vgId; SVgObj *pVgObj = mndAcquireVgroup(pMnode, vgId); if (pVgObj == NULL) { taosMemoryFree(buf); - terrno = TSDB_CODE_MND_VGROUP_NOT_EXIST; - return -1; + code = TSDB_CODE_MND_VGROUP_NOT_EXIST; + TAOS_RETURN(code); } STransAction action = {0}; @@ -183,11 +191,11 @@ static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubsc action.msgType = TDMT_VND_TMQ_SUBSCRIBE; mndReleaseVgroup(pMnode, pVgObj); - if (mndTransAppendRedoAction(pTrans, &action) != 0) { + if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { taosMemoryFree(buf); - return -1; + TAOS_RETURN(code); } - return 0; + TAOS_RETURN(code); } static int32_t mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, bool fullName) { @@ -209,6 +217,7 @@ static int32_t mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, } static SMqRebInfo *mndGetOrCreateRebSub(SHashObj *pHash, const char *key) { + terrno = 0; SMqRebInfo *pRebInfo = taosHashGet(pHash, key, strlen(key) + 1); if (pRebInfo == NULL) { pRebInfo = tNewSMqRebSubscribe(key); @@ -612,7 +621,6 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu if (strcmp(pOutput->pSub->qmsg, "") != 0) { code = qStringToSubplan(pOutput->pSub->qmsg, &pPlan); if (code != 0) { - terrno = code; goto END; } } @@ -623,7 +631,8 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB_INSIDE, pMsg, "tmq-reb"); if (pTrans == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; goto END; } @@ -665,7 +674,7 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu END: nodesDestroyNode((SNode *)pPlan); mndTransDrop(pTrans); - return code; + TAOS_RETURN(code); } static void freeRebalanceItem(void *param) { @@ -827,6 +836,7 @@ static void checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) { } static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOutputObj *rebOutput) { + int32_t code = 0; const char *key = rebInput->pRebInfo->key; SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, key); @@ -838,8 +848,10 @@ static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOu SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic); if (pTopic == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; mError("[rebalance] mq rebalance %s ignored since topic %s doesn't exist", key, topic); - return -1; + TAOS_RETURN(code); } taosRLockLatch(&pTopic->lock); @@ -848,10 +860,12 @@ static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOu rebOutput->pSub = mndCreateSubscription(pMnode, pTopic, key); if (rebOutput->pSub == NULL) { - mError("[rebalance] mq rebalance %s failed create sub since %s, ignore", key, terrstr()); + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + mError("[rebalance] mq rebalance %s failed create sub since %s, ignore", key, tstrerror(code)); taosRUnLockLatch(&pTopic->lock); mndReleaseTopic(pMnode, pTopic); - return -1; + TAOS_RETURN(code); } memcpy(rebOutput->pSub->dbName, pTopic->db, TSDB_DB_FNAME_LEN); @@ -869,7 +883,7 @@ static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOu mInfo("[rebalance] sub topic:%s has %d consumers sub till now", key, rebInput->oldConsumerNum); mndReleaseSubscribe(pMnode, pSub); } - return 0; + TAOS_RETURN(code); } static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) { @@ -885,6 +899,7 @@ static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) { SHashObj *rebSubHash = taosHashInit(64, MurmurHash3_32, true, HASH_NO_LOCK); if (rebSubHash == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; + if (terrno != 0) code = terrno; goto END; } taosHashSetFreeFp(rebSubHash, freeRebalanceItem); @@ -915,8 +930,8 @@ static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) { mndDoRebalance(pMnode, &rebInput, &rebOutput); - if (mndPersistRebResult(pMnode, pMsg, &rebOutput) != 0) { - mError("mq rebalance persist output error, possibly vnode splitted or dropped,msg:%s", terrstr()) + if ((code = mndPersistRebResult(pMnode, pMsg, &rebOutput)) != 0) { + mError("mq rebalance persist output error, possibly vnode splitted or dropped,msg:%s", tstrerror(code)) } clearRebOutput(&rebOutput); @@ -931,7 +946,7 @@ END: taosHashCleanup(rebSubHash); mndRebCntDec(); - return code; + TAOS_RETURN(code); } static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STrans *pTrans) { @@ -950,8 +965,7 @@ static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STran } SMqVDeleteReq *pReq = taosMemoryCalloc(1, sizeof(SMqVDeleteReq)); if (pReq == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - ret = -1; + ret = TSDB_CODE_OUT_OF_MEMORY; goto END; } pReq->head.vgId = htonl(pVgObj->vgId); @@ -968,15 +982,14 @@ static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STran action.acceptableCode = TSDB_CODE_MND_VGROUP_NOT_EXIST; sdbRelease(pMnode->pSdb, pVgObj); - if (mndTransAppendRedoAction(pTrans, &action) != 0) { - ret = -1; + if ((ret = mndTransAppendRedoAction(pTrans, &action)) != 0) { goto END; } } END: sdbRelease(pMnode->pSdb, pVgObj); sdbCancelFetch(pMnode->pSdb, pIter); - return ret; + TAOS_RETURN(ret); } static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgroup, char *topic) { @@ -1012,7 +1025,7 @@ static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgro END: sdbRelease(pMnode->pSdb, pConsumer); sdbCancelFetch(pMnode->pSdb, pIter); - return ret; + TAOS_RETURN(ret); } static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) { @@ -1022,8 +1035,8 @@ static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) { int32_t code = TSDB_CODE_ACTION_IN_PROGRESS; if (tDeserializeSMDropCgroupReq(pMsg->pCont, pMsg->contLen, &dropReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; + code = TSDB_CODE_INVALID_MSG; + TAOS_RETURN(code); } SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, dropReq.cgroup, dropReq.topic); @@ -1032,24 +1045,24 @@ static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) { mInfo("cgroup:%s on topic:%s, not exist, ignore not exist is set", dropReq.cgroup, dropReq.topic); return 0; } else { - terrno = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST; - mError("topic:%s, cgroup:%s, failed to drop since %s", dropReq.topic, dropReq.cgroup, terrstr()); - return -1; + code = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST; + mError("topic:%s, cgroup:%s, failed to drop since %s", dropReq.topic, dropReq.cgroup, tstrerror(code)); + TAOS_RETURN(code); } } taosWLockLatch(&pSub->lock); if (taosHashGetSize(pSub->consumerHash) != 0) { - terrno = TSDB_CODE_MND_CGROUP_USED; - mError("cgroup:%s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr()); - code = -1; + code = TSDB_CODE_MND_CGROUP_USED; + mError("cgroup:%s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, tstrerror(code)); goto end; } pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB_INSIDE, pMsg, "drop-cgroup"); if (pTrans == NULL) { - mError("cgroup: %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr()); - code = -1; + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + mError("cgroup: %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, tstrerror(code)); goto end; } @@ -1088,9 +1101,9 @@ end: if (code != 0) { mError("cgroup %s on topic:%s, failed to drop", dropReq.cgroup, dropReq.topic); - return code; + TAOS_RETURN(code); } - return TSDB_CODE_ACTION_IN_PROGRESS; + TAOS_RETURN(TSDB_CODE_ACTION_IN_PROGRESS); } void mndCleanupSubscribe(SMnode *pMnode) {} @@ -1344,7 +1357,7 @@ END: sdbRelease(pSdb, pSub); sdbCancelFetch(pSdb, pIter); - return code; + TAOS_RETURN(code); } static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t consumerId, const char *topic, diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c index 573b75ff5a..70d0b858f6 100644 --- a/source/dnode/mnode/impl/src/mndSync.c +++ b/source/dnode/mnode/impl/src/mndSync.c @@ -123,15 +123,16 @@ _OUT: } static int32_t mndTransValidateImp(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; if (pTrans->stage == TRN_STAGE_PREPARE) { - if (mndTransCheckConflict(pMnode, pTrans) < 0) { + if ((code = mndTransCheckConflict(pMnode, pTrans)) < 0) { mError("trans:%d, failed to validate trans conflicts.", pTrans->id); - return -1; + TAOS_RETURN(code); } return mndTransValidatePrepareStage(pMnode, pTrans); } - return 0; + TAOS_RETURN(code); } static int32_t mndTransValidate(SMnode *pMnode, SSdbRaw *pRaw) { @@ -139,10 +140,18 @@ static int32_t mndTransValidate(SMnode *pMnode, SSdbRaw *pRaw) { int32_t code = -1; SSdbRow *pRow = mndTransDecode(pRaw); - if (pRow == NULL) goto _OUT; + if (pRow == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OUT; + } pTrans = sdbGetRowObj(pRow); - if (pTrans == NULL) goto _OUT; + if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OUT; + } code = mndTransValidateImp(pMnode, pTrans); @@ -150,11 +159,10 @@ _OUT: if (pTrans) mndTransDropData(pTrans); if (pRow) taosMemoryFreeClear(pRow); if (code) terrno = (terrno ? terrno : TSDB_CODE_MND_TRANS_CONFLICT); - return code; + TAOS_RETURN(code); } int32_t mndProcessWriteMsg(SMnode *pMnode, SRpcMsg *pMsg, SFsmCbMeta *pMeta) { - terrno = TSDB_CODE_SUCCESS; SSyncMgmt *pMgmt = &pMnode->syncMgmt; SSdbRaw *pRaw = pMsg->pCont; STrans *pTrans = NULL; @@ -163,7 +171,7 @@ int32_t mndProcessWriteMsg(SMnode *pMnode, SRpcMsg *pMsg, SFsmCbMeta *pMeta) { if (transId <= 0) { mError("trans:%d, invalid commit msg, cache transId:%d seq:%" PRId64, transId, pMgmt->transId, pMgmt->transSeq); - terrno = TSDB_CODE_INVALID_MSG; + code = TSDB_CODE_INVALID_MSG; goto _OUT; } @@ -176,7 +184,7 @@ int32_t mndProcessWriteMsg(SMnode *pMnode, SRpcMsg *pMsg, SFsmCbMeta *pMeta) { if (code != 0) { mError("trans:%d, failed to validate requested trans since %s", transId, terrstr()); code = 0; - pMeta->code = terrno; + pMeta->code = code; goto _OUT; } @@ -184,13 +192,15 @@ int32_t mndProcessWriteMsg(SMnode *pMnode, SRpcMsg *pMsg, SFsmCbMeta *pMeta) { if (code != 0) { mError("trans:%d, failed to write to sdb since %s", transId, terrstr()); code = 0; - pMeta->code = terrno; + pMeta->code = code; goto _OUT; } pTrans = mndAcquireTrans(pMnode, transId); if (pTrans == NULL) { - mError("trans:%d, not found while execute in mnode since %s", transId, terrstr()); + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + mError("trans:%d, not found while execute in mnode since %s", transId, tstrerror(code)); goto _OUT; } @@ -207,7 +217,7 @@ int32_t mndProcessWriteMsg(SMnode *pMnode, SRpcMsg *pMsg, SFsmCbMeta *pMeta) { _OUT: if (pTrans) mndReleaseTrans(pMnode, pTrans); - return code; + TAOS_RETURN(code); } static int32_t mndPostMgmtCode(SMnode *pMnode, int32_t code) { @@ -258,7 +268,7 @@ _OUT: mndPostMgmtCode(pMnode, code ? code : pMeta->code); rpcFreeCont(pMsg->pCont); pMsg->pCont = NULL; - return code; + TAOS_RETURN(code); } SyncIndex mndSyncAppliedIndex(const SSyncFSM *pFSM) { @@ -466,16 +476,18 @@ int32_t mndInitSync(SMnode *pMnode) { pNode->clusterId); } + int32_t code = 0; tsem_init(&pMgmt->syncSem, 0, 0); pMgmt->sync = syncOpen(&syncInfo, true); if (pMgmt->sync <= 0) { - mError("failed to open sync since %s", terrstr()); - return -1; + if (terrno != 0) code = terrno; + mError("failed to open sync since %s", tstrerror(code)); + TAOS_RETURN(code); } pMnode->pSdb->sync = pMgmt->sync; mInfo("mnode-sync is opened, id:%" PRId64, pMgmt->sync); - return 0; + TAOS_RETURN(code); } void mndCleanupSync(SMnode *pMnode) { @@ -518,10 +530,10 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) { SSyncMgmt *pMgmt = &pMnode->syncMgmt; SRpcMsg req = {.msgType = TDMT_MND_APPLY_MSG, .contLen = sdbGetRawTotalSize(pRaw)}; - if (req.contLen <= 0) return -1; + if (req.contLen <= 0) return TSDB_CODE_OUT_OF_MEMORY; req.pCont = rpcMallocCont(req.contLen); - if (req.pCont == NULL) return -1; + if (req.pCont == NULL) return TSDB_CODE_OUT_OF_MEMORY; memcpy(req.pCont, pRaw, req.contLen); taosThreadMutexLock(&pMgmt->lock); @@ -531,8 +543,7 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) { mError("trans:%d, can't be proposed since trans:%d already waiting for confirm", transId, pMgmt->transId); taosThreadMutexUnlock(&pMgmt->lock); rpcFreeCont(req.pCont); - terrno = TSDB_CODE_MND_LAST_TRANS_NOT_FINISHED; - return terrno; + TAOS_RETURN(TSDB_CODE_MND_LAST_TRANS_NOT_FINISHED); } mInfo("trans:%d, will be proposed", transId); diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt index 400725b041..f70a8844ba 100644 --- a/source/dnode/vnode/CMakeLists.txt +++ b/source/dnode/vnode/CMakeLists.txt @@ -22,7 +22,6 @@ set( # meta "src/meta/metaOpen.c" - "src/meta/metaIdx.c" "src/meta/metaTable.c" "src/meta/metaSma.c" "src/meta/metaQuery.c" diff --git a/source/dnode/vnode/src/inc/tq.h b/source/dnode/vnode/src/inc/tq.h index d3582ab8f3..56a3c00fee 100644 --- a/source/dnode/vnode/src/inc/tq.h +++ b/source/dnode/vnode/src/inc/tq.h @@ -155,8 +155,8 @@ int32_t tqSetDstTableDataPayload(uint64_t suid, const STSchema* pTSchema, int32_ SSubmitTbData* pTableData, int64_t earlyTs, const char* id); int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, const char* id); -SVCreateTbReq* buildAutoCreateTableReq(const char* stbFullName, int64_t suid, int32_t numOfCols, - SSDataBlock* pDataBlock, SArray* pTagArray, bool newSubTableRule); +int32_t buildAutoCreateTableReq(const char* stbFullName, int64_t suid, int32_t numOfCols, SSDataBlock* pDataBlock, + SArray* pTagArray, bool newSubTableRule, SVCreateTbReq** pReq); #define TQ_ERR_GO_TO_END(c) \ do { \ diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h index 0dc53afc48..32e4fea336 100644 --- a/source/dnode/vnode/src/inc/vnodeInt.h +++ b/source/dnode/vnode/src/inc/vnodeInt.h @@ -318,7 +318,7 @@ void* tdUidStoreFree(STbUidStore* pStore); // SMetaSnapReader ======================================== int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapReader** ppReader); -int32_t metaSnapReaderClose(SMetaSnapReader** ppReader); +void metaSnapReaderClose(SMetaSnapReader** ppReader); int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData); // SMetaSnapWriter ======================================== int32_t metaSnapWriterOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapWriter** ppWriter); diff --git a/source/dnode/vnode/src/meta/metaCache.c b/source/dnode/vnode/src/meta/metaCache.c index 64cee3513c..3d4757d3e4 100644 --- a/source/dnode/vnode/src/meta/metaCache.c +++ b/source/dnode/vnode/src/meta/metaCache.c @@ -117,91 +117,81 @@ static void freeCacheEntryFp(void* param) { } int32_t metaCacheOpen(SMeta* pMeta) { - int32_t code = 0; - SMetaCache* pCache = NULL; + int32_t code = 0; + int32_t lino; - pCache = (SMetaCache*)taosMemoryMalloc(sizeof(SMetaCache)); - if (pCache == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + pMeta->pCache = (SMetaCache*)taosMemoryCalloc(1, sizeof(SMetaCache)); + if (pMeta->pCache == NULL) { + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } // open entry cache - pCache->sEntryCache.nEntry = 0; - pCache->sEntryCache.nBucket = META_CACHE_BASE_BUCKET; - pCache->sEntryCache.aBucket = - (SMetaCacheEntry**)taosMemoryCalloc(pCache->sEntryCache.nBucket, sizeof(SMetaCacheEntry*)); - if (pCache->sEntryCache.aBucket == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + pMeta->pCache->sEntryCache.nEntry = 0; + pMeta->pCache->sEntryCache.nBucket = META_CACHE_BASE_BUCKET; + pMeta->pCache->sEntryCache.aBucket = + (SMetaCacheEntry**)taosMemoryCalloc(pMeta->pCache->sEntryCache.nBucket, sizeof(SMetaCacheEntry*)); + if (pMeta->pCache->sEntryCache.aBucket == NULL) { + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } // open stats cache - pCache->sStbStatsCache.nEntry = 0; - pCache->sStbStatsCache.nBucket = META_CACHE_STATS_BUCKET; - pCache->sStbStatsCache.aBucket = - (SMetaStbStatsEntry**)taosMemoryCalloc(pCache->sStbStatsCache.nBucket, sizeof(SMetaStbStatsEntry*)); - if (pCache->sStbStatsCache.aBucket == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + pMeta->pCache->sStbStatsCache.nEntry = 0; + pMeta->pCache->sStbStatsCache.nBucket = META_CACHE_STATS_BUCKET; + pMeta->pCache->sStbStatsCache.aBucket = + (SMetaStbStatsEntry**)taosMemoryCalloc(pMeta->pCache->sStbStatsCache.nBucket, sizeof(SMetaStbStatsEntry*)); + if (pMeta->pCache->sStbStatsCache.aBucket == NULL) { + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } - pCache->sTagFilterResCache.pUidResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5); - if (pCache->sTagFilterResCache.pUidResCache == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + pMeta->pCache->sTagFilterResCache.pUidResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5); + if (pMeta->pCache->sTagFilterResCache.pUidResCache == NULL) { + TSDB_CHECK_CODE(code = terrno, lino, _exit); } - pCache->sTagFilterResCache.accTimes = 0; - pCache->sTagFilterResCache.pTableEntry = + pMeta->pCache->sTagFilterResCache.accTimes = 0; + pMeta->pCache->sTagFilterResCache.pTableEntry = taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK); - if (pCache->sTagFilterResCache.pTableEntry == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + if (pMeta->pCache->sTagFilterResCache.pTableEntry == NULL) { + TSDB_CHECK_CODE(code = terrno, lino, _exit); } - taosHashSetFreeFp(pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp); - taosThreadMutexInit(&pCache->sTagFilterResCache.lock, NULL); + taosHashSetFreeFp(pMeta->pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp); + taosThreadMutexInit(&pMeta->pCache->sTagFilterResCache.lock, NULL); - pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5); - if (pCache->STbGroupResCache.pResCache == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + pMeta->pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5); + if (pMeta->pCache->STbGroupResCache.pResCache == NULL) { + TSDB_CHECK_CODE(code = terrno, lino, _exit); } - pCache->STbGroupResCache.accTimes = 0; - pCache->STbGroupResCache.pTableEntry = + pMeta->pCache->STbGroupResCache.accTimes = 0; + pMeta->pCache->STbGroupResCache.pTableEntry = taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK); - if (pCache->STbGroupResCache.pTableEntry == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + if (pMeta->pCache->STbGroupResCache.pTableEntry == NULL) { + TSDB_CHECK_CODE(code = terrno, lino, _exit); } - taosHashSetFreeFp(pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp); - taosThreadMutexInit(&pCache->STbGroupResCache.lock, NULL); + taosHashSetFreeFp(pMeta->pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp); + taosThreadMutexInit(&pMeta->pCache->STbGroupResCache.lock, NULL); - pCache->STbFilterCache.pStb = taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); - if (pCache->STbFilterCache.pStb == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + pMeta->pCache->STbFilterCache.pStb = + taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + if (pMeta->pCache->STbFilterCache.pStb == NULL) { + TSDB_CHECK_CODE(code = terrno, lino, _exit); } - pCache->STbFilterCache.pStbName = + pMeta->pCache->STbFilterCache.pStbName = taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK); - if (pCache->STbFilterCache.pStbName == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + if (pMeta->pCache->STbFilterCache.pStbName == NULL) { + TSDB_CHECK_CODE(code = terrno, lino, _exit); } - pMeta->pCache = pCache; - return code; - -_err2: - entryCacheClose(pMeta); - -_err: - taosMemoryFree(pCache); - metaError("vgId:%d, meta open cache failed since %s", TD_VID(pMeta->pVnode), tstrerror(code)); +_exit: + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code)); + metaCacheClose(pMeta); + } else { + metaDebug("vgId:%d, %s success", TD_VID(pMeta->pVnode), __func__); + } return code; } @@ -289,8 +279,7 @@ int32_t metaCacheUpsert(SMeta* pMeta, SMetaInfo* pInfo) { } } else { // insert if (pCache->sEntryCache.nEntry >= pCache->sEntryCache.nBucket) { - code = metaRehashCache(pCache, 1); - if (code) goto _exit; + TAOS_UNUSED(metaRehashCache(pCache, 1)); iBucket = TABS(pInfo->uid) % pCache->sEntryCache.nBucket; } @@ -328,8 +317,7 @@ int32_t metaCacheDrop(SMeta* pMeta, int64_t uid) { pCache->sEntryCache.nEntry--; if (pCache->sEntryCache.nEntry < pCache->sEntryCache.nBucket / 4 && pCache->sEntryCache.nBucket > META_CACHE_BASE_BUCKET) { - code = metaRehashCache(pCache, 0); - if (code) goto _exit; + TAOS_UNUSED(metaRehashCache(pCache, 0)); } } else { code = TSDB_CODE_NOT_FOUND; @@ -351,7 +339,9 @@ int32_t metaCacheGet(SMeta* pMeta, int64_t uid, SMetaInfo* pInfo) { } if (pEntry) { - *pInfo = pEntry->info; + if (pInfo) { + *pInfo = pEntry->info; + } } else { code = TSDB_CODE_NOT_FOUND; } @@ -415,9 +405,7 @@ int32_t metaStatsCacheUpsert(SMeta* pMeta, SMetaStbStats* pInfo) { (*ppEntry)->info.ctbNum = pInfo->ctbNum; } else { // insert if (pCache->sStbStatsCache.nEntry >= pCache->sStbStatsCache.nBucket) { - code = metaRehashStatsCache(pCache, 1); - if (code) goto _exit; - + TAOS_UNUSED(metaRehashStatsCache(pCache, 1)); iBucket = TABS(pInfo->uid) % pCache->sStbStatsCache.nBucket; } @@ -454,8 +442,7 @@ int32_t metaStatsCacheDrop(SMeta* pMeta, int64_t uid) { pCache->sStbStatsCache.nEntry--; if (pCache->sStbStatsCache.nEntry < pCache->sStbStatsCache.nBucket / 4 && pCache->sStbStatsCache.nBucket > META_CACHE_STATS_BUCKET) { - code = metaRehashStatsCache(pCache, 0); - if (code) goto _exit; + TAOS_UNUSED(metaRehashStatsCache(pCache, 0)); } } else { code = TSDB_CODE_NOT_FOUND; @@ -477,7 +464,9 @@ int32_t metaStatsCacheGet(SMeta* pMeta, int64_t uid, SMetaStbStats* pInfo) { } if (pEntry) { - *pInfo = pEntry->info; + if (pInfo) { + *pInfo = pEntry->info; + } } else { code = TSDB_CODE_NOT_FOUND; } @@ -502,7 +491,9 @@ static int checkAllEntriesInCache(const STagFilterResEntry* pEntry, SArray* pInv // check whether it is existed in LRU cache, and remove it from linked list if not. LRUHandle* pRes = taosLRUCacheLookup(pCache, buf, len); if (pRes == NULL) { // remove the item in the linked list - taosArrayPush(pInvalidRes, &pNode); + if (taosArrayPush(pInvalidRes, &pNode) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } else { taosLRUCacheRelease(pCache, pRes, false); } @@ -626,7 +617,7 @@ static int32_t addNewEntry(SHashObj* pTableEntry, const void* pKey, int32_t keyL p->hitTimes = 0; tdListInit(&p->list, keyLen); - taosHashPut(pTableEntry, &suid, sizeof(uint64_t), &p, POINTER_BYTES); + TAOS_CHECK_RETURN(taosHashPut(pTableEntry, &suid, sizeof(uint64_t), &p, POINTER_BYTES)); tdListAppend(&p->list, pKey); return 0; } @@ -956,9 +947,7 @@ int32_t metaInitTbFilterCache(SMeta* pMeta) { } if (tbNum && pTbArr) { for (int32_t i = 0; i < tbNum; ++i) { - if (metaPutTbToFilterCache(pMeta, pTbArr[i], 1) != 0) { - return terrno ? terrno : -1; - } + TAOS_CHECK_RETURN(metaPutTbToFilterCache(pMeta, pTbArr[i], 1)); } } #else diff --git a/source/dnode/vnode/src/meta/metaCommit.c b/source/dnode/vnode/src/meta/metaCommit.c index f8b41e413b..bbf2217b31 100644 --- a/source/dnode/vnode/src/meta/metaCommit.c +++ b/source/dnode/vnode/src/meta/metaCommit.c @@ -21,7 +21,10 @@ static FORCE_INLINE void *metaMalloc(void *pPool, size_t size) { static FORCE_INLINE void metaFree(void *pPool, void *p) { vnodeBufPoolFree((SVBufPool *)pPool, p); } // begin a meta txn -int metaBegin(SMeta *pMeta, int8_t heap) { +int32_t metaBegin(SMeta *pMeta, int8_t heap) { + int32_t code = 0; + int32_t lino; + void *(*xMalloc)(void *, size_t) = NULL; void (*xFree)(void *, void *) = NULL; void *xArg = NULL; @@ -36,12 +39,19 @@ int metaBegin(SMeta *pMeta, int8_t heap) { xArg = pMeta->pVnode->inUse; } - if (tdbBegin(pMeta->pEnv, &pMeta->txn, xMalloc, xFree, xArg, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) < 0) { - return -1; + code = tdbBegin(pMeta->pEnv, &pMeta->txn, xMalloc, xFree, xArg, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tdbCommit(pMeta->pEnv, pMeta->txn); + TSDB_CHECK_CODE(code, lino, _exit); + +_exit: + if (code) { + metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, + tstrerror(terrno)); + } else { + metaDebug("vgId:%d %s success", TD_VID(pMeta->pVnode), __func__); } - - tdbCommit(pMeta->pEnv, pMeta->txn); - return 0; } @@ -49,20 +59,36 @@ int metaBegin(SMeta *pMeta, int8_t heap) { TXN *metaGetTxn(SMeta *pMeta) { return pMeta->txn; } int metaCommit(SMeta *pMeta, TXN *txn) { return tdbCommit(pMeta->pEnv, txn); } int metaFinishCommit(SMeta *pMeta, TXN *txn) { return tdbPostCommit(pMeta->pEnv, txn); } -int metaPrepareAsyncCommit(SMeta *pMeta) { - // return tdbPrepareAsyncCommit(pMeta->pEnv, pMeta->txn); - int code = 0; + +int metaPrepareAsyncCommit(SMeta *pMeta) { + // return tdbPrepareAsyncCommit(pMeta->pEnv, pMeta->txn); + int code = 0; + int32_t lino; + metaWLock(pMeta); - code = ttlMgrFlush(pMeta->pTtlMgr, pMeta->txn); + TAOS_UNUSED(ttlMgrFlush(pMeta->pTtlMgr, pMeta->txn)); metaULock(pMeta); + code = tdbCommit(pMeta->pEnv, pMeta->txn); + TSDB_CHECK_CODE(code, lino, _exit); pMeta->changed = false; + +_exit: + if (code) { + metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, + tstrerror(terrno)); + } else { + metaDebug("vgId:%d %s success", TD_VID(pMeta->pVnode), __func__); + } return code; } // abort the meta txn int metaAbort(SMeta *pMeta) { - if (!pMeta->txn) return 0; + if (!pMeta->txn) { + return 0; + } + int code = tdbAbort(pMeta->pEnv, pMeta->txn); if (code) { metaError("vgId:%d, failed to abort meta since %s", TD_VID(pMeta->pVnode), tstrerror(terrno)); diff --git a/source/dnode/vnode/src/meta/metaEntry.c b/source/dnode/vnode/src/meta/metaEntry.c index 9a111ae2d4..6e94cca390 100644 --- a/source/dnode/vnode/src/meta/metaEntry.c +++ b/source/dnode/vnode/src/meta/metaEntry.c @@ -17,159 +17,166 @@ int meteEncodeColCmprEntry(SEncoder *pCoder, const SMetaEntry *pME) { const SColCmprWrapper *pw = &pME->colCmpr; - if (tEncodeI32v(pCoder, pw->nCols) < 0) return -1; - if (tEncodeI32v(pCoder, pw->version) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->nCols)); + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->version)); uDebug("encode cols:%d", pw->nCols); for (int32_t i = 0; i < pw->nCols; i++) { SColCmpr *p = &pw->pColCmpr[i]; - if (tEncodeI16v(pCoder, p->id) < 0) return -1; - if (tEncodeU32(pCoder, p->alg) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI16v(pCoder, p->id)); + TAOS_CHECK_RETURN(tEncodeU32(pCoder, p->alg)); } return 0; } int meteDecodeColCmprEntry(SDecoder *pDecoder, SMetaEntry *pME) { SColCmprWrapper *pWrapper = &pME->colCmpr; - if (tDecodeI32v(pDecoder, &pWrapper->nCols) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->nCols)); if (pWrapper->nCols == 0) { return 0; } - if (tDecodeI32v(pDecoder, &pWrapper->version) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->version)); uDebug("dencode cols:%d", pWrapper->nCols); pWrapper->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pWrapper->nCols * sizeof(SColCmpr)); - if (pWrapper->pColCmpr == NULL) return -1; + if (pWrapper->pColCmpr == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int i = 0; i < pWrapper->nCols; i++) { SColCmpr *p = &pWrapper->pColCmpr[i]; - if (tDecodeI16v(pDecoder, &p->id) < 0) return -1; - if (tDecodeU32(pDecoder, &p->alg) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI16v(pDecoder, &p->id)); + TAOS_CHECK_RETURN(tDecodeU32(pDecoder, &p->alg)); } return 0; } -static FORCE_INLINE void metatInitDefaultSColCmprWrapper(SDecoder *pDecoder, SColCmprWrapper *pCmpr, - SSchemaWrapper *pSchema) { +static FORCE_INLINE int32_t metatInitDefaultSColCmprWrapper(SDecoder *pDecoder, SColCmprWrapper *pCmpr, + SSchemaWrapper *pSchema) { pCmpr->nCols = pSchema->nCols; - pCmpr->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pCmpr->nCols * sizeof(SColCmpr)); + if ((pCmpr->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pCmpr->nCols * sizeof(SColCmpr))) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + for (int32_t i = 0; i < pCmpr->nCols; i++) { SColCmpr *pColCmpr = &pCmpr->pColCmpr[i]; SSchema *pColSchema = &pSchema->pSchema[i]; pColCmpr->id = pColSchema->colId; pColCmpr->alg = createDefaultColCmprByType(pColSchema->type); } + return 0; } int metaEncodeEntry(SEncoder *pCoder, const SMetaEntry *pME) { - if (tStartEncode(pCoder) < 0) return -1; + TAOS_CHECK_RETURN(tStartEncode(pCoder)); + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->version)); + TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->type)); + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->uid)); - if (tEncodeI64(pCoder, pME->version) < 0) return -1; - if (tEncodeI8(pCoder, pME->type) < 0) return -1; - if (tEncodeI64(pCoder, pME->uid) < 0) return -1; - if (pME->name == NULL || tEncodeCStr(pCoder, pME->name) < 0) return -1; + if (pME->name == NULL) { + return TSDB_CODE_INVALID_PARA; + } + + TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->name)); if (pME->type == TSDB_SUPER_TABLE) { - if (tEncodeI8(pCoder, pME->flags) < 0) return -1; // TODO: need refactor? - if (tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow) < 0) return -1; - if (tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->flags)); + TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow)); + TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag)); if (TABLE_IS_ROLLUP(pME->flags)) { - if (tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam)); } } else if (pME->type == TSDB_CHILD_TABLE) { - if (tEncodeI64(pCoder, pME->ctbEntry.btime) < 0) return -1; - if (tEncodeI32(pCoder, pME->ctbEntry.ttlDays) < 0) return -1; - if (tEncodeI32v(pCoder, pME->ctbEntry.commentLen) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.btime)); + TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ctbEntry.ttlDays)); + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ctbEntry.commentLen)); if (pME->ctbEntry.commentLen > 0) { - if (tEncodeCStr(pCoder, pME->ctbEntry.comment) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ctbEntry.comment)); } - if (tEncodeI64(pCoder, pME->ctbEntry.suid) < 0) return -1; - if (tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.suid)); + TAOS_CHECK_RETURN(tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags)); } else if (pME->type == TSDB_NORMAL_TABLE) { - if (tEncodeI64(pCoder, pME->ntbEntry.btime) < 0) return -1; - if (tEncodeI32(pCoder, pME->ntbEntry.ttlDays) < 0) return -1; - if (tEncodeI32v(pCoder, pME->ntbEntry.commentLen) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ntbEntry.btime)); + TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ntbEntry.ttlDays)); + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.commentLen)); if (pME->ntbEntry.commentLen > 0) { - if (tEncodeCStr(pCoder, pME->ntbEntry.comment) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ntbEntry.comment)); } - if (tEncodeI32v(pCoder, pME->ntbEntry.ncid) < 0) return -1; - if (tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.ncid)); + TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow)); } else if (pME->type == TSDB_TSMA_TABLE) { - if (tEncodeTSma(pCoder, pME->smaEntry.tsma) < 0) return -1; + TAOS_CHECK_RETURN(tEncodeTSma(pCoder, pME->smaEntry.tsma)); } else { metaError("meta/entry: invalide table type: %" PRId8 " encode failed.", pME->type); - - return -1; + return TSDB_CODE_INVALID_PARA; } - if (meteEncodeColCmprEntry(pCoder, pME) < 0) return -1; + TAOS_CHECK_RETURN(meteEncodeColCmprEntry(pCoder, pME)); tEndEncode(pCoder); return 0; } int metaDecodeEntry(SDecoder *pCoder, SMetaEntry *pME) { - if (tStartDecode(pCoder) < 0) return -1; - - if (tDecodeI64(pCoder, &pME->version) < 0) return -1; - if (tDecodeI8(pCoder, &pME->type) < 0) return -1; - if (tDecodeI64(pCoder, &pME->uid) < 0) return -1; - if (tDecodeCStr(pCoder, &pME->name) < 0) return -1; + TAOS_CHECK_RETURN(tStartDecode(pCoder)); + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->version)); + TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->type)); + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->uid)); + TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->name)); if (pME->type == TSDB_SUPER_TABLE) { - if (tDecodeI8(pCoder, &pME->flags) < 0) return -1; // TODO: need refactor? - if (tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow) < 0) return -1; - if (tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->flags)); + TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow)); + TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag)); if (TABLE_IS_ROLLUP(pME->flags)) { - if (tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam)); } } else if (pME->type == TSDB_CHILD_TABLE) { - if (tDecodeI64(pCoder, &pME->ctbEntry.btime) < 0) return -1; - if (tDecodeI32(pCoder, &pME->ctbEntry.ttlDays) < 0) return -1; - if (tDecodeI32v(pCoder, &pME->ctbEntry.commentLen) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.btime)); + TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ctbEntry.ttlDays)); + TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ctbEntry.commentLen)); if (pME->ctbEntry.commentLen > 0) { - if (tDecodeCStr(pCoder, &pME->ctbEntry.comment) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ctbEntry.comment)); } - if (tDecodeI64(pCoder, &pME->ctbEntry.suid) < 0) return -1; - if (tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags) < 0) return -1; // (TODO) + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.suid)); + TAOS_CHECK_RETURN(tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags)); } else if (pME->type == TSDB_NORMAL_TABLE) { - if (tDecodeI64(pCoder, &pME->ntbEntry.btime) < 0) return -1; - if (tDecodeI32(pCoder, &pME->ntbEntry.ttlDays) < 0) return -1; - if (tDecodeI32v(pCoder, &pME->ntbEntry.commentLen) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ntbEntry.btime)); + TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ntbEntry.ttlDays)); + TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.commentLen)); if (pME->ntbEntry.commentLen > 0) { - if (tDecodeCStr(pCoder, &pME->ntbEntry.comment) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ntbEntry.comment)); } - if (tDecodeI32v(pCoder, &pME->ntbEntry.ncid) < 0) return -1; - if (tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.ncid)); + TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow)); } else if (pME->type == TSDB_TSMA_TABLE) { pME->smaEntry.tsma = tDecoderMalloc(pCoder, sizeof(STSma)); if (!pME->smaEntry.tsma) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } - if (tDecodeTSma(pCoder, pME->smaEntry.tsma, true) < 0) return -1; + TAOS_CHECK_RETURN(tDecodeTSma(pCoder, pME->smaEntry.tsma, true)); } else { metaError("meta/entry: invalide table type: %" PRId8 " decode failed.", pME->type); - return -1; + return TSDB_CODE_INVALID_PARA; } if (pME->type == TSDB_SUPER_TABLE) { if (TABLE_IS_COL_COMPRESSED(pME->flags)) { - if (meteDecodeColCmprEntry(pCoder, pME) < 0) return -1; + TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME)); if (pME->colCmpr.nCols == 0) { - metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow); + TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow)); } } else { - metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow); + TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow)); TABLE_SET_COL_COMPRESSED(pME->flags); } } else if (pME->type == TSDB_NORMAL_TABLE) { if (!tDecodeIsEnd(pCoder)) { uDebug("set type: %d, tableName:%s", pME->type, pME->name); - if (meteDecodeColCmprEntry(pCoder, pME) < 0) return -1; + TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME)); if (pME->colCmpr.nCols == 0) { - metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow); + TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow)); } } else { uDebug("set default type: %d, tableName:%s", pME->type, pME->name); - metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow); + TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow)); } TABLE_SET_COL_COMPRESSED(pME->flags); } diff --git a/source/dnode/vnode/src/meta/metaIdx.c b/source/dnode/vnode/src/meta/metaIdx.c deleted file mode 100644 index dc62ab2b9f..0000000000 --- a/source/dnode/vnode/src/meta/metaIdx.c +++ /dev/null @@ -1,118 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#ifdef USE_INVERTED_INDEX -#include "index.h" -#endif -#include "meta.h" - -struct SMetaIdx { -#ifdef USE_INVERTED_INDEX - SIndex *pIdx; -#endif - /* data */ -#ifdef WINDOWS - size_t avoidCompilationErrors; -#endif -}; - -int metaOpenIdx(SMeta *pMeta) { -#if 0 - char idxDir[128]; // TODO - char * err = NULL; - rocksdb_options_t *options = rocksdb_options_create(); - - // TODO - sprintf(idxDir, "%s/index", pMeta->path); - - if (pMeta->pCache) { - rocksdb_options_set_row_cache(options, pMeta->pCache); - } - rocksdb_options_set_create_if_missing(options, 1); - - pMeta->pIdx = rocksdb_open(options, idxDir, &err); - if (pMeta->pIdx == NULL) { - // TODO: handle error - rocksdb_options_destroy(options); - return -1; - } - - rocksdb_options_destroy(options); -#endif - -#ifdef USE_INVERTED_INDEX - // SIndexOpts opts; - // if (indexOpen(&opts, pMeta->path, &pMeta->pIdx->pIdx) != 0) { - // return -1; - //} - -#endif - return 0; -} - -#ifdef BUILD_NO_CALL -void metaCloseIdx(SMeta *pMeta) { /* TODO */ -#if 0 - if (pMeta->pIdx) { - rocksdb_close(pMeta->pIdx); - pMeta->pIdx = NULL; - } -#endif - -#ifdef USE_INVERTED_INDEX - // SIndexOpts opts; - // if (indexClose(pMeta->pIdx->pIdx) != 0) { - // return -1; - //} - // return 0; - -#endif -} - -int metaSaveTableToIdx(SMeta *pMeta, const STbCfg *pTbCfg) { -#ifdef USE_INVERTED_INDEX - // if (pTbCfgs->type == META_CHILD_TABLE) { - // char buf[8] = {0}; - // int16_t colId = (kvRowColIdx(pTbCfg->ctbCfg.pTag))[0].colId; - // sprintf(buf, "%d", colId); // colname - - // char *pTagVal = (char *)tdGetKVRowValOfCol(pTbCfg->ctbCfg.pTag, (kvRowColIdx(pTbCfg->ctbCfg.pTag))[0].colId); - - // tb_uid_t suid = pTbCfg->ctbCfg.suid; // super id - // tb_uid_t tuid = 0; // child table uid - // SIndexMultiTerm *terms = indexMultiTermCreate(); - // SIndexTerm *term = - // indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_BINARY, buf, strlen(buf), pTagVal, strlen(pTagVal), tuid); - // indexMultiTermAdd(terms, term); - - // int ret = indexPut(pMeta->pIdx->pIdx, terms); - // indexMultiTermDestroy(terms); - // return ret; - //} else { - // return DB_DONOTINDEX; - //} -#endif - // TODO - return 0; -} - -int metaRemoveTableFromIdx(SMeta *pMeta, tb_uid_t uid) { -#ifdef USE_INVERTED_INDEX - -#endif - // TODO - return 0; -} -#endif \ No newline at end of file diff --git a/source/dnode/vnode/src/meta/metaOpen.c b/source/dnode/vnode/src/meta/metaOpen.c index e3b3de6cd6..ec26e94c5a 100644 --- a/source/dnode/vnode/src/meta/metaOpen.c +++ b/source/dnode/vnode/src/meta/metaOpen.c @@ -39,13 +39,13 @@ static int32_t metaDestroyLock(SMeta *pMeta) { return taosThreadRwlockDestroy(&p static void metaCleanup(SMeta **ppMeta); -int metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) { - SMeta *pMeta = NULL; - int ret; - int offset; - char path[TSDB_FILENAME_LEN] = {0}; - - *ppMeta = NULL; +int32_t metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) { + SMeta *pMeta = NULL; + int32_t code = 0; + int32_t lino; + int32_t offset; + char path[TSDB_FILENAME_LEN] = {0}; + char indexFullPath[128] = {0}; // create handle vnodeGetPrimaryDir(pVnode->path, pVnode->diskPrimary, pVnode->pTfs, path, TSDB_FILENAME_LEN); @@ -53,8 +53,7 @@ int metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) { snprintf(path + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VNODE_META_DIR); if ((pMeta = taosMemoryCalloc(1, sizeof(*pMeta) + strlen(path) + 1)) == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } metaInitLock(pMeta); @@ -69,163 +68,104 @@ int metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) { taosMkDir(pMeta->path); // open env - ret = tdbOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv, rollback, - pVnode->config.tdbEncryptAlgorithm, pVnode->config.tdbEncryptKey); - if (ret < 0) { - metaError("vgId:%d, failed to open meta env since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv, rollback, + pVnode->config.tdbEncryptAlgorithm, pVnode->config.tdbEncryptKey); + TSDB_CHECK_CODE(code, lino, _exit); // open pTbDb - ret = tdbTbOpen("table.db", sizeof(STbDbKey), -1, tbDbKeyCmpr, pMeta->pEnv, &pMeta->pTbDb, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta table db since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("table.db", sizeof(STbDbKey), -1, tbDbKeyCmpr, pMeta->pEnv, &pMeta->pTbDb, 0); + TSDB_CHECK_CODE(code, lino, _exit); // open pSkmDb - ret = tdbTbOpen("schema.db", sizeof(SSkmDbKey), -1, skmDbKeyCmpr, pMeta->pEnv, &pMeta->pSkmDb, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta schema db since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("schema.db", sizeof(SSkmDbKey), -1, skmDbKeyCmpr, pMeta->pEnv, &pMeta->pSkmDb, 0); + TSDB_CHECK_CODE(code, lino, _exit); // open pUidIdx - ret = tdbTbOpen("uid.idx", sizeof(tb_uid_t), sizeof(SUidIdxVal), uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pUidIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta uid idx since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("uid.idx", sizeof(tb_uid_t), sizeof(SUidIdxVal), uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pUidIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); // open pNameIdx - ret = tdbTbOpen("name.idx", -1, sizeof(tb_uid_t), NULL, pMeta->pEnv, &pMeta->pNameIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta name index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("name.idx", -1, sizeof(tb_uid_t), NULL, pMeta->pEnv, &pMeta->pNameIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); // open pCtbIdx - ret = tdbTbOpen("ctb.idx", sizeof(SCtbIdxKey), -1, ctbIdxKeyCmpr, pMeta->pEnv, &pMeta->pCtbIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta child table index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("ctb.idx", sizeof(SCtbIdxKey), -1, ctbIdxKeyCmpr, pMeta->pEnv, &pMeta->pCtbIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); // open pSuidIdx - ret = tdbTbOpen("suid.idx", sizeof(tb_uid_t), 0, uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pSuidIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta super table index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("suid.idx", sizeof(tb_uid_t), 0, uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pSuidIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); - char indexFullPath[128] = {0}; sprintf(indexFullPath, "%s/%s", pMeta->path, "invert"); - taosMkDir(indexFullPath); + TAOS_UNUSED(taosMkDir(indexFullPath)); SIndexOpts opts = {.cacheSize = 8 * 1024 * 1024}; - ret = indexOpen(&opts, indexFullPath, (SIndex **)&pMeta->pTagIvtIdx); - if (ret < 0) { - metaError("vgId:%d, failed to open meta tag index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = indexOpen(&opts, indexFullPath, (SIndex **)&pMeta->pTagIvtIdx); + TSDB_CHECK_CODE(code, lino, _exit); - ret = tdbTbOpen("tag.idx", -1, 0, tagIdxKeyCmpr, pMeta->pEnv, &pMeta->pTagIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta tag index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("tag.idx", -1, 0, tagIdxKeyCmpr, pMeta->pEnv, &pMeta->pTagIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); // open pTtlMgr ("ttlv1.idx") char logPrefix[128] = {0}; sprintf(logPrefix, "vgId:%d", TD_VID(pVnode)); - ret = ttlMgrOpen(&pMeta->pTtlMgr, pMeta->pEnv, 0, logPrefix, tsTtlFlushThreshold); - if (ret < 0) { - metaError("vgId:%d, failed to open meta ttl index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = ttlMgrOpen(&pMeta->pTtlMgr, pMeta->pEnv, 0, logPrefix, tsTtlFlushThreshold); + TSDB_CHECK_CODE(code, lino, _exit); // open pSmaIdx - ret = tdbTbOpen("sma.idx", sizeof(SSmaIdxKey), 0, smaIdxKeyCmpr, pMeta->pEnv, &pMeta->pSmaIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta sma index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("sma.idx", sizeof(SSmaIdxKey), 0, smaIdxKeyCmpr, pMeta->pEnv, &pMeta->pSmaIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); // idx table create time - ret = tdbTbOpen("ctime.idx", sizeof(SBtimeIdxKey), 0, btimeIdxCmpr, pMeta->pEnv, &pMeta->pBtimeIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta ctime index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("ctime.idx", sizeof(SBtimeIdxKey), 0, btimeIdxCmpr, pMeta->pEnv, &pMeta->pBtimeIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); // idx num of col, normal table only - ret = tdbTbOpen("ncol.idx", sizeof(SNcolIdxKey), 0, ncolIdxCmpr, pMeta->pEnv, &pMeta->pNcolIdx, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta ncol index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("ncol.idx", sizeof(SNcolIdxKey), 0, ncolIdxCmpr, pMeta->pEnv, &pMeta->pNcolIdx, 0); + TSDB_CHECK_CODE(code, lino, _exit); - ret = tdbTbOpen("stream.task.db", sizeof(int64_t), -1, taskIdxKeyCmpr, pMeta->pEnv, &pMeta->pStreamDb, 0); - if (ret < 0) { - metaError("vgId:%d, failed to open meta stream task index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = tdbTbOpen("stream.task.db", sizeof(int64_t), -1, taskIdxKeyCmpr, pMeta->pEnv, &pMeta->pStreamDb, 0); + TSDB_CHECK_CODE(code, lino, _exit); - // open index - if (metaOpenIdx(pMeta) < 0) { - metaError("vgId:%d, failed to open meta index since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + code = metaCacheOpen(pMeta); + TSDB_CHECK_CODE(code, lino, _exit); - int32_t code = metaCacheOpen(pMeta); + code = metaInitTbFilterCache(pMeta); + TSDB_CHECK_CODE(code, lino, _exit); + +_exit: if (code) { - terrno = code; - metaError("vgId:%d, failed to open meta cache since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; + metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, __LINE__, tstrerror(code)); + metaCleanup(&pMeta); + *ppMeta = NULL; + } else { + metaDebug("vgId:%d %s success", TD_VID(pVnode), __func__); + *ppMeta = pMeta; } - - if (metaInitTbFilterCache(pMeta) != 0) { - goto _err; - } - - metaDebug("vgId:%d, meta is opened", TD_VID(pVnode)); - - *ppMeta = pMeta; - return 0; - -_err: - metaCleanup(&pMeta); - return -1; + return code; } -int metaUpgrade(SVnode *pVnode, SMeta **ppMeta) { - int code = TSDB_CODE_SUCCESS; - SMeta *pMeta = *ppMeta; +int32_t metaUpgrade(SVnode *pVnode, SMeta **ppMeta) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino; + SMeta *pMeta = *ppMeta; if (ttlMgrNeedUpgrade(pMeta->pEnv)) { code = metaBegin(pMeta, META_BEGIN_HEAP_OS); - if (code < 0) { - metaError("vgId:%d, failed to upgrade meta, meta begin failed since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + TSDB_CHECK_CODE(code, lino, _exit); code = ttlMgrUpgrade(pMeta->pTtlMgr, pMeta); - if (code < 0) { - metaError("vgId:%d, failed to upgrade meta ttl since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + TSDB_CHECK_CODE(code, lino, _exit); code = metaCommit(pMeta, pMeta->txn); - if (code < 0) { - metaError("vgId:%d, failed to upgrade meta ttl, meta commit failed since %s", TD_VID(pVnode), tstrerror(terrno)); - goto _err; - } + TSDB_CHECK_CODE(code, lino, _exit); } - return TSDB_CODE_SUCCESS; - -_err: - metaCleanup(ppMeta); +_exit: + if (code) { + metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, __LINE__, tstrerror(code)); + metaCleanup(ppMeta); + } return code; } @@ -235,33 +175,42 @@ int metaClose(SMeta **ppMeta) { } int metaAlterCache(SMeta *pMeta, int32_t nPage) { + int32_t code = 0; metaWLock(pMeta); - - if (tdbAlter(pMeta->pEnv, nPage) < 0) { - metaULock(pMeta); - return -1; - } - + code = tdbAlter(pMeta->pEnv, nPage); metaULock(pMeta); - return 0; + + if (code) { + metaError("vgId:%d %s failed since %s", TD_VID(pMeta->pVnode), __func__, tstrerror(code)); + } + return code; } int32_t metaRLock(SMeta *pMeta) { metaTrace("meta rlock %p", &pMeta->lock); - int32_t ret = taosThreadRwlockRdlock(&pMeta->lock); - return ret; + int32_t code = taosThreadRwlockRdlock(&pMeta->lock); + if (code) { + return TAOS_SYSTEM_ERROR(code); + } + return 0; } int32_t metaWLock(SMeta *pMeta) { metaTrace("meta wlock %p", &pMeta->lock); - int32_t ret = taosThreadRwlockWrlock(&pMeta->lock); - return ret; + int32_t code = taosThreadRwlockWrlock(&pMeta->lock); + if (code) { + return TAOS_SYSTEM_ERROR(code); + } + return 0; } int32_t metaULock(SMeta *pMeta) { metaTrace("meta ulock %p", &pMeta->lock); - int32_t ret = taosThreadRwlockUnlock(&pMeta->lock); - return ret; + int32_t code = taosThreadRwlockUnlock(&pMeta->lock); + if (code) { + return TAOS_SYSTEM_ERROR(code); + } + return 0; } static void metaCleanup(SMeta **ppMeta) { diff --git a/source/dnode/vnode/src/meta/metaSnapshot.c b/source/dnode/vnode/src/meta/metaSnapshot.c index 34d4f8e845..95c65e5e80 100644 --- a/source/dnode/vnode/src/meta/metaSnapshot.c +++ b/source/dnode/vnode/src/meta/metaSnapshot.c @@ -25,14 +25,14 @@ struct SMetaSnapReader { int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapReader** ppReader) { int32_t code = 0; + int32_t lino; int32_t c = 0; SMetaSnapReader* pReader = NULL; // alloc pReader = (SMetaSnapReader*)taosMemoryCalloc(1, sizeof(*pReader)); if (pReader == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } pReader->pMeta = pMeta; pReader->sver = sver; @@ -40,36 +40,29 @@ int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapRe // impl code = tdbTbcOpen(pMeta->pTbDb, &pReader->pTbc, NULL); - if (code) { - taosMemoryFree(pReader); - goto _err; - } + TSDB_CHECK_CODE(code, lino, _exit); code = tdbTbcMoveTo(pReader->pTbc, &(STbDbKey){.version = sver, .uid = INT64_MIN}, sizeof(STbDbKey), &c); + TSDB_CHECK_CODE(code, lino, _exit); + +_exit: if (code) { - taosMemoryFree(pReader); - goto _err; + metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code)); + metaSnapReaderClose(&pReader); + *ppReader = NULL; + } else { + metaInfo("vgId:%d, %s success", TD_VID(pMeta->pVnode), __func__); + *ppReader = pReader; } - - metaInfo("vgId:%d, vnode snapshot meta reader opened", TD_VID(pMeta->pVnode)); - - *ppReader = pReader; - return code; - -_err: - metaError("vgId:%d, vnode snapshot meta reader open failed since %s", TD_VID(pMeta->pVnode), tstrerror(code)); - *ppReader = NULL; return code; } -int32_t metaSnapReaderClose(SMetaSnapReader** ppReader) { - int32_t code = 0; - - tdbTbcClose((*ppReader)->pTbc); - taosMemoryFree(*ppReader); - *ppReader = NULL; - - return code; +void metaSnapReaderClose(SMetaSnapReader** ppReader) { + if (ppReader && *ppReader) { + tdbTbcClose((*ppReader)->pTbc); + taosMemoryFree(*ppReader); + *ppReader = NULL; + } } int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { @@ -106,7 +99,7 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { *ppData = taosMemoryMalloc(sizeof(SSnapDataHdr) + nData); if (*ppData == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + goto _exit; } SSnapDataHdr* pHdr = (SSnapDataHdr*)(*ppData); @@ -122,10 +115,10 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { } _exit: - return code; - -_err: - metaError("vgId:%d, vnode snapshot meta read data failed since %s", TD_VID(pReader->pMeta->pVnode), tstrerror(code)); + if (code) { + metaError("vgId:%d, vnode snapshot meta read data failed since %s", TD_VID(pReader->pMeta->pVnode), + tstrerror(code)); + } return code; } @@ -138,26 +131,30 @@ struct SMetaSnapWriter { int32_t metaSnapWriterOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapWriter** ppWriter) { int32_t code = 0; + int32_t lino; SMetaSnapWriter* pWriter; // alloc pWriter = (SMetaSnapWriter*)taosMemoryCalloc(1, sizeof(*pWriter)); if (pWriter == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } pWriter->pMeta = pMeta; pWriter->sver = sver; pWriter->ever = ever; - metaBegin(pMeta, META_BEGIN_HEAP_NIL); + code = metaBegin(pMeta, META_BEGIN_HEAP_NIL); + TSDB_CHECK_CODE(code, lino, _exit); - *ppWriter = pWriter; - return code; - -_err: - metaError("vgId:%d, meta snapshot writer open failed since %s", TD_VID(pMeta->pVnode), tstrerror(code)); - *ppWriter = NULL; +_exit: + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code)); + taosMemoryFree(pWriter); + *ppWriter = NULL; + } else { + metaDebug("vgId:%d, %s success", TD_VID(pMeta->pVnode), __func__); + *ppWriter = pWriter; + } return code; } @@ -189,25 +186,24 @@ _err: int32_t metaSnapWrite(SMetaSnapWriter* pWriter, uint8_t* pData, uint32_t nData) { int32_t code = 0; - int32_t line = 0; + int32_t lino = 0; SMeta* pMeta = pWriter->pMeta; SMetaEntry metaEntry = {0}; SDecoder* pDecoder = &(SDecoder){0}; tDecoderInit(pDecoder, pData + sizeof(SSnapDataHdr), nData - sizeof(SSnapDataHdr)); code = metaDecodeEntry(pDecoder, &metaEntry); - VND_CHECK_CODE(code, line, _err); + TSDB_CHECK_CODE(code, lino, _exit); code = metaHandleEntry(pMeta, &metaEntry); - VND_CHECK_CODE(code, line, _err); + TSDB_CHECK_CODE(code, lino, _exit); +_exit: + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code)); + } tDecoderClear(pDecoder); return code; - -_err: - tDecoderClear(pDecoder); - metaError("vgId:%d, vnode snapshot meta write failed since %s at line:%d", TD_VID(pMeta->pVnode), terrstr(), line); - return code; } typedef struct STableInfoForChildTable { @@ -468,19 +464,17 @@ int32_t setForSnapShot(SSnapContext* ctx, int64_t uid) { return c; } -void taosXSetTablePrimaryKey(SSnapContext* ctx, int64_t uid){ - bool ret = false; - SSchemaWrapper *schema = metaGetTableSchema(ctx->pMeta, uid, -1, 1); - if (schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY){ +void taosXSetTablePrimaryKey(SSnapContext* ctx, int64_t uid) { + bool ret = false; + SSchemaWrapper* schema = metaGetTableSchema(ctx->pMeta, uid, -1, 1); + if (schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY) { ret = true; } tDeleteSchemaWrapper(schema); ctx->hasPrimaryKey = ret; } -bool taosXGetTablePrimaryKey(SSnapContext* ctx){ - return ctx->hasPrimaryKey; -} +bool taosXGetTablePrimaryKey(SSnapContext* ctx) { return ctx->hasPrimaryKey; } int32_t getTableInfoFromSnapshot(SSnapContext* ctx, void** pBuf, int32_t* contLen, int16_t* type, int64_t* uid) { int32_t ret = 0; diff --git a/source/dnode/vnode/src/sma/smaTimeRange.c b/source/dnode/vnode/src/sma/smaTimeRange.c index fe3117de49..201e496140 100644 --- a/source/dnode/vnode/src/sma/smaTimeRange.c +++ b/source/dnode/vnode/src/sma/smaTimeRange.c @@ -201,7 +201,12 @@ int32_t smaBlockToSubmit(SVnode *pVnode, const SArray *pBlocks, const STSchema * SSubmitTbData tbData = {.suid = suid, .uid = 0, .sver = pTSchema->version, .flags = SUBMIT_REQ_AUTO_CREATE_TABLE}; int32_t cid = taosArrayGetSize(pDataBlock->pDataBlock) + 1; - tbData.pCreateTbReq = buildAutoCreateTableReq(stbFullName, suid, cid, pDataBlock, tagArray, true); + + code = buildAutoCreateTableReq(stbFullName, suid, cid, pDataBlock, tagArray, true, &tbData.pCreateTbReq); + if (code) { + smaError("failed to build create-table req, code:%d", code); + continue; + } { uint64_t groupId = pDataBlock->info.id.groupId; diff --git a/source/dnode/vnode/src/tq/tqSink.c b/source/dnode/vnode/src/tq/tqSink.c index 3efc653f64..45212df1dd 100644 --- a/source/dnode/vnode/src/tq/tqSink.c +++ b/source/dnode/vnode/src/tq/tqSink.c @@ -18,8 +18,6 @@ #include "tmsg.h" #include "tq.h" -#define MAX_CACHE_TABLE_INFO_NUM 10240 - typedef struct STableSinkInfo { uint64_t uid; tstr name; @@ -43,7 +41,7 @@ static int32_t doRemoveFromCache(SSHashObj* pSinkTableMap, uint64_t groupId, con static bool isValidDstChildTable(SMetaReader* pReader, int32_t vgId, const char* ctbName, int64_t suid); static int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const char* stbFullName, int32_t numOfTags); -static SArray* createDefaultTagColName(); +static int32_t createDefaultTagColName(SArray** pList); static void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDataBlock, const char* stbFullName, int64_t gid, bool newSubTableRule); static int32_t doCreateSinkInfo(const char* pDstTableName, STableSinkInfo** pInfo); @@ -95,7 +93,10 @@ int32_t tqBuildDeleteReq(STQ* pTq, const char* stbFullName, const SSDataBlock* p SSingleDeleteReq req = {.startTs = skey, .endTs = ekey}; strncpy(req.tbname, name, TSDB_TABLE_NAME_LEN - 1); - taosArrayPush(deleteReq->deleteReqs, &req); + void* p = taosArrayPush(deleteReq->deleteReqs, &req); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } if (originName) name = originName; taosMemoryFreeClear(name); @@ -149,14 +150,20 @@ static bool tqGetTableInfo(SSHashObj* pTableInfoMap, uint64_t groupId, STableSin static int32_t tqPutReqToQueue(SVnode* pVnode, SVCreateTbBatchReq* pReqs) { void* buf = NULL; int32_t tlen = 0; - encodeCreateChildTableForRPC(pReqs, TD_VID(pVnode), &buf, &tlen); + + int32_t code = encodeCreateChildTableForRPC(pReqs, TD_VID(pVnode), &buf, &tlen); + if (code) { + tqError("vgId:%d failed to encode create table msg, create table failed, code:%s", TD_VID(pVnode), tstrerror(code)); + return code; + } SRpcMsg msg = {.msgType = TDMT_VND_CREATE_TABLE, .pCont = buf, .contLen = tlen}; - if (tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg) != 0) { + code = tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg); + if (code) { tqError("failed to put into write-queue since %s", terrstr()); } - return TSDB_CODE_SUCCESS; + return code; } int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const char* stbFullName, int32_t numOfTags) { @@ -166,18 +173,36 @@ int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const // set super table name SName name = {0}; - tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - pCreateTableReq->ctb.stbName = taosStrdup((char*)tNameGetTableName(&name)); + + int32_t code = tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + if (code == 0) { + pCreateTableReq->ctb.stbName = taosStrdup((char*)tNameGetTableName(&name)); + if (pCreateTableReq->ctb.stbName == NULL) { // ignore this error code + tqError("failed to duplicate the stb name:%s, failed to init create-table msg and create req table", stbFullName); + } + } pCreateTableReq->ctb.tagNum = numOfTags; - return TSDB_CODE_SUCCESS; + return code; } -SArray* createDefaultTagColName() { +int32_t createDefaultTagColName(SArray** pColNameList) { + *pColNameList = NULL; + SArray* pTagColNameList = taosArrayInit(1, TSDB_COL_NAME_LEN); - char tagNameStr[TSDB_COL_NAME_LEN] = "group_id"; - taosArrayPush(pTagColNameList, tagNameStr); - return pTagColNameList; + if (pTagColNameList == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + char tagNameStr[TSDB_COL_NAME_LEN] = "group_id"; + void* p = taosArrayPush(pTagColNameList, tagNameStr); + if (p == NULL) { + taosArrayDestroy(pTagColNameList); + return TSDB_CODE_OUT_OF_MEMORY; + } + + *pColNameList = pTagColNameList; + return TSDB_CODE_SUCCESS; } void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDataBlock, const char* stbFullName, @@ -201,18 +226,20 @@ void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDa static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, SSDataBlock* pDataBlock, SStreamTask* pTask, int64_t suid) { - STSchema* pTSchema = pTask->outputInfo.tbSink.pTSchema; - int32_t rows = pDataBlock->info.rows; - SArray* tagArray = taosArrayInit(4, sizeof(STagVal)); + STSchema* pTSchema = pTask->outputInfo.tbSink.pTSchema; + int32_t rows = pDataBlock->info.rows; + SArray* tagArray = taosArrayInit(4, sizeof(STagVal)); + const char* id = pTask->id.idStr; + int32_t vgId = pTask->pMeta->vgId; - tqDebug("s-task:%s build create %d table(s) msg", pTask->id.idStr, rows); + tqDebug("s-task:%s build create %d table(s) msg", id, rows); int32_t code = 0; SVCreateTbBatchReq reqs = {0}; SArray* crTblArray = reqs.pArray = taosArrayInit(1, sizeof(SVCreateTbReq)); if (NULL == reqs.pArray) { - tqError("s-task:%s failed to init create table msg, code:%s", pTask->id.idStr, tstrerror(terrno)); + tqError("s-task:%s failed to init create table msg, code:%s", id, tstrerror(terrno)); goto _end; } @@ -222,15 +249,26 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S int32_t size = taosArrayGetSize(pDataBlock->pDataBlock); int32_t numOfTags = TMAX(size - UD_TAG_COLUMN_INDEX, 1); - initCreateTableMsg(pCreateTbReq, suid, stbFullName, numOfTags); + code = initCreateTableMsg(pCreateTbReq, suid, stbFullName, numOfTags); + if (code) { + tqError("s-task:%s vgId:%d failed to init create table msg", id, vgId); + continue; + } taosArrayClear(tagArray); if (size == 2) { STagVal tagVal = { .cid = pTSchema->numOfCols + 1, .type = TSDB_DATA_TYPE_UBIGINT, .i64 = pDataBlock->info.id.groupId}; - taosArrayPush(tagArray, &tagVal); - pCreateTbReq->ctb.tagName = createDefaultTagColName(); + void* p = taosArrayPush(tagArray, &tagVal); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + code = createDefaultTagColName(&pCreateTbReq->ctb.tagName); + if (code) { + return code; + } } else { for (int32_t tagId = UD_TAG_COLUMN_INDEX, step = 1; tagId < size; tagId++, step++) { SColumnInfoData* pTagData = taosArrayGet(pDataBlock->pDataBlock, tagId); @@ -245,14 +283,19 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S } else { memcpy(&tagVal.i64, pData, pTagData->info.bytes); } - taosArrayPush(tagArray, &tagVal); + void* p = taosArrayPush(tagArray, &tagVal); + if (p == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _end; + } } } - tTagNew(tagArray, 1, false, (STag**)&pCreateTbReq->ctb.pTag); + code = tTagNew(tagArray, 1, false, (STag**)&pCreateTbReq->ctb.pTag); taosArrayDestroy(tagArray); tagArray = NULL; - if (pCreateTbReq->ctb.pTag == NULL) { + + if (pCreateTbReq->ctb.pTag == NULL || (code != 0)) { tdDestroySVCreateTbReq(pCreateTbReq); code = TSDB_CODE_OUT_OF_MEMORY; goto _end; @@ -270,22 +313,34 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S setCreateTableMsgTableName(pCreateTbReq, pDataBlock, stbFullName, gid, pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1); - taosArrayPush(reqs.pArray, pCreateTbReq); + void* p = taosArrayPush(reqs.pArray, pCreateTbReq); + if (p == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _end; + } STableSinkInfo* pInfo = NULL; bool alreadyCached = tqGetTableInfo(pTask->outputInfo.tbSink.pTblInfo, gid, &pInfo); if (!alreadyCached) { code = doCreateSinkInfo(pCreateTbReq->name, &pInfo); - doPutIntoCache(pTask->outputInfo.tbSink.pTblInfo, pInfo, gid, pTask->id.idStr); + if (code) { + tqError("vgId:%d failed to create sink tableInfo for table:%s, s-task:%s", vgId, pCreateTbReq->name, id); + continue; + } + + code = doPutIntoCache(pTask->outputInfo.tbSink.pTblInfo, pInfo, gid, id); + if (code) { + tqError("vgId:%d failed to put sink tableInfo:%s into cache, s-task:%s", vgId, pCreateTbReq->name, id); + } } - tqDebug("s-task:%s build create table:%s msg complete", pTask->id.idStr, pCreateTbReq->name); + tqDebug("s-task:%s build create table:%s msg complete", id, pCreateTbReq->name); } reqs.nReqs = taosArrayGetSize(reqs.pArray); code = tqPutReqToQueue(pVnode, &reqs); if (code != TSDB_CODE_SUCCESS) { - tqError("s-task:%s failed to send create table msg", pTask->id.idStr); + tqError("s-task:%s failed to send create table msg", id); } _end: @@ -348,15 +403,26 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c SRow* pOldRow = *(SRow**)TARRAY_GET_ELEM(pExisted->aRowP, k); if (pNewRow->ts < pOldRow->ts) { - taosArrayPush(pFinal, &pNewRow); + void* p = taosArrayPush(pFinal, &pNewRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } j += 1; } else if (pNewRow->ts > pOldRow->ts) { - taosArrayPush(pFinal, &pOldRow); + void* p = taosArrayPush(pFinal, &pOldRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + k += 1; } else { // check for the existance of primary key if (pNewRow->numOfPKs == 0) { - taosArrayPush(pFinal, &pNewRow); + void* p = taosArrayPush(pFinal, &pNewRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + k += 1; j += 1; tRowDestroy(pOldRow); @@ -369,7 +435,11 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c int32_t ret = tRowKeyCompare(&kNew, &kOld); if (ret <= 0) { - taosArrayPush(pFinal, &pNewRow); + void* p = taosArrayPush(pFinal, &pNewRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + j += 1; if (ret == 0) { @@ -377,7 +447,11 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c tRowDestroy(pOldRow); } } else { - taosArrayPush(pFinal, &pOldRow); + void* p = taosArrayPush(pFinal, &pOldRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + k += 1; } } @@ -386,12 +460,18 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c while (j < newLen) { SRow* pRow = *(SRow**)TARRAY_GET_ELEM(pNew->aRowP, j++); - taosArrayPush(pFinal, &pRow); + void* p = taosArrayPush(pFinal, &pRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } while (k < oldLen) { SRow* pRow = *(SRow**)TARRAY_GET_ELEM(pExisted->aRowP, k++); - taosArrayPush(pFinal, &pRow); + void* p = taosArrayPush(pFinal, &pRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } taosArrayDestroy(pNew->aRowP); @@ -425,34 +505,40 @@ bool isValidDstChildTable(SMetaReader* pReader, int32_t vgId, const char* ctbNam return true; } -SVCreateTbReq* buildAutoCreateTableReq(const char* stbFullName, int64_t suid, int32_t numOfCols, - SSDataBlock* pDataBlock, SArray* pTagArray, bool newSubTableRule) { +int32_t buildAutoCreateTableReq(const char* stbFullName, int64_t suid, int32_t numOfCols, SSDataBlock* pDataBlock, + SArray* pTagArray, bool newSubTableRule, SVCreateTbReq** pReq) { + *pReq = NULL; + SVCreateTbReq* pCreateTbReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq)); if (pCreateTbReq == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } taosArrayClear(pTagArray); - initCreateTableMsg(pCreateTbReq, suid, stbFullName, 1); - - STagVal tagVal = {.cid = numOfCols, .type = TSDB_DATA_TYPE_UBIGINT, .i64 = pDataBlock->info.id.groupId}; - taosArrayPush(pTagArray, &tagVal); - - tTagNew(pTagArray, 1, false, (STag**)&pCreateTbReq->ctb.pTag); - - if (pCreateTbReq->ctb.pTag == NULL) { - tdDestroySVCreateTbReq(pCreateTbReq); - taosMemoryFreeClear(pCreateTbReq); - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + int32_t code = initCreateTableMsg(pCreateTbReq, suid, stbFullName, 1); + if (code != 0) { + return code; } - pCreateTbReq->ctb.tagName = createDefaultTagColName(); + STagVal tagVal = {.cid = numOfCols, .type = TSDB_DATA_TYPE_UBIGINT, .i64 = pDataBlock->info.id.groupId}; + void* p = taosArrayPush(pTagArray, &tagVal); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + code = tTagNew(pTagArray, 1, false, (STag**)&pCreateTbReq->ctb.pTag); + if (pCreateTbReq->ctb.pTag == NULL || (code != 0)) { + tdDestroySVCreateTbReq(pCreateTbReq); + taosMemoryFreeClear(pCreateTbReq); + return code; + } + + code = createDefaultTagColName(&pCreateTbReq->ctb.tagName); // set table name setCreateTableMsgTableName(pCreateTbReq, pDataBlock, stbFullName, pDataBlock->info.id.groupId, newSubTableRule); - return pCreateTbReq; + *pReq = pCreateTbReq; + return code; } int32_t buildSubmitMsgImpl(SSubmitReq2* pSubmitReq, int32_t vgId, void** pMsg, int32_t* msgLen) { @@ -555,7 +641,10 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat break; } SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type); - taosArrayPush(pVals, &cv); + void* p = taosArrayPush(pVals, &cv); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } else { SColumnInfoData* pColData = taosArrayGet(pDataBlock->pDataBlock, dataIndex); if (colDataIsNull_s(pColData, j)) { @@ -566,7 +655,11 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat } SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type); - taosArrayPush(pVals, &cv); + void* p = taosArrayPush(pVals, &cv); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + dataIndex++; } else { void* colData = colDataGetData(pColData, j); @@ -574,12 +667,18 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat SValue sv = (SValue){.type = pCol->type, .nData = varDataLen(colData), .pData = (uint8_t*)varDataVal(colData)}; SColVal cv = COL_VAL_VALUE(pCol->colId, sv); - taosArrayPush(pVals, &cv); + void* p = taosArrayPush(pVals, &cv); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } else { SValue sv = {.type = pCol->type}; memcpy(&sv.val, colData, tDataTypes[pCol->type].bytes); SColVal cv = COL_VAL_VALUE(pCol->colId, sv); - taosArrayPush(pVals, &cv); + void* p = taosArrayPush(pVals, &cv); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } dataIndex++; } @@ -596,7 +695,10 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat } ASSERT(pRow); - taosArrayPush(pTableData->aRowP, &pRow); + void* p = taosArrayPush(pTableData->aRowP, &pRow); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } taosArrayDestroy(pVals); @@ -665,6 +767,7 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat STSchema* pTSchema = pTask->outputInfo.tbSink.pTSchema; int32_t vgId = TD_VID(pVnode); STableSinkInfo* pTableSinkInfo = NULL; + int32_t code = 0; bool alreadyCached = tqGetTableInfo(pTask->outputInfo.tbSink.pTblInfo, groupId, &pTableSinkInfo); @@ -686,7 +789,11 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat } else { // this groupId has not been kept in cache yet if (dstTableName[0] == 0) { memset(dstTableName, 0, TSDB_TABLE_NAME_LEN); - buildCtbNameByGroupIdImpl(stbFullName, groupId, dstTableName); + code = buildCtbNameByGroupIdImpl(stbFullName, groupId, dstTableName); + if (code) { + tqDebug("s-task:%s failed to build auto create table-name:%s, groupId:0x%" PRId64, id, dstTableName, groupId); + return code; + } } else { if (pTask->subtableWithoutMd5 != 1 && !isAutoTableName(dstTableName) && !alreadyAddGroupId(dstTableName, groupId) && groupId != 0) { @@ -699,8 +806,13 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat } } - int32_t code = doCreateSinkInfo(dstTableName, &pTableSinkInfo); - tqDebug("s-task:%s build new sinkTableInfo to add cache, dstTable:%s", id, dstTableName); + code = doCreateSinkInfo(dstTableName, &pTableSinkInfo); + if (code == 0) { + tqDebug("s-task:%s build new sinkTableInfo to add cache, dstTable:%s", id, dstTableName); + } else { + tqDebug("s-task:%s failed to build new sinkTableInfo, dstTable:%s", id, dstTableName); + return code; + } } if (alreadyCached) { @@ -731,20 +843,20 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat SArray* pTagArray = taosArrayInit(pTSchema->numOfCols + 1, sizeof(STagVal)); pTableData->flags = SUBMIT_REQ_AUTO_CREATE_TABLE; - pTableData->pCreateTbReq = + code = buildAutoCreateTableReq(stbFullName, suid, pTSchema->numOfCols + 1, pDataBlock, pTagArray, - pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1); + (pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1), + &pTableData->pCreateTbReq); taosArrayDestroy(pTagArray); - if (pTableData->pCreateTbReq == NULL) { - tqError("s-task:%s failed to build auto create dst-table req:%s, code:%s", id, dstTableName, - tstrerror(terrno)); + if (code) { + tqError("s-task:%s failed to build auto create dst-table req:%s, code:%s", id, dstTableName, tstrerror(code)); taosMemoryFree(pTableSinkInfo); - return terrno; + return code; } pTableSinkInfo->uid = 0; - doPutIntoCache(pTask->outputInfo.tbSink.pTblInfo, pTableSinkInfo, groupId, id); + code = doPutIntoCache(pTask->outputInfo.tbSink.pTblInfo, pTableSinkInfo, groupId, id); } else { metaReaderClear(&mr); @@ -765,12 +877,12 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat pTableSinkInfo->uid = mr.me.uid; metaReaderClear(&mr); - doPutIntoCache(pTask->outputInfo.tbSink.pTblInfo, pTableSinkInfo, groupId, id); + code = doPutIntoCache(pTask->outputInfo.tbSink.pTblInfo, pTableSinkInfo, groupId, id); } } } - return TDB_CODE_SUCCESS; + return code; } int32_t tqSetDstTableDataPayload(uint64_t suid, const STSchema *pTSchema, int32_t blockIndex, SSDataBlock* pDataBlock, @@ -864,14 +976,21 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { if (code != TSDB_CODE_SUCCESS || tbData.aRowP == NULL) { if (tbData.pCreateTbReq != NULL) { tdDestroySVCreateTbReq(tbData.pCreateTbReq); - doRemoveFromCache(pTask->outputInfo.tbSink.pTblInfo, pDataBlock->info.id.groupId, id); + (void) doRemoveFromCache(pTask->outputInfo.tbSink.pTblInfo, pDataBlock->info.id.groupId, id); tbData.pCreateTbReq = NULL; } continue; } - taosArrayPush(submitReq.aSubmitTbData, &tbData); + void* p = taosArrayPush(submitReq.aSubmitTbData, &tbData); + if (p == NULL) { + tqDebug("vgId:%d, s-task:%s failed to build submit msg, data lost", vgId, id); + } + code = doBuildAndSendSubmitMsg(pVnode, pTask, &submitReq, 1); + if (code) { // failed and continue + tqDebug("vgId:%d, s-task:%s submit msg failed, data lost", vgId, id); + } } } } else { @@ -918,16 +1037,24 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { if (code != TSDB_CODE_SUCCESS || tbData.aRowP == NULL) { if (tbData.pCreateTbReq != NULL) { tdDestroySVCreateTbReq(tbData.pCreateTbReq); - doRemoveFromCache(pTask->outputInfo.tbSink.pTblInfo, groupId, id); + (void) doRemoveFromCache(pTask->outputInfo.tbSink.pTblInfo, groupId, id); tbData.pCreateTbReq = NULL; } continue; } - taosArrayPush(submitReq.aSubmitTbData, &tbData); + void* p = taosArrayPush(submitReq.aSubmitTbData, &tbData); + if (p == NULL) { + tqError("vgId:%d, s-task:%s failed to build submit msg, data lost", vgId, id); + continue; + } int32_t size = (int32_t)taosArrayGetSize(submitReq.aSubmitTbData) - 1; - taosHashPut(pTableIndexMap, &groupId, sizeof(groupId), &size, sizeof(size)); + code = taosHashPut(pTableIndexMap, &groupId, sizeof(groupId), &size, sizeof(size)); + if (code) { + tqError("vgId:%d, s-task:%s failed to put group into index map, code:%s", vgId, id, tstrerror(code)); + continue; + } } else { code = tqSetDstTableDataPayload(suid, pTSchema, i, pDataBlock, &tbData, earlyTs, id); if (code != TSDB_CODE_SUCCESS || tbData.aRowP == NULL) { @@ -951,7 +1078,10 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { taosHashCleanup(pTableIndexMap); if (hasSubmit) { - doBuildAndSendSubmitMsg(pVnode, pTask, &submitReq, numOfBlocks); + code = doBuildAndSendSubmitMsg(pVnode, pTask, &submitReq, numOfBlocks); + if (code) { // failed and continue + tqError("vgId:%d failed to build and send submit msg", vgId); + } } else { tDestroySubmitReq(&submitReq, TSDB_MSG_FLG_ENCODE); tqDebug("vgId:%d, s-task:%s write results completed", vgId, id); @@ -989,7 +1119,11 @@ int32_t doRemoveFromCache(SSHashObj* pSinkTableMap, uint64_t groupId, const char } int32_t code = tSimpleHashRemove(pSinkTableMap, &groupId, sizeof(groupId)); - tqDebug("s-task:%s remove cached table meta for groupId:%" PRId64, id, groupId); + if (code == 0) { + tqDebug("s-task:%s remove cached table meta for groupId:%" PRId64, id, groupId); + } else { + tqError("s-task:%s failed to remove table meta from hashmap, groupId:%" PRId64, id, groupId); + } return code; } @@ -1019,10 +1153,14 @@ int32_t doBuildAndSendDeleteMsg(SVnode* pVnode, char* stbFullName, SSDataBlock* void* serializedDeleteReq = rpcMallocCont(len + sizeof(SMsgHead)); void* abuf = POINTER_SHIFT(serializedDeleteReq, sizeof(SMsgHead)); tEncoderInit(&encoder, abuf, len); - tEncodeSBatchDeleteReq(&encoder, &deleteReq); + code = tEncodeSBatchDeleteReq(&encoder, &deleteReq); tEncoderClear(&encoder); taosArrayDestroy(deleteReq.deleteReqs); + if (code) { + return code; + } + ((SMsgHead*)serializedDeleteReq)->vgId = TD_VID(pVnode); SRpcMsg msg = {.msgType = TDMT_VND_BATCH_DEL, .pCont = serializedDeleteReq, .contLen = len + sizeof(SMsgHead)}; diff --git a/source/dnode/vnode/src/tq/tqStreamTask.c b/source/dnode/vnode/src/tq/tqStreamTask.c index 0e5b1b6fb7..c84e016459 100644 --- a/source/dnode/vnode/src/tq/tqStreamTask.c +++ b/source/dnode/vnode/src/tq/tqStreamTask.c @@ -37,7 +37,12 @@ int32_t tqScanWal(STQ* pTq) { // check all tasks int32_t numOfTasks = 0; bool shouldIdle = true; - doScanWalForAllTasks(pMeta, &shouldIdle); + + int32_t code = doScanWalForAllTasks(pMeta, &shouldIdle); + if (code) { + tqError("vgId:%d failed to start all tasks, try next time", vgId); + return code; + } streamMetaWLock(pMeta); int32_t times = (--pMeta->scanInfo.scanCounter); @@ -51,9 +56,13 @@ int32_t tqScanWal(STQ* pTq) { if (times > 0) { tqDebug("vgId:%d scan wal for stream tasks for %d times in %dms", vgId, times, SCAN_WAL_IDLE_DURATION); - tqScanWalInFuture(pTq, numOfTasks, SCAN_WAL_IDLE_DURATION); + code = tqScanWalInFuture(pTq, numOfTasks, SCAN_WAL_IDLE_DURATION); + if (code) { + tqError("vgId:%d sched scan wal in %dms failed, ignore this failure", vgId, SCAN_WAL_IDLE_DURATION); + } } - return 0; + + return code; } typedef struct SBuildScanWalMsgParam { @@ -69,28 +78,44 @@ static void doStartScanWal(void* param, void* tmrId) { tqDebug("vgId:%d create msg to start wal scan, numOfTasks:%d, vnd restored:%d", vgId, pParam->numOfTasks, pTq->pVnode->restored); - /*int32_t code = */ streamTaskSchedTask(&pTq->pVnode->msgCb, vgId, 0, 0, STREAM_EXEC_T_EXTRACT_WAL_DATA); + int32_t code = streamTaskSchedTask(&pTq->pVnode->msgCb, vgId, 0, 0, STREAM_EXEC_T_EXTRACT_WAL_DATA); taosMemoryFree(pParam); + + if (code) { + tqError("vgId:%d failed sched task to scan wal", vgId); + } } int32_t tqScanWalInFuture(STQ* pTq, int32_t numOfTasks, int32_t idleDuration) { SStreamMeta* pMeta = pTq->pStreamMeta; + int32_t code = 0; + int32_t vgId = TD_VID(pTq->pVnode); SBuildScanWalMsgParam* pParam = taosMemoryMalloc(sizeof(SBuildScanWalMsgParam)); + if (pParam == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } pParam->pTq = pTq; pParam->numOfTasks = numOfTasks; - tmr_h pTimer = streamTimerGetInstance(); - ASSERT(pTimer); + tmr_h pTimer = NULL; + code = streamTimerGetInstance(&pTimer); + if (code) { + tqError("vgId:%d failed to get tmr ctrl during sched scan wal", vgId); + return code; + } if (pMeta->scanInfo.scanTimer == NULL) { pMeta->scanInfo.scanTimer = taosTmrStart(doStartScanWal, idleDuration, pParam, pTimer); } else { - taosTmrReset(doStartScanWal, idleDuration, pParam, pTimer, &pMeta->scanInfo.scanTimer); + code = taosTmrReset(doStartScanWal, idleDuration, pParam, pTimer, &pMeta->scanInfo.scanTimer); + if (code) { + tqError("vgId:%d failed to start scan wal in:%dms", vgId, idleDuration); + } } - return TSDB_CODE_SUCCESS; + return code; } int32_t tqScanWalAsync(STQ* pTq, bool ckPause) { @@ -207,7 +232,11 @@ bool handleFillhistoryScanComplete(SStreamTask* pTask, int64_t ver) { double el = (taosGetTimestampMs() - pTask->execInfo.step2Start) / 1000.0; qDebug("s-task:%s scan-history from WAL stage(step 2) ended, range:%" PRId64 "-%" PRId64 ", elapsed time:%.2fs", id, pTask->step2Range.minVer, maxVer, el); - /*int32_t code = */streamTaskPutTranstateIntoInputQ(pTask); + int32_t code = streamTaskPutTranstateIntoInputQ(pTask); + if (code) { + qError("s-task:%s failed to put trans-state into inputQ", id); + } + return true; } else { qWarn("s-task:%s fill-history scan WAL, nextProcessVer:%" PRId64 " out of the ver range:%" PRId64 "-%" PRId64 @@ -290,8 +319,12 @@ bool doPutDataIntoInputQ(SStreamTask* pTask, int64_t maxVer, int32_t* numOfItems break; } } else { - walReaderSeekVer(pTask->exec.pWalReader, pTask->chkInfo.nextProcessVer); tqTrace("s-task:%s append input queue failed, code:too many items, ver:%" PRId64, id, pTask->chkInfo.nextProcessVer); + code = walReaderSeekVer(pTask->exec.pWalReader, pTask->chkInfo.nextProcessVer); + if (code) { + tqError("s-task:%s failed to seek ver to:%"PRId64 " in wal", id, pTask->chkInfo.nextProcessVer); + } + break; } } @@ -347,18 +380,18 @@ int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle) { int32_t numOfItems = streamQueueGetNumOfItems(pTask->inputq.queue); int64_t maxVer = (pTask->info.fillHistory == 1) ? pTask->step2Range.maxVer : INT64_MAX; - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); SStreamTaskState pState = streamTaskGetStatus(pTask); if (pState.state != TASK_STATUS__READY) { tqDebug("s-task:%s not ready for submit block from wal, status:%s", pTask->id.idStr, pState.name); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pStreamMeta, pTask); continue; } bool hasNewData = doPutDataIntoInputQ(pTask, maxVer, &numOfItems); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); if ((numOfItems > 0) || hasNewData) { noDataInWal = false; @@ -366,7 +399,7 @@ int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle) { if (code != TSDB_CODE_SUCCESS) { streamMetaReleaseTask(pStreamMeta, pTask); taosArrayDestroy(pTaskList); - return -1; + return code; } } @@ -379,5 +412,5 @@ int32_t doScanWalForAllTasks(SStreamMeta* pStreamMeta, bool* pScanIdle) { } taosArrayDestroy(pTaskList); - return 0; + return TSDB_CODE_SUCCESS; } diff --git a/source/dnode/vnode/src/tqCommon/tqCommon.c b/source/dnode/vnode/src/tqCommon/tqCommon.c index 3c6100a8f4..b56c474ed5 100644 --- a/source/dnode/vnode/src/tqCommon/tqCommon.c +++ b/source/dnode/vnode/src/tqCommon/tqCommon.c @@ -160,6 +160,7 @@ int32_t tqStreamTaskProcessUpdateReq(SStreamMeta* pMeta, SMsgCb* cb, SRpcMsg* pM SRpcMsg rsp = {.info = pMsg->info, .code = TSDB_CODE_SUCCESS}; int64_t st = taosGetTimestampMs(); bool updated = false; + int32_t code = 0; SStreamTaskNodeUpdateMsg req = {0}; @@ -258,26 +259,40 @@ int32_t tqStreamTaskProcessUpdateReq(SStreamMeta* pMeta, SMsgCb* cb, SRpcMsg* pM } } - // save + // stream do update the nodeEp info, write it into stream meta. if (updated) { tqDebug("s-task:%s vgId:%d save task after update epset, and stop task", idstr, vgId); - streamMetaSaveTask(pMeta, pTask); + code = streamMetaSaveTask(pMeta, pTask); + if (code) { + tqError("s-task:%s vgId:%d failed to save task, code:%s", idstr, vgId, tstrerror(code)); + } + if (ppHTask != NULL) { - streamMetaSaveTask(pMeta, *ppHTask); + code = streamMetaSaveTask(pMeta, *ppHTask); + if (code) { + tqError("s-task:%s vgId:%d failed to save related history task, code:%s", idstr, vgId, tstrerror(code)); + } } } else { tqDebug("s-task:%s vgId:%d not save task since not update epset actually, stop task", idstr, vgId); } - streamTaskStop(pTask); + code = streamTaskStop(pTask); + if (code) { + tqError("s-task:%s vgId:%d failed to stop task, code:%s", idstr, vgId, tstrerror(code)); + } + if (ppHTask != NULL) { - streamTaskStop(*ppHTask); + code = streamTaskStop(*ppHTask); + if (code) { + tqError("s-task:%s vgId:%d failed to stop related history task, code:%s", idstr, vgId, tstrerror(code)); + } } // keep info streamMetaAddIntoUpdateTaskList(pMeta, pTask, (ppHTask != NULL) ? (*ppHTask) : NULL, req.transId, st); - rsp.code = 0; + rsp.code = TSDB_CODE_SUCCESS; // possibly only handle the stream task. int32_t numOfTasks = streamMetaGetNumOfTasks(pMeta); @@ -305,13 +320,16 @@ int32_t tqStreamTaskProcessUpdateReq(SStreamMeta* pMeta, SMsgCb* cb, SRpcMsg* pM #if 0 taosMSleep(5000);// for test purpose, to trigger the leader election #endif - tqStreamTaskStartAsync(pMeta, cb, true); + code = tqStreamTaskStartAsync(pMeta, cb, true); + if (code) { + tqError("vgId:%d async start all tasks, failed, code:%s", vgId, tstrerror(code)); + } } } streamMetaWUnLock(pMeta); taosArrayDestroy(req.pNodeList); - return rsp.code; + return rsp.code; // always return true } int32_t tqStreamTaskProcessDispatchReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { @@ -333,7 +351,7 @@ int32_t tqStreamTaskProcessDispatchReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, req.streamId, req.taskId, &pTask); - if (pTask) { + if (pTask && (code == 0)) { SRpcMsg rsp = {.info = pMsg->info, .code = 0}; if (streamProcessDispatchMsg(pTask, &req, &rsp) != 0) { return -1; @@ -393,14 +411,14 @@ int32_t tqStreamTaskProcessDispatchRsp(SStreamMeta* pMeta, SRpcMsg* pMsg) { SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pRsp->streamId, pRsp->upstreamTaskId, &pTask); - if (pTask) { - streamProcessDispatchRsp(pTask, pRsp, pMsg->code); + if (pTask && (code == 0)) { + code = streamProcessDispatchRsp(pTask, pRsp, pMsg->code); streamMetaReleaseTask(pMeta, pTask); - return TSDB_CODE_SUCCESS; + return code; } else { tqDebug("vgId:%d failed to handle the dispatch rsp, since find task:0x%x failed", vgId, pRsp->upstreamTaskId); terrno = TSDB_CODE_STREAM_TASK_NOT_EXIST; - return terrno; + return TSDB_CODE_STREAM_TASK_NOT_EXIST; } } @@ -408,16 +426,22 @@ int32_t tqStreamTaskProcessRetrieveReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { char* msgStr = pMsg->pCont; char* msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead)); int32_t msgLen = pMsg->contLen - sizeof(SMsgHead); + int32_t code = 0; SDecoder decoder; SStreamRetrieveReq req; tDecoderInit(&decoder, (uint8_t*)msgBody, msgLen); - tDecodeStreamRetrieveReq(&decoder, &req); + code = tDecodeStreamRetrieveReq(&decoder, &req); tDecoderClear(&decoder); + if (code) { + tqError("vgId:%d failed to decode retrieve msg, quit handling it", pMeta->vgId); + return code; + } + SStreamTask* pTask = NULL; - int32_t code = streamMetaAcquireTask(pMeta, req.streamId, req.dstTaskId, &pTask); - if (pTask == NULL) { + code = streamMetaAcquireTask(pMeta, req.streamId, req.dstTaskId, &pTask); + if (pTask == NULL || code != 0) { tqError("vgId:%d process retrieve req, failed to acquire task:0x%x, it may have been dropped already", pMeta->vgId, req.dstTaskId); tCleanupStreamRetrieveReq(&req); @@ -446,6 +470,7 @@ int32_t tqStreamTaskProcessCheckReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { char* msgStr = pMsg->pCont; char* msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead)); int32_t msgLen = pMsg->contLen - sizeof(SMsgHead); + int32_t code = 0; SStreamTaskCheckReq req; SStreamTaskCheckRsp rsp = {0}; @@ -453,9 +478,14 @@ int32_t tqStreamTaskProcessCheckReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { SDecoder decoder; tDecoderInit(&decoder, (uint8_t*)msgBody, msgLen); - tDecodeStreamTaskCheckReq(&decoder, &req); + code = tDecodeStreamTaskCheckReq(&decoder, &req); tDecoderClear(&decoder); + if (code) { + tqError("vgId:%d decode check msg failed, not handle this msg", pMeta->vgId); + return code; + } + streamTaskProcessCheckMsg(pMeta, &req, &rsp); return streamTaskSendCheckRsp(pMeta, req.upstreamNodeId, &rsp, &pMsg->info, req.upstreamTaskId); } @@ -490,7 +520,7 @@ int32_t tqStreamTaskProcessCheckRsp(SStreamMeta* pMeta, SRpcMsg* pMsg, bool isLe SStreamTask* pTask = NULL; code = streamMetaAcquireTask(pMeta, rsp.streamId, rsp.upstreamTaskId, &pTask); - if (pTask == NULL) { + if ((pTask == NULL) || (code != 0)) { return streamMetaAddFailedTask(pMeta, rsp.streamId, rsp.upstreamTaskId); } @@ -518,19 +548,25 @@ int32_t tqStreamTaskProcessCheckpointReadyMsg(SStreamMeta* pMeta, SRpcMsg* pMsg) SStreamTask* pTask = NULL; code = streamMetaAcquireTask(pMeta, req.streamId, req.upstreamTaskId, &pTask); - if (pTask == NULL) { + if (code != 0) { tqError("vgId:%d failed to find s-task:0x%x, it may have been destroyed already", vgId, req.downstreamTaskId); - return TSDB_CODE_STREAM_TASK_NOT_EXIST; + return code; } tqDebug("vgId:%d s-task:%s received the checkpoint-ready msg from task:0x%x (vgId:%d), handle it", vgId, pTask->id.idStr, req.downstreamTaskId, req.downstreamNodeId); - streamProcessCheckpointReadyMsg(pTask, req.checkpointId, req.downstreamTaskId, req.downstreamNodeId); + code = streamProcessCheckpointReadyMsg(pTask, req.checkpointId, req.downstreamTaskId, req.downstreamNodeId); streamMetaReleaseTask(pMeta, pTask); + if (code) { + return code; + } { // send checkpoint ready rsp SMStreamCheckpointReadyRspMsg* pReadyRsp = rpcMallocCont(sizeof(SMStreamCheckpointReadyRspMsg)); + if (pReadyRsp == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } pReadyRsp->upstreamTaskId = req.upstreamTaskId; pReadyRsp->upstreamNodeId = req.upstreamNodeId; @@ -606,8 +642,8 @@ int32_t tqStreamTaskProcessDeployReq(SStreamMeta* pMeta, SMsgCb* cb, int64_t sve if (restored) { SStreamTask* p = NULL; code = streamMetaAcquireTask(pMeta, streamId, taskId, &p); - if ((p != NULL) && (p->info.fillHistory == 0)) { - tqStreamStartOneTaskAsync(pMeta, cb, streamId, taskId); + if ((p != NULL) && (code == 0) && (p->info.fillHistory == 0)) { + code = tqStreamStartOneTaskAsync(pMeta, cb, streamId, taskId); } if (p != NULL) { @@ -631,6 +667,7 @@ int32_t tqStreamTaskProcessDeployReq(SStreamMeta* pMeta, SMsgCb* cb, int64_t sve int32_t tqStreamTaskProcessDropReq(SStreamMeta* pMeta, char* msg, int32_t msgLen) { SVDropStreamTaskReq* pReq = (SVDropStreamTaskReq*)msg; + int32_t code = 0; int32_t vgId = pMeta->vgId; STaskId hTaskId = {0}; tqDebug("vgId:%d receive msg to drop s-task:0x%x", vgId, pReq->taskId); @@ -649,8 +686,12 @@ int32_t tqStreamTaskProcessDropReq(SStreamMeta* pMeta, char* msg, int32_t msgLen } streamTaskSetRemoveBackendFiles(pTask); - streamTaskClearHTaskAttr(pTask, pReq->resetRelHalt); + code = streamTaskClearHTaskAttr(pTask, pReq->resetRelHalt); streamMetaReleaseTask(pMeta, pTask); + + if (code) { + tqError("s-task:0x%x failed to clear related fill-history info, still exists", pReq->taskId); + } } streamMetaWUnLock(pMeta); @@ -658,11 +699,17 @@ int32_t tqStreamTaskProcessDropReq(SStreamMeta* pMeta, char* msg, int32_t msgLen // drop the related fill-history task firstly if (hTaskId.taskId != 0 && hTaskId.streamId != 0) { tqDebug("s-task:0x%x vgId:%d drop rel fill-history task:0x%x firstly", pReq->taskId, vgId, (int32_t)hTaskId.taskId); - streamMetaUnregisterTask(pMeta, hTaskId.streamId, hTaskId.taskId); + code = streamMetaUnregisterTask(pMeta, hTaskId.streamId, hTaskId.taskId); + if (code) { + tqDebug("s-task:0x%x vgId:%d drop rel fill-history task:0x%x failed", pReq->taskId, vgId, (int32_t)hTaskId.taskId); + } } // drop the stream task now - streamMetaUnregisterTask(pMeta, pReq->streamId, pReq->taskId); + code = streamMetaUnregisterTask(pMeta, pReq->streamId, pReq->taskId); + if (code) { + tqDebug("s-task:0x%x vgId:%d drop task failed", pReq->taskId, vgId); + } // commit the update streamMetaWLock(pMeta); @@ -674,12 +721,13 @@ int32_t tqStreamTaskProcessDropReq(SStreamMeta* pMeta, char* msg, int32_t msgLen } streamMetaWUnLock(pMeta); - return 0; + return 0; // always return success } int32_t tqStreamTaskProcessUpdateCheckpointReq(SStreamMeta* pMeta, bool restored, char* msg) { SVUpdateCheckpointInfoReq* pReq = (SVUpdateCheckpointInfoReq*)msg; + int32_t code = 0; int32_t vgId = pMeta->vgId; tqDebug("vgId:%d receive msg to update-checkpoint-info for s-task:0x%x", vgId, pReq->taskId); @@ -689,7 +737,7 @@ int32_t tqStreamTaskProcessUpdateCheckpointReq(SStreamMeta* pMeta, bool restored SStreamTask** ppTask = (SStreamTask**)taosHashGet(pMeta->pTasksMap, &id, sizeof(id)); if (ppTask != NULL && (*ppTask) != NULL) { - streamTaskUpdateTaskCheckpointInfo(*ppTask, restored, pReq); + code = streamTaskUpdateTaskCheckpointInfo(*ppTask, restored, pReq); } else { // failed to get the task. int32_t numOfTasks = streamMetaGetNumOfTasks(pMeta); tqError( @@ -700,7 +748,7 @@ int32_t tqStreamTaskProcessUpdateCheckpointReq(SStreamMeta* pMeta, bool restored streamMetaWUnLock(pMeta); // always return success when handling the requirement issued by mnode during transaction. - return TSDB_CODE_SUCCESS; + return code; } static int32_t restartStreamTasks(SStreamMeta* pMeta, bool isLeader) { @@ -746,7 +794,7 @@ static int32_t restartStreamTasks(SStreamMeta* pMeta, bool isLeader) { if (isLeader && !tsDisableStream) { streamMetaWUnLock(pMeta); - streamMetaStartAllTasks(pMeta); + code = streamMetaStartAllTasks(pMeta); } else { streamMetaResetStartInfo(&pMeta->startInfo, pMeta->vgId); pMeta->startInfo.restartCount = 0; @@ -765,16 +813,16 @@ int32_t tqStreamTaskProcessRunReq(SStreamMeta* pMeta, SRpcMsg* pMsg, bool isLead int32_t vgId = pMeta->vgId; if (type == STREAM_EXEC_T_START_ONE_TASK) { - streamMetaStartOneTask(pMeta, pReq->streamId, pReq->taskId); + (void) streamMetaStartOneTask(pMeta, pReq->streamId, pReq->taskId); return 0; } else if (type == STREAM_EXEC_T_START_ALL_TASKS) { - streamMetaStartAllTasks(pMeta); + (void) streamMetaStartAllTasks(pMeta); return 0; } else if (type == STREAM_EXEC_T_RESTART_ALL_TASKS) { - restartStreamTasks(pMeta, isLeader); + (void) restartStreamTasks(pMeta, isLeader); return 0; } else if (type == STREAM_EXEC_T_STOP_ALL_TASKS) { - streamMetaStopAllTasks(pMeta); + (void) streamMetaStopAllTasks(pMeta); return 0; } else if (type == STREAM_EXEC_T_ADD_FAILED_TASK) { int32_t code = streamMetaAddFailedTask(pMeta, pReq->streamId, pReq->taskId); @@ -783,7 +831,7 @@ int32_t tqStreamTaskProcessRunReq(SStreamMeta* pMeta, SRpcMsg* pMsg, bool isLead SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pReq->streamId, pReq->taskId, &pTask); - if (pTask != NULL) { + if (pTask != NULL && (code == 0)) { char* pStatus = NULL; if (streamTaskReadyToRun(pTask, &pStatus)) { int64_t execTs = pTask->status.lastExecTs; @@ -804,12 +852,12 @@ int32_t tqStreamTaskProcessRunReq(SStreamMeta* pMeta, SRpcMsg* pMsg, bool isLead SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pReq->streamId, pReq->taskId, &pTask); - if (pTask != NULL) { // even in halt status, the data in inputQ must be processed + if ((pTask != NULL) && (code == 0)) { // even in halt status, the data in inputQ must be processed char* p = NULL; if (streamTaskReadyToRun(pTask, &p)) { tqDebug("vgId:%d s-task:%s status:%s start to process block from inputQ, next checked ver:%" PRId64, vgId, pTask->id.idStr, p, pTask->chkInfo.nextProcessVer); - streamExecTask(pTask); + (void) streamExecTask(pTask); } else { int8_t status = streamTaskSetSchedStatusInactive(pTask); tqDebug("vgId:%d s-task:%s ignore run req since not in ready state, status:%s, sched-status:%d", vgId, @@ -829,6 +877,7 @@ int32_t tqStartTaskCompleteCallback(SStreamMeta* pMeta) { STaskStartInfo* pStartInfo = &pMeta->startInfo; int32_t vgId = pMeta->vgId; bool scanWal = false; + int32_t code = 0; streamMetaWLock(pMeta); if (pStartInfo->startAllTasks == 1) { @@ -844,8 +893,7 @@ int32_t tqStartTaskCompleteCallback(SStreamMeta* pMeta) { pStartInfo->restartCount); streamMetaWUnLock(pMeta); - restartStreamTasks(pMeta, (pMeta->role == NODE_ROLE_LEADER)); - return TSDB_CODE_SUCCESS; + return restartStreamTasks(pMeta, (pMeta->role == NODE_ROLE_LEADER)); } else { if (pStartInfo->restartCount == 0) { tqDebug("vgId:%d start all tasks completed in callbackFn, restartCount is 0", pMeta->vgId); @@ -862,10 +910,10 @@ int32_t tqStartTaskCompleteCallback(SStreamMeta* pMeta) { if (scanWal && (vgId != SNODE_HANDLE)) { tqDebug("vgId:%d start scan wal for executing tasks", vgId); - tqScanWalAsync(pMeta->ahandle, true); + code = tqScanWalAsync(pMeta->ahandle, true); } - return TSDB_CODE_SUCCESS; + return code; } int32_t tqStreamTaskProcessTaskResetReq(SStreamMeta* pMeta, char* pMsg) { @@ -873,7 +921,7 @@ int32_t tqStreamTaskProcessTaskResetReq(SStreamMeta* pMeta, char* pMsg) { SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pReq->streamId, pReq->taskId, &pTask); - if (pTask == NULL) { + if (pTask == NULL || (code != 0)) { tqError("vgId:%d process task-reset req, failed to acquire task:0x%x, it may have been dropped already", pMeta->vgId, pReq->taskId); return TSDB_CODE_SUCCESS; @@ -881,7 +929,7 @@ int32_t tqStreamTaskProcessTaskResetReq(SStreamMeta* pMeta, char* pMsg) { tqDebug("s-task:%s receive task-reset msg from mnode, reset status and ready for data processing", pTask->id.idStr); - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); streamTaskClearCheckInfo(pTask, true); // clear flag set during do checkpoint, and open inputQ for all upstream tasks @@ -904,7 +952,7 @@ int32_t tqStreamTaskProcessTaskResetReq(SStreamMeta* pMeta, char* pMsg) { tqDebug("s-task:%s status:%s do nothing after receiving reset-task from mnode", pTask->id.idStr, pState.name); } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pMeta, pTask); return TSDB_CODE_SUCCESS; @@ -915,7 +963,7 @@ int32_t tqStreamTaskProcessRetrieveTriggerReq(SStreamMeta* pMeta, SRpcMsg* pMsg) SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pReq->streamId, pReq->upstreamTaskId, &pTask); - if (pTask == NULL) { + if (pTask == NULL || (code != 0)) { tqError("vgId:%d process retrieve checkpoint trigger, checkpointId:%" PRId64 " from s-task:0x%x, failed to acquire task:0x%x, it may have been dropped already", pMeta->vgId, pReq->checkpointId, (int32_t)pReq->downstreamTaskId, pReq->upstreamTaskId); @@ -929,11 +977,10 @@ int32_t tqStreamTaskProcessRetrieveTriggerReq(SStreamMeta* pMeta, SRpcMsg* pMsg) tqError("s-task:%s not ready for checkpoint-trigger retrieve from 0x%x, since downstream not ready", pTask->id.idStr, (int32_t)pReq->downstreamTaskId); - streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, + code = streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, TSDB_CODE_STREAM_TASK_IVLD_STATUS); streamMetaReleaseTask(pMeta, pTask); - - return TSDB_CODE_SUCCESS; + return code; } SStreamTaskState pState = streamTaskGetStatus(pTask); @@ -948,7 +995,7 @@ int32_t tqStreamTaskProcessRetrieveTriggerReq(SStreamMeta* pMeta, SRpcMsg* pMsg) // re-send the lost checkpoint-trigger msg to downstream task tqDebug("s-task:%s re-send checkpoint-trigger to:0x%x, checkpointId:%" PRId64 ", transId:%d", pTask->id.idStr, (int32_t)pReq->downstreamTaskId, checkpointId, transId); - streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, + code = streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, TSDB_CODE_SUCCESS); } else { // not send checkpoint-trigger yet, wait int32_t recv = 0, total = 0; @@ -962,7 +1009,7 @@ int32_t tqStreamTaskProcessRetrieveTriggerReq(SStreamMeta* pMeta, SRpcMsg* pMsg) "sending checkpoint-source/trigger", pTask->id.idStr, recv, total); } - streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, + code = streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, TSDB_CODE_ACTION_IN_PROGRESS); } } else { // upstream not recv the checkpoint-source/trigger till now @@ -971,12 +1018,12 @@ int32_t tqStreamTaskProcessRetrieveTriggerReq(SStreamMeta* pMeta, SRpcMsg* pMsg) "s-task:%s not recv checkpoint-source from mnode or checkpoint-trigger from upstream yet, wait for all " "upstream sending checkpoint-source/trigger", pTask->id.idStr); - streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, + code = streamTaskSendCheckpointTriggerMsg(pTask, pReq->downstreamTaskId, pReq->downstreamNodeId, &pMsg->info, TSDB_CODE_ACTION_IN_PROGRESS); } streamMetaReleaseTask(pMeta, pTask); - return TSDB_CODE_SUCCESS; + return code; } int32_t tqStreamTaskProcessRetrieveTriggerRsp(SStreamMeta* pMeta, SRpcMsg* pMsg) { @@ -984,19 +1031,19 @@ int32_t tqStreamTaskProcessRetrieveTriggerRsp(SStreamMeta* pMeta, SRpcMsg* pMsg) SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pRsp->streamId, pRsp->taskId, &pTask); - if (pTask == NULL) { + if (pTask == NULL || (code != 0)) { tqError( "vgId:%d process retrieve checkpoint-trigger, failed to acquire task:0x%x, it may have been dropped already", pMeta->vgId, pRsp->taskId); - return TSDB_CODE_STREAM_TASK_NOT_EXIST; + return code; } tqDebug("s-task:%s recv re-send checkpoint-trigger msg from upstream:0x%x, checkpointId:%" PRId64 ", transId:%d", pTask->id.idStr, pRsp->upstreamTaskId, pRsp->checkpointId, pRsp->transId); - streamTaskProcessCheckpointTriggerRsp(pTask, pRsp); + code = streamTaskProcessCheckpointTriggerRsp(pTask, pRsp); streamMetaReleaseTask(pMeta, pTask); - return TSDB_CODE_SUCCESS; + return code; } int32_t tqStreamTaskProcessTaskPauseReq(SStreamMeta* pMeta, char* pMsg) { @@ -1004,7 +1051,7 @@ int32_t tqStreamTaskProcessTaskPauseReq(SStreamMeta* pMeta, char* pMsg) { SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pReq->streamId, pReq->taskId, &pTask); - if (pTask == NULL) { + if (pTask == NULL || (code != 0)) { tqError("vgId:%d process pause req, failed to acquire task:0x%x, it may have been dropped already", pMeta->vgId, pReq->taskId); // since task is in [STOP|DROPPING] state, it is safe to assume the pause is active @@ -1018,7 +1065,7 @@ int32_t tqStreamTaskProcessTaskPauseReq(SStreamMeta* pMeta, char* pMsg) { if (HAS_RELATED_FILLHISTORY_TASK(pTask)) { pHistoryTask = NULL; code = streamMetaAcquireTask(pMeta, pTask->hTaskInfo.id.streamId, pTask->hTaskInfo.id.taskId, &pHistoryTask); - if (pHistoryTask == NULL) { + if (pHistoryTask == NULL || (code != 0)) { tqError("vgId:%d process pause req, failed to acquire fill-history task:0x%" PRIx64 ", it may have been dropped already", pMeta->vgId, pTask->hTaskInfo.id.taskId); @@ -1042,6 +1089,8 @@ static int32_t tqProcessTaskResumeImpl(void* handle, SStreamTask* pTask, int64_t bool fromVnode) { SStreamMeta* pMeta = fromVnode ? ((STQ*)handle)->pStreamMeta : handle; int32_t vgId = pMeta->vgId; + int32_t code = 0; + if (pTask == NULL) { return -1; } @@ -1065,18 +1114,18 @@ static int32_t tqProcessTaskResumeImpl(void* handle, SStreamTask* pTask, int64_t if (level == TASK_LEVEL__SOURCE && pTask->info.fillHistory && status == TASK_STATUS__SCAN_HISTORY) { pTask->hTaskInfo.operatorOpen = false; - streamStartScanHistoryAsync(pTask, igUntreated); + code = streamStartScanHistoryAsync(pTask, igUntreated); } else if (level == TASK_LEVEL__SOURCE && (streamQueueGetNumOfItems(pTask->inputq.queue) == 0)) { - tqScanWalAsync((STQ*)handle, false); + code = tqScanWalAsync((STQ*)handle, false); } else { - streamTrySchedExec(pTask); + code = streamTrySchedExec(pTask); } } /*else { ASSERT(status != TASK_STATUS__UNINIT); }*/ streamMetaReleaseTask(pMeta, pTask); - return 0; + return code; } int32_t tqStreamTaskProcessTaskResumeReq(void* handle, int64_t sversion, char* msg, bool fromVnode) { @@ -1086,15 +1135,15 @@ int32_t tqStreamTaskProcessTaskResumeReq(void* handle, int64_t sversion, char* m SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pReq->streamId, pReq->taskId, &pTask); - if (pTask == NULL) { + if (pTask == NULL || (code != 0)) { tqError("s-task:0x%x failed to acquire task to resume, it may have been dropped or stopped", pReq->taskId); return TSDB_CODE_STREAM_TASK_IVLD_STATUS; } - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); SStreamTaskState pState = streamTaskGetStatus(pTask); tqDebug("s-task:%s start to resume from paused, current status:%s", pTask->id.idStr, pState.name); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); code = tqProcessTaskResumeImpl(handle, pTask, sversion, pReq->igUntreated, fromVnode); if (code != 0) { @@ -1104,11 +1153,11 @@ int32_t tqStreamTaskProcessTaskResumeReq(void* handle, int64_t sversion, char* m STaskId* pHTaskId = &pTask->hTaskInfo.id; SStreamTask* pHTask = NULL; code = streamMetaAcquireTask(pMeta, pHTaskId->streamId, pHTaskId->taskId, &pHTask); - if (pHTask) { - taosThreadMutexLock(&pHTask->lock); + if (pHTask && (code == 0)) { + streamMutexLock(&pHTask->lock); SStreamTaskState p = streamTaskGetStatus(pHTask); tqDebug("s-task:%s related history task start to resume from paused, current status:%s", pHTask->id.idStr, p.name); - taosThreadMutexUnlock(&pHTask->lock); + streamMutexUnlock(&pHTask->lock); code = tqProcessTaskResumeImpl(handle, pHTask, sversion, pReq->igUntreated, fromVnode); } @@ -1139,15 +1188,15 @@ int32_t tqStreamProcessCheckpointReadyRsp(SStreamMeta* pMeta, SRpcMsg* pMsg) { SStreamTask* pTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pRsp->streamId, pRsp->downstreamTaskId, &pTask); - if (pTask == NULL) { + if (pTask == NULL || (code != 0)) { tqError("vgId:%d failed to acquire task:0x%x when handling checkpoint-ready msg, it may have been dropped", pRsp->downstreamNodeId, pRsp->downstreamTaskId); - return TSDB_CODE_STREAM_TASK_NOT_EXIST; + return code; } - streamTaskProcessCheckpointReadyRsp(pTask, pRsp->upstreamTaskId, pRsp->checkpointId); + code = streamTaskProcessCheckpointReadyRsp(pTask, pRsp->upstreamTaskId, pRsp->checkpointId); streamMetaReleaseTask(pMeta, pTask); - return TSDB_CODE_SUCCESS; + return code; } int32_t tqStreamTaskProcessConsenChkptIdReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { @@ -1173,11 +1222,11 @@ int32_t tqStreamTaskProcessConsenChkptIdReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { SStreamTask* pTask = NULL; code = streamMetaAcquireTask(pMeta, req.streamId, req.taskId, &pTask); - if (pTask == NULL) { + if (pTask == NULL || (code != 0)) { tqError("vgId:%d process set consensus checkpointId req, failed to acquire task:0x%x, it may have been dropped already", pMeta->vgId, req.taskId); - streamMetaAddFailedTask(pMeta, req.streamId, req.taskId); - return TSDB_CODE_SUCCESS; + (void)streamMetaAddFailedTask(pMeta, req.streamId, req.taskId); + return code; } // discard the rsp, since it is expired. @@ -1193,13 +1242,13 @@ int32_t tqStreamTaskProcessConsenChkptIdReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { tqDebug("s-task:%s vgId:%d checkpointId:%" PRId64 " restore to consensus-checkpointId:%" PRId64 " from mnode", pTask->id.idStr, vgId, pTask->chkInfo.checkpointId, req.checkpointId); - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); ASSERT(pTask->chkInfo.checkpointId >= req.checkpointId); if (pTask->chkInfo.consensusTransId >= req.transId) { tqDebug("s-task:%s vgId:%d latest consensus transId:%d, expired consensus trans:%d, discard", pTask->id.idStr, vgId, pTask->chkInfo.consensusTransId, req.transId); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pMeta, pTask); return TSDB_CODE_SUCCESS; } @@ -1215,14 +1264,14 @@ int32_t tqStreamTaskProcessConsenChkptIdReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { } pTask->chkInfo.consensusTransId = req.transId; - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); if (pMeta->role == NODE_ROLE_LEADER) { - /*code = */ tqStreamStartOneTaskAsync(pMeta, pTask->pMsgCb, req.streamId, req.taskId); + code = tqStreamStartOneTaskAsync(pMeta, pTask->pMsgCb, req.streamId, req.taskId); } else { tqDebug("vgId:%d follower not start task:%s", vgId, pTask->id.idStr); } streamMetaReleaseTask(pMeta, pTask); - return TSDB_CODE_SUCCESS; + return code; } \ No newline at end of file diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c index 46c3ba4785..27910d1746 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c @@ -294,6 +294,14 @@ void* tsdbCacherowsReaderClose(void* pReader) { taosMemoryFree(p->pCurrSchema); + if (p->rowKey.numOfPKs > 0) { + for (int32_t i = 0; i < p->rowKey.numOfPKs; i++) { + if (IS_VAR_DATA_TYPE(p->rowKey.pks[i].type)) { + taosMemoryFree(p->rowKey.pks[i].pData); + } + } + } + if (p->pLDataIterArray) { destroySttBlockReader(p->pLDataIterArray, NULL); } @@ -325,13 +333,26 @@ void* tsdbCacherowsReaderClose(void* pReader) { return NULL; } -static void freeItem(void* pItem) { +static void freeItemOfRow(void* pItem) { SLastCol* pCol = (SLastCol*)pItem; if (IS_VAR_DATA_TYPE(pCol->colVal.value.type) && pCol->colVal.value.pData) { taosMemoryFree(pCol->colVal.value.pData); } } +static void freeItemWithPk(void* pItem) { + SLastCol* pCol = (SLastCol*)pItem; + for (int i = 0; i < pCol->rowKey.numOfPKs; i++) { + if (IS_VAR_DATA_TYPE(pCol->rowKey.pks[i].type)) { + taosMemoryFree(pCol->rowKey.pks[i].pData); + } + } + + if (IS_VAR_DATA_TYPE(pCol->colVal.value.type) && pCol->colVal.value.pData) { + taosMemoryFree(pCol->colVal.value.pData); + } +} + static int32_t tsdbCacheQueryReseek(void* pQHandle) { int32_t code = 0; SCacheRowsReader* pReader = pQHandle; @@ -407,6 +428,16 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 struct STColumn* pCol = &pr->pSchema->columns[slotId]; SLastCol p = {.rowKey.ts = INT64_MIN, .colVal.value.type = pCol->type, .colVal.flag = CV_FLAG_NULL}; + if (pr->rowKey.numOfPKs > 0) { + p.rowKey.numOfPKs = pr->rowKey.numOfPKs; + for (int32_t j = 0; j < pr->rowKey.numOfPKs; j++) { + p.rowKey.pks[j].type = pr->pkColumn.type; + if (IS_VAR_DATA_TYPE(pr->pkColumn.type)) { + p.rowKey.pks[j].pData = taosMemoryCalloc(1, pr->pkColumn.bytes); + } + } + } + if (IS_VAR_DATA_TYPE(pCol->type)) { p.colVal.value.pData = taosMemoryCalloc(pCol->bytes, sizeof(char)); } @@ -420,7 +451,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 tsdbCacheGetBatch(pr->pTsdb, uid, pRow, pr, ltype); if (TARRAY_SIZE(pRow) <= 0 || COL_VAL_IS_NONE(&((SLastCol*)TARRAY_DATA(pRow))[0].colVal)) { - taosArrayClearEx(pRow, freeItem); + taosArrayClearEx(pRow, freeItemOfRow); continue; } @@ -432,7 +463,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 SLastCol* p = taosArrayGet(pLastCols, k); SLastCol* pColVal = (SLastCol*)taosArrayGet(pRow, k); - if (pColVal->rowKey.ts > p->rowKey.ts) { + if (tRowKeyCompare(&pColVal->rowKey, &p->rowKey) > 0) { if (!COL_VAL_IS_VALUE(&pColVal->colVal) && HASTYPE(pr->type, CACHESCAN_RETRIEVE_LAST)) { if (!COL_VAL_IS_VALUE(&p->colVal)) { hasNotNullRow = false; @@ -445,6 +476,15 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 hasRes = true; p->rowKey.ts = pColVal->rowKey.ts; + for (int32_t j = 0; j < p->rowKey.numOfPKs; j++) { + if (IS_VAR_DATA_TYPE(p->rowKey.pks[j].type)) { + memcpy(p->rowKey.pks[j].pData, pColVal->rowKey.pks[j].pData, pColVal->rowKey.pks[j].nData); + p->rowKey.pks[j].nData = pColVal->rowKey.pks[j].nData; + } else { + p->rowKey.pks[j].val = pColVal->rowKey.pks[j].val; + } + } + if (k == 0) { if (TARRAY_SIZE(pTableUidList) == 0) { taosArrayPush(pTableUidList, &uid); @@ -483,26 +523,26 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 } } - taosArrayClearEx(pRow, freeItem); + taosArrayClearEx(pRow, freeItemOfRow); } if (hasRes) { saveOneRow(pLastCols, pResBlock, pr, slotIds, dstSlotIds, pRes, pr->idstr); } - taosArrayDestroyEx(pLastCols, freeItem); + taosArrayDestroyEx(pLastCols, freeItemWithPk); } else if (HASTYPE(pr->type, CACHESCAN_RETRIEVE_TYPE_ALL)) { for (int32_t i = pr->tableIndex; i < pr->numOfTables; ++i) { tb_uid_t uid = pTableList[i].uid; tsdbCacheGetBatch(pr->pTsdb, uid, pRow, pr, ltype); if (TARRAY_SIZE(pRow) <= 0 || COL_VAL_IS_NONE(&((SLastCol*)TARRAY_DATA(pRow))[0].colVal)) { - taosArrayClearEx(pRow, freeItem); + taosArrayClearEx(pRow, freeItemOfRow); continue; } saveOneRow(pRow, pResBlock, pr, slotIds, dstSlotIds, pRes, pr->idstr); - taosArrayClearEx(pRow, freeItem); + taosArrayClearEx(pRow, freeItemOfRow); taosArrayPush(pTableUidList, &uid); diff --git a/source/dnode/vnode/src/vnd/vnodeSnapshot.c b/source/dnode/vnode/src/vnd/vnodeSnapshot.c index 75ba2be100..046f12f9e7 100644 --- a/source/dnode/vnode/src/vnd/vnodeSnapshot.c +++ b/source/dnode/vnode/src/vnd/vnodeSnapshot.c @@ -312,8 +312,7 @@ int32_t vnodeSnapRead(SVSnapReader *pReader, uint8_t **ppData, uint32_t *nData) goto _exit; } else { pReader->metaDone = 1; - code = metaSnapReaderClose(&pReader->pMetaReader); - TSDB_CHECK_CODE(code, lino, _exit); + metaSnapReaderClose(&pReader->pMetaReader); } } diff --git a/source/libs/stream/inc/streamInt.h b/source/libs/stream/inc/streamInt.h index 2fe86817e3..93d2edd639 100644 --- a/source/libs/stream/inc/streamInt.h +++ b/source/libs/stream/inc/streamInt.h @@ -231,14 +231,8 @@ void initCheckpointReadyInfo(STaskCheckpointReadyInfo* pReadyInfo, int32_t up int32_t initCheckpointReadyMsg(SStreamTask* pTask, int32_t upstreamNodeId, int32_t upstreamTaskId, int32_t childId, int64_t checkpointId, SRpcMsg* pMsg); -typedef int32_t (*__stream_async_exec_fn_t)(void* param); - -int32_t streamMetaAsyncExec(SStreamMeta* pMeta, __stream_async_exec_fn_t fn, void* param, int32_t* code); void flushStateDataInExecutor(SStreamTask* pTask, SStreamQueueItem* pCheckpointBlock); -void streamMutexLock(TdThreadMutex *pMutex); -void streamMutexUnlock(TdThreadMutex *pMutex); -void streamMutexDestroy(TdThreadMutex *pMutex); #ifdef __cplusplus } diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c index 74fff23c6b..869877c9a8 100644 --- a/source/libs/stream/src/streamBackendRocksdb.c +++ b/source/libs/stream/src/streamBackendRocksdb.c @@ -1540,7 +1540,7 @@ int32_t chkpLoadExtraInfo(char* pChkpIdDir, int64_t* chkpId, int64_t* processId) // compatible with previous version *processId = -1; code = 0; - stError("failed to open file to load extra info, file:%s, reason:%s", pDst, tstrerror(TAOS_SYSTEM_ERROR(errno))); + stWarn("failed to open file to load extra info, file:%s, reason:%s", pDst, tstrerror(TAOS_SYSTEM_ERROR(errno))); goto _EXIT; } @@ -2308,6 +2308,7 @@ _EXIT: taosMemoryFree(cfHandle); return code; } + void* taskDbAddRef(void* pTaskDb) { STaskDbWrapper* pBackend = pTaskDb; return taosAcquireRef(taskDbWrapperId, pBackend->refId); diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c index 6f3b7d8b32..1283f8e20b 100644 --- a/source/libs/stream/src/streamMeta.c +++ b/source/libs/stream/src/streamMeta.c @@ -45,7 +45,7 @@ typedef struct STaskInitTs { SMetaRefMgt gMetaRefMgt; -void metaRefMgtInit(); +int32_t metaRefMgtInit(); void metaRefMgtCleanup(); int32_t metaRefMgtAdd(int64_t vgId, int64_t* rid); @@ -56,9 +56,14 @@ static void streamMetaEnvInit() { streamMetaId = taosOpenRef(64, streamMetaCloseImpl); - metaRefMgtInit(); - int32_t code = streamTimerInit(); - if (code != 0) { + int32_t code = metaRefMgtInit(); + if (code) { + stError("failed to init stream meta mgmt env, start failed"); + return; + } + + code = streamTimerInit(); + if (code) { stError("failed to init stream meta env, start failed"); } } @@ -66,17 +71,29 @@ static void streamMetaEnvInit() { void streamMetaInit() { (void) taosThreadOnce(&streamMetaModuleInit, streamMetaEnvInit); } void streamMetaCleanup() { - taosCloseRef(streamBackendId); - taosCloseRef(streamBackendCfWrapperId); - taosCloseRef(streamMetaId); + (void) taosCloseRef(streamBackendId); + (void) taosCloseRef(streamBackendCfWrapperId); + (void) taosCloseRef(streamMetaId); metaRefMgtCleanup(); streamTimerCleanUp(); } -void metaRefMgtInit() { - taosThreadMutexInit(&(gMetaRefMgt.mutex), NULL); - gMetaRefMgt.pTable = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); +int32_t metaRefMgtInit() { + int32_t code = taosThreadMutexInit(&(gMetaRefMgt.mutex), NULL); + if (code) { + return code; + } + + if (code == 0) { + gMetaRefMgt.pTable = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); + } + + if (gMetaRefMgt.pTable == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } else { + return code; + } } void metaRefMgtCleanup() { @@ -96,20 +113,34 @@ void metaRefMgtCleanup() { } int32_t metaRefMgtAdd(int64_t vgId, int64_t* rid) { + int32_t code = 0; + void* p = NULL; + streamMutexLock(&gMetaRefMgt.mutex); - void* p = taosHashGet(gMetaRefMgt.pTable, &vgId, sizeof(vgId)); + p = taosHashGet(gMetaRefMgt.pTable, &vgId, sizeof(vgId)); if (p == NULL) { SArray* list = taosArrayInit(8, sizeof(void*)); - taosArrayPush(list, &rid); - taosHashPut(gMetaRefMgt.pTable, &vgId, sizeof(vgId), &list, sizeof(void*)); + p = taosArrayPush(list, &rid); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + code = taosHashPut(gMetaRefMgt.pTable, &vgId, sizeof(vgId), &list, sizeof(void*)); + if (code) { + stError("vgId:%d failed to put into metaRef table, rid:%" PRId64, (int32_t) vgId, *rid); + return code; + } } else { SArray* list = *(SArray**)p; - taosArrayPush(list, &rid); + void* px = taosArrayPush(list, &rid); + if (px == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + } } streamMutexUnlock(&gMetaRefMgt.mutex); - return 0; + return code; } int32_t streamMetaOpenTdb(SStreamMeta* pMeta) { @@ -141,19 +172,25 @@ enum STREAM_STATE_VER { }; int32_t streamMetaCheckBackendCompatible(SStreamMeta* pMeta) { - int8_t ret = STREAM_STATA_COMPATIBLE; - TBC* pCur = NULL; - - if (tdbTbcOpen(pMeta->pTaskDb, &pCur, NULL) < 0) { // no task info, no stream - return ret; - } - + int8_t ret = STREAM_STATA_COMPATIBLE; + TBC* pCur = NULL; + int32_t code = 0; void* pKey = NULL; int32_t kLen = 0; void* pVal = NULL; int32_t vLen = 0; - tdbTbcMoveToFirst(pCur); + if (tdbTbcOpen(pMeta->pTaskDb, &pCur, NULL) < 0) { // no task info, no stream + return ret; + } + + code = tdbTbcMoveToFirst(pCur); + if (code) { + (void) tdbTbcClose(pCur); + stError("vgId:%d failed to open stream meta file cursor, not perform compatible check", pMeta->vgId); + return ret; + } + while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) { if (pVal == NULL || vLen == 0) { break; @@ -178,7 +215,7 @@ int32_t streamMetaCheckBackendCompatible(SStreamMeta* pMeta) { tdbFree(pKey); tdbFree(pVal); - tdbTbcClose(pCur); + (void) tdbTbcClose(pCur); return ret; } @@ -244,7 +281,11 @@ int32_t streamTaskSetDb(SStreamMeta* pMeta, SStreamTask* pTask, const char* key) streamMutexLock(&pMeta->backendMutex); void** ppBackend = taosHashGet(pMeta->pTaskDbUnique, key, strlen(key)); if ((ppBackend != NULL) && (*ppBackend != NULL)) { - taskDbAddRef(*ppBackend); + void* p = taskDbAddRef(*ppBackend); + if (p == NULL) { + stError("s-task:0x%x failed to ref backend", pTask->id.taskId); + return TSDB_CODE_FAILED; + } STaskDbWrapper* pBackend = *ppBackend; pBackend->pMeta = pMeta; @@ -278,7 +319,10 @@ int32_t streamTaskSetDb(SStreamMeta* pMeta, SStreamTask* pTask, const char* key) if (processVer != -1) pTask->chkInfo.processedVer = processVer; - taosHashPut(pMeta->pTaskDbUnique, key, strlen(key), &pBackend, sizeof(void*)); + int32_t code = taosHashPut(pMeta->pTaskDbUnique, key, strlen(key), &pBackend, sizeof(void*)); + if (code) { + stError("s-task:0x%x failed to put taskDb backend, code:out of memory", pTask->id.taskId); + } streamMutexUnlock(&pMeta->backendMutex); stDebug("s-task:0x%x set backend %p", pTask->id.taskId, pBackend); @@ -290,7 +334,10 @@ void streamMetaRemoveDB(void* arg, char* key) { SStreamMeta* pMeta = arg; streamMutexLock(&pMeta->backendMutex); - taosHashRemove(pMeta->pTaskDbUnique, key, strlen(key)); + int32_t code = taosHashRemove(pMeta->pTaskDbUnique, key, strlen(key)); + if (code) { + stError("vgId:%d failed to remove key:%s in taskDbUnique map", pMeta->vgId, key); + } streamMutexUnlock(&pMeta->backendMutex); } @@ -398,12 +445,22 @@ int32_t streamMetaOpen(const char* path, void* ahandle, FTaskBuild buildTaskFn, } #endif - taosThreadRwlockInit(&pMeta->lock, &attr); - taosThreadRwlockAttrDestroy(&attr); + code = taosThreadRwlockInit(&pMeta->lock, &attr); + if (code) { + goto _err; + } + + code = taosThreadRwlockAttrDestroy(&attr); + if (code) { + goto _err; + } int64_t* pRid = taosMemoryMalloc(sizeof(int64_t)); memcpy(pRid, &pMeta->rid, sizeof(pMeta->rid)); - metaRefMgtAdd(pMeta->vgId, pRid); + code = metaRefMgtAdd(pMeta->vgId, pRid); + if (code) { + goto _err; + } code = createMetaHbInfo(pRid, &pMeta->pHbInfo); if (code != TSDB_CODE_SUCCESS) { @@ -416,7 +473,8 @@ int32_t streamMetaOpen(const char* path, void* ahandle, FTaskBuild buildTaskFn, if (pMeta->bkdChkptMgt == NULL) { goto _err; } - taosThreadMutexInit(&pMeta->backendMutex, NULL); + + code = taosThreadMutexInit(&pMeta->backendMutex, NULL); *p = pMeta; return code; @@ -425,9 +483,9 @@ _err: taosMemoryFree(pMeta->path); if (pMeta->pTasksMap) taosHashCleanup(pMeta->pTasksMap); if (pMeta->pTaskList) taosArrayDestroy(pMeta->pTaskList); - if (pMeta->pTaskDb) tdbTbClose(pMeta->pTaskDb); - if (pMeta->pCheckpointDb) tdbTbClose(pMeta->pCheckpointDb); - if (pMeta->db) tdbClose(pMeta->db); + if (pMeta->pTaskDb) (void)tdbTbClose(pMeta->pTaskDb); + if (pMeta->pCheckpointDb) (void)tdbTbClose(pMeta->pCheckpointDb); + if (pMeta->db) (void) tdbClose(pMeta->db); if (pMeta->pHbInfo) taosMemoryFreeClear(pMeta->pHbInfo); if (pMeta->updateInfo.pTasks) taosHashCleanup(pMeta->updateInfo.pTasks); if (pMeta->startInfo.pReadyTaskSet) taosHashCleanup(pMeta->startInfo.pReadyTaskSet); @@ -473,7 +531,7 @@ void streamMetaClear(SStreamMeta* pMeta) { // release the ref by timer if (p->info.delaySchedParam != 0 && p->info.fillHistory == 0) { // one more ref in timer stDebug("s-task:%s stop schedTimer, and (before) desc ref:%d", p->id.idStr, p->refCnt); - taosTmrStop(p->schedInfo.pDelayTimer); + (void) taosTmrStop(p->schedInfo.pDelayTimer); p->info.delaySchedParam = 0; streamMetaReleaseTask(pMeta, p); } @@ -481,7 +539,11 @@ void streamMetaClear(SStreamMeta* pMeta) { streamMetaReleaseTask(pMeta, p); } - taosRemoveRef(streamBackendId, pMeta->streamBackendRid); + int32_t code = taosRemoveRef(streamBackendId, pMeta->streamBackendRid); + if (code) { + stError("vgId:%d remove stream backend Ref failed, rid:%"PRId64, pMeta->vgId, pMeta->streamBackendRid); + } + taosHashClear(pMeta->pTasksMap); taosArrayClear(pMeta->pTaskList); @@ -502,14 +564,7 @@ void streamMetaClose(SStreamMeta* pMeta) { if (pMeta == NULL) { return; } - - // int64_t rid = *(int64_t*)pMeta->pRid; - // if (taosTmrStop(pMeta->hbInfo.hbTmr)) { - // taosMemoryFree(pMeta->pRid); - // } else { - // // do nothing, stop by timer thread - // } - taosRemoveRef(streamMetaId, pMeta->rid); + (void) taosRemoveRef(streamMetaId, pMeta->rid); } void streamMetaCloseImpl(void* arg) { @@ -525,10 +580,11 @@ void streamMetaCloseImpl(void* arg) { streamMetaClear(pMeta); streamMetaWUnLock(pMeta); - tdbAbort(pMeta->db, pMeta->txn); - tdbTbClose(pMeta->pTaskDb); - tdbTbClose(pMeta->pCheckpointDb); - tdbClose(pMeta->db); + // already log the error, ignore here + (void) tdbAbort(pMeta->db, pMeta->txn); + (void) tdbTbClose(pMeta->pTaskDb); + (void) tdbTbClose(pMeta->pCheckpointDb); + (void) tdbClose(pMeta->db); taosArrayDestroy(pMeta->pTaskList); taosArrayDestroy(pMeta->chkpSaved); @@ -552,7 +608,7 @@ void streamMetaCloseImpl(void* arg) { bkdMgtDestroy(pMeta->bkdChkptMgt); pMeta->role = NODE_ROLE_UNINIT; - taosThreadRwlockDestroy(&pMeta->lock); + (void) taosThreadRwlockDestroy(&pMeta->lock); taosMemoryFree(pMeta); stDebug("vgId:%d end to close stream meta", vgId); @@ -568,9 +624,10 @@ int32_t streamMetaSaveTask(SStreamMeta* pMeta, SStreamTask* pTask) { if (code < 0) { return -1; } + buf = taosMemoryCalloc(1, len); if (buf == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } if (pTask->ver < SSTREAM_TASK_SUBTABLE_CHANGED_VER) { @@ -579,13 +636,19 @@ int32_t streamMetaSaveTask(SStreamMeta* pMeta, SStreamTask* pTask) { SEncoder encoder = {0}; tEncoderInit(&encoder, buf, len); - tEncodeStreamTask(&encoder, pTask); + code = tEncodeStreamTask(&encoder, pTask); tEncoderClear(&encoder); + if (code == -1) { + stError("s-task:%s vgId:%d task meta encode failed, code:%s", pTask->id.idStr, vgId, tstrerror(code)); + return TSDB_CODE_INVALID_MSG; + } + int64_t id[2] = {pTask->id.streamId, pTask->id.taskId}; code = tdbTbUpsert(pMeta->pTaskDb, id, STREAM_TASK_KEY_LEN, buf, len, pMeta->txn); if (code != TSDB_CODE_SUCCESS) { + code = terrno; stError("s-task:%s vgId:%d task meta save to disk failed, code:%s", pTask->id.idStr, vgId, tstrerror(terrno)); } else { stDebug("s-task:%s vgId:%d task meta save to disk", pTask->id.idStr, vgId); @@ -612,33 +675,44 @@ int32_t streamMetaRemoveTask(SStreamMeta* pMeta, STaskId* pTaskId) { int32_t streamMetaRegisterTask(SStreamMeta* pMeta, int64_t ver, SStreamTask* pTask, bool* pAdded) { *pAdded = false; + int32_t code = 0; STaskId id = streamTaskGetTaskId(pTask); void* p = taosHashGet(pMeta->pTasksMap, &id, sizeof(id)); if (p != NULL) { - return 0; + stDebug("s-task:%" PRIx64 " already exist in meta, no need to register", id.taskId); + return code; } - if (pMeta->buildTaskFn(pMeta->ahandle, pTask, ver) < 0) { - return -1; + if ((code = pMeta->buildTaskFn(pMeta->ahandle, pTask, ver)) != 0) { + return code; } - taosArrayPush(pMeta->pTaskList, &pTask->id); - taosHashPut(pMeta->pTasksMap, &id, sizeof(id), &pTask, POINTER_BYTES); - - if (streamMetaSaveTask(pMeta, pTask) < 0) { - return -1; + p = taosArrayPush(pMeta->pTaskList, &pTask->id); + if (p == NULL) { + stError("s-task:0x%"PRIx64" failed to register task into meta-list, code: out of memory", id.taskId); + return TSDB_CODE_OUT_OF_MEMORY; } - if (streamMetaCommit(pMeta) < 0) { - return -1; + code = taosHashPut(pMeta->pTasksMap, &id, sizeof(id), &pTask, POINTER_BYTES); + if (code) { + stError("s-task:0x%"PRIx64" failed to register task into meta-list, code: out of memory", id.taskId); + return code; + } + + if ((code = streamMetaSaveTask(pMeta, pTask)) != 0) { + return code; + } + + if ((code = streamMetaCommit(pMeta)) != 0) { + return code; } if (pTask->info.fillHistory == 0) { - atomic_add_fetch_32(&pMeta->numOfStreamTasks, 1); + (void) atomic_add_fetch_32(&pMeta->numOfStreamTasks, 1); } *pAdded = true; - return 0; + return code; } int32_t streamMetaGetNumOfTasks(SStreamMeta* pMeta) { @@ -703,7 +777,7 @@ static void doRemoveIdFromList(SArray* pTaskList, int32_t num, SStreamTaskId* id static int32_t streamTaskSendTransSuccessMsg(SStreamTask* pTask, void* param) { if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) { - streamTaskSendCheckpointSourceRsp(pTask); + (void) streamTaskSendCheckpointSourceRsp(pTask); } return 0; } @@ -726,7 +800,7 @@ int32_t streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t t } // handle the dropping event - streamTaskHandleEventAsync(pTask->status.pSM, TASK_EVENT_DROPPING, streamTaskSendTransSuccessMsg, NULL); + (void) streamTaskHandleEventAsync(pTask->status.pSM, TASK_EVENT_DROPPING, streamTaskSendTransSuccessMsg, NULL); } else { stDebug("vgId:%d failed to find the task:0x%x, it may be dropped already", pMeta->vgId, taskId); streamMetaWUnLock(pMeta); @@ -765,12 +839,12 @@ int32_t streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t t pTask = *ppTask; // it is an fill-history task, remove the related stream task's id that points to it if (pTask->info.fillHistory == 0) { - atomic_sub_fetch_32(&pMeta->numOfStreamTasks, 1); + (void) atomic_sub_fetch_32(&pMeta->numOfStreamTasks, 1); } - taosHashRemove(pMeta->pTasksMap, &id, sizeof(id)); + (void) taosHashRemove(pMeta->pTasksMap, &id, sizeof(id)); doRemoveIdFromList(pMeta->pTaskList, (int32_t)taosArrayGetSize(pMeta->pTaskList), &pTask->id); - streamMetaRemoveTask(pMeta, &id); + (void) streamMetaRemoveTask(pMeta, &id); ASSERT(taosHashGetSize(pMeta->pTasksMap) == taosArrayGetSize(pMeta->pTaskList)); streamMetaWUnLock(pMeta); @@ -778,7 +852,7 @@ int32_t streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t t ASSERT(pTask->status.timerActive == 0); if (pTask->info.delaySchedParam != 0 && pTask->info.fillHistory == 0) { stDebug("s-task:%s stop schedTimer, and (before) desc ref:%d", pTask->id.idStr, pTask->refCnt); - taosTmrStop(pTask->schedInfo.pDelayTimer); + (void) taosTmrStop(pTask->schedInfo.pDelayTimer); pTask->info.delaySchedParam = 0; streamMetaReleaseTask(pMeta, pTask); } @@ -823,9 +897,11 @@ int32_t streamMetaCommit(SStreamMeta* pMeta) { int64_t streamMetaGetLatestCheckpointId(SStreamMeta* pMeta) { int64_t checkpointId = 0; + int32_t code = 0; TBC* pCur = NULL; if (tdbTbcOpen(pMeta->pTaskDb, &pCur, NULL) < 0) { + stError("failed to open stream meta file, the latest checkpointId is 0, vgId:%d", pMeta->vgId); return checkpointId; } @@ -835,7 +911,13 @@ int64_t streamMetaGetLatestCheckpointId(SStreamMeta* pMeta) { int32_t vLen = 0; SDecoder decoder; - tdbTbcMoveToFirst(pCur); + code = tdbTbcMoveToFirst(pCur); + if (code) { + (void) tdbTbcClose(pCur); + stError("failed to open stream meta file cursor, the latest checkpointId is 0, vgId:%d", pMeta->vgId); + return checkpointId; + } + while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) { if (pVal == NULL || vLen == 0) { break; @@ -854,8 +936,8 @@ int64_t streamMetaGetLatestCheckpointId(SStreamMeta* pMeta) { tdbFree(pKey); tdbFree(pVal); - tdbTbcClose(pCur); + (void)tdbTbcClose(pCur); return checkpointId; } @@ -867,23 +949,34 @@ void streamMetaLoadAllTasks(SStreamMeta* pMeta) { void* pVal = NULL; int32_t vLen = 0; SDecoder decoder; + int32_t vgId = 0; + int32_t code = 0; + SArray* pRecycleList = NULL; if (pMeta == NULL) { return; } - SArray* pRecycleList = taosArrayInit(4, sizeof(STaskId)); - int32_t vgId = pMeta->vgId; + pRecycleList = taosArrayInit(4, sizeof(STaskId)); + + vgId = pMeta->vgId; stInfo("vgId:%d load stream tasks from meta files", vgId); - int32_t code = tdbTbcOpen(pMeta->pTaskDb, &pCur, NULL); + code = tdbTbcOpen(pMeta->pTaskDb, &pCur, NULL); if (code != TSDB_CODE_SUCCESS) { stError("vgId:%d failed to open stream meta, code:%s, not load any stream tasks", vgId, tstrerror(terrno)); taosArrayDestroy(pRecycleList); return; } - tdbTbcMoveToFirst(pCur); + code = tdbTbcMoveToFirst(pCur); + if (code) { + stError("vgId:%d failed to open stream meta cursor, code:%s, not load any stream tasks", vgId, tstrerror(terrno)); + taosArrayDestroy(pRecycleList); + (void) tdbTbcClose(pCur); + return; + } + while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) { if (pVal == NULL || vLen == 0) { break; @@ -913,7 +1006,7 @@ void streamMetaLoadAllTasks(SStreamMeta* pMeta) { tFreeStreamTask(pTask); STaskId id = streamTaskGetTaskId(pTask); - taosArrayPush(pRecycleList, &id); + (void) taosArrayPush(pRecycleList, &id); int32_t total = taosArrayGetSize(pRecycleList); stDebug("s-task:0x%x is already dropped, add into recycle list, total:%d", taskId, total); @@ -934,7 +1027,7 @@ void streamMetaLoadAllTasks(SStreamMeta* pMeta) { continue; } - taosArrayPush(pMeta->pTaskList, &pTask->id); + (void) taosArrayPush(pMeta->pTaskList, &pTask->id); } else { // todo this should replace the existed object put by replay creating stream task msg from mnode stError("s-task:0x%x already added into table meta by replaying WAL, need check", pTask->id.taskId); @@ -944,17 +1037,17 @@ void streamMetaLoadAllTasks(SStreamMeta* pMeta) { if (taosHashPut(pMeta->pTasksMap, &id, sizeof(id), &pTask, POINTER_BYTES) != 0) { stError("s-task:0x%x failed to put into hashTable, code:%s, continue", pTask->id.taskId, tstrerror(terrno)); - taosArrayPop(pMeta->pTaskList); + (void) taosArrayPop(pMeta->pTaskList); tFreeStreamTask(pTask); continue; } if (pTask->info.fillHistory == 0) { - atomic_add_fetch_32(&pMeta->numOfStreamTasks, 1); + (void) atomic_add_fetch_32(&pMeta->numOfStreamTasks, 1); } if (streamTaskShouldPause(pTask)) { - atomic_add_fetch_32(&pMeta->numOfPausedTasks, 1); + (void) atomic_add_fetch_32(&pMeta->numOfPausedTasks, 1); } ASSERT(pTask->status.downstreamReady == 0); @@ -970,7 +1063,7 @@ void streamMetaLoadAllTasks(SStreamMeta* pMeta) { if (taosArrayGetSize(pRecycleList) > 0) { for (int32_t i = 0; i < taosArrayGetSize(pRecycleList); ++i) { STaskId* pId = taosArrayGet(pRecycleList, i); - streamMetaRemoveTask(pMeta, pId); + (void) streamMetaRemoveTask(pMeta, pId); } } @@ -998,7 +1091,7 @@ bool streamMetaTaskInTimer(SStreamMeta* pMeta) { SStreamTask* pTask = *(SStreamTask**)pIter; if (pTask->status.timerActive >= 1) { stDebug("s-task:%s in timer, blocking tasks in vgId:%d restart, set closing again", pTask->id.idStr, pMeta->vgId); - streamTaskStop(pTask); + (void) streamTaskStop(pTask); inTimer = true; } } @@ -1031,7 +1124,7 @@ void streamMetaNotifyClose(SStreamMeta* pMeta) { SStreamTask* pTask = *(SStreamTask**)pIter; stDebug("vgId:%d s-task:%s set task closing flag", vgId, pTask->id.idStr); - streamTaskStop(pTask); + (void) streamTaskStop(pTask); } streamMetaWUnLock(pMeta); @@ -1050,7 +1143,16 @@ void streamMetaNotifyClose(SStreamMeta* pMeta) { void streamMetaStartHb(SStreamMeta* pMeta) { int64_t* pRid = taosMemoryMalloc(sizeof(int64_t)); - metaRefMgtAdd(pMeta->vgId, pRid); + if (pRid == NULL) { + stError("vgId:%d failed to prepare the metaHb to mnode, hbMsg will not started, code: out of memory", pMeta->vgId); + return; + } + + int32_t code = metaRefMgtAdd(pMeta->vgId, pRid); + if (code) { + return; + } + *pRid = pMeta->rid; streamMetaHbToMnode(pRid, NULL); } @@ -1069,7 +1171,7 @@ void streamMetaResetStartInfo(STaskStartInfo* pStartInfo, int32_t vgId) { void streamMetaRLock(SStreamMeta* pMeta) { // stTrace("vgId:%d meta-rlock", pMeta->vgId); - taosThreadRwlockRdlock(&pMeta->lock); + (void) taosThreadRwlockRdlock(&pMeta->lock); } void streamMetaRUnLock(SStreamMeta* pMeta) { @@ -1084,30 +1186,13 @@ void streamMetaRUnLock(SStreamMeta* pMeta) { void streamMetaWLock(SStreamMeta* pMeta) { // stTrace("vgId:%d meta-wlock", pMeta->vgId); - taosThreadRwlockWrlock(&pMeta->lock); + (void) taosThreadRwlockWrlock(&pMeta->lock); // stTrace("vgId:%d meta-wlock completed", pMeta->vgId); } void streamMetaWUnLock(SStreamMeta* pMeta) { // stTrace("vgId:%d meta-wunlock", pMeta->vgId); - taosThreadRwlockUnlock(&pMeta->lock); -} - -static void execHelper(struct SSchedMsg* pSchedMsg) { - __async_exec_fn_t execFn = (__async_exec_fn_t)pSchedMsg->ahandle; - int32_t code = execFn(pSchedMsg->thandle); - if (code != 0 && pSchedMsg->msg != NULL) { - *(int32_t*)pSchedMsg->msg = code; - } -} - -int32_t streamMetaAsyncExec(SStreamMeta* pMeta, __stream_async_exec_fn_t fn, void* param, int32_t* code) { - SSchedMsg schedMsg = {0}; - schedMsg.fp = execHelper; - schedMsg.ahandle = fn; - schedMsg.thandle = param; - schedMsg.msg = code; - return taosScheduleTask(pMeta->qHandle, &schedMsg); + (void) taosThreadRwlockUnlock(&pMeta->lock); } int32_t streamMetaSendMsgBeforeCloseTasks(SStreamMeta* pMeta, SArray** pList) { @@ -1195,10 +1280,10 @@ static int32_t prepareBeforeStartTasks(SStreamMeta* pMeta, SArray** pList, int64 taosHashClear(pMeta->startInfo.pFailedTaskSet); pMeta->startInfo.startTs = now; - streamMetaResetTaskStatus(pMeta); + int32_t code = streamMetaResetTaskStatus(pMeta); streamMetaWUnLock(pMeta); - return TSDB_CODE_SUCCESS; + return code; } // restore the checkpoint id by negotiating the latest consensus checkpoint id @@ -1233,7 +1318,7 @@ int32_t streamMetaStartAllTasks(SStreamMeta* pMeta) { code = streamMetaAcquireTask(pMeta, pTaskId->streamId, pTaskId->taskId, &pTask); if (pTask == NULL) { stError("vgId:%d failed to acquire task:0x%x during start tasks", pMeta->vgId, pTaskId->taskId); - streamMetaAddFailedTask(pMeta, pTaskId->streamId, pTaskId->taskId); + (void) streamMetaAddFailedTask(pMeta, pTaskId->streamId, pTaskId->taskId); continue; } @@ -1256,7 +1341,7 @@ int32_t streamMetaStartAllTasks(SStreamMeta* pMeta) { code = streamMetaAcquireTask(pMeta, pTaskId->streamId, pTaskId->taskId, &pTask); if (pTask == NULL) { stError("vgId:%d failed to acquire task:0x%x during start tasks", pMeta->vgId, pTaskId->taskId); - streamMetaAddFailedTask(pMeta, pTaskId->streamId, pTaskId->taskId); + (void) streamMetaAddFailedTask(pMeta, pTaskId->streamId, pTaskId->taskId); continue; } @@ -1274,7 +1359,7 @@ int32_t streamMetaStartAllTasks(SStreamMeta* pMeta) { if (HAS_RELATED_FILLHISTORY_TASK(pTask)) { stDebug("s-task:%s downstream ready, no need to check downstream, check only related fill-history task", pTask->id.idStr); - streamLaunchFillHistoryTask(pTask); + (void) streamLaunchFillHistoryTask(pTask); // todo: how about retry launch fill-history task? } (void) streamMetaAddTaskLaunchResult(pMeta, pTaskId->streamId, pTaskId->taskId, pInfo->checkTs, pInfo->readyTs, true); @@ -1340,7 +1425,7 @@ int32_t streamMetaStopAllTasks(SStreamMeta* pMeta) { continue; } - streamTaskStop(pTask); + (void) streamTaskStop(pTask); streamMetaReleaseTask(pMeta, pTask); } @@ -1380,7 +1465,7 @@ int32_t streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t tas code = streamMetaAcquireTask(pMeta, streamId, taskId, &pTask); if (pTask == NULL) { stError("vgId:%d failed to acquire task:0x%x when starting task", pMeta->vgId, taskId); - streamMetaAddFailedTask(pMeta, streamId, taskId); + (void) streamMetaAddFailedTask(pMeta, streamId, taskId); return TSDB_CODE_STREAM_TASK_IVLD_STATUS; } @@ -1471,7 +1556,10 @@ int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int3 SHashObj* pDst = ready ? pStartInfo->pReadyTaskSet : pStartInfo->pFailedTaskSet; STaskInitTs initTs = {.start = startTs, .end = endTs, .success = ready}; - taosHashPut(pDst, &id, sizeof(id), &initTs, sizeof(STaskInitTs)); + int32_t code = taosHashPut(pDst, &id, sizeof(id), &initTs, sizeof(STaskInitTs)); + if (code) { + + } int32_t numOfTotal = streamMetaGetNumOfTasks(pMeta); int32_t numOfRecv = taosHashGetSize(pStartInfo->pReadyTaskSet) + taosHashGetSize(pStartInfo->pFailedTaskSet); @@ -1491,14 +1579,14 @@ int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int3 streamMetaResetStartInfo(pStartInfo, pMeta->vgId); streamMetaWUnLock(pMeta); - pStartInfo->completeFn(pMeta); + code = pStartInfo->completeFn(pMeta); } else { streamMetaWUnLock(pMeta); stDebug("vgId:%d recv check downstream results, s-task:0x%x succ:%d, received:%d, total:%d", pMeta->vgId, taskId, ready, numOfRecv, numOfTotal); } - return TSDB_CODE_SUCCESS; + return code; } int32_t streamMetaResetTaskStatus(SStreamMeta* pMeta) { @@ -1572,19 +1660,26 @@ void streamMetaAddIntoUpdateTaskList(SStreamMeta* pMeta, SStreamTask* pTask, SSt int64_t startTs) { const char* id = pTask->id.idStr; int32_t vgId = pTask->pMeta->vgId; + int32_t code = 0; // keep the already updated info STaskUpdateEntry entry = {.streamId = pTask->id.streamId, .taskId = pTask->id.taskId, .transId = transId}; - taosHashPut(pMeta->updateInfo.pTasks, &entry, sizeof(entry), NULL, 0); + code = taosHashPut(pMeta->updateInfo.pTasks, &entry, sizeof(entry), NULL, 0); + if (code != 0) { + stError("s-task:%s failed to put updateTask into update list", id); + } int64_t el = taosGetTimestampMs() - startTs; if (pHTask != NULL) { STaskUpdateEntry hEntry = {.streamId = pHTask->id.streamId, .taskId = pHTask->id.taskId, .transId = transId}; - taosHashPut(pMeta->updateInfo.pTasks, &hEntry, sizeof(hEntry), NULL, 0); - - stDebug("s-task:%s vgId:%d transId:%d task nodeEp update completed, streamTask/hTask closed, elapsed:%" PRId64 - " ms", - id, vgId, transId, el); + code = taosHashPut(pMeta->updateInfo.pTasks, &hEntry, sizeof(hEntry), NULL, 0); + if (code != 0) { + stError("s-task:%s failed to put updateTask into update list", id); + } else { + stDebug("s-task:%s vgId:%d transId:%d task nodeEp update completed, streamTask/hTask closed, elapsed:%" PRId64 + " ms", + id, vgId, transId, el); + } } else { stDebug("s-task:%s vgId:%d transId:%d task nodeEp update completed, streamTask closed, elapsed time:%" PRId64 "ms", id, vgId, transId, el); diff --git a/source/libs/stream/src/streamMsg.c b/source/libs/stream/src/streamMsg.c index b08280f9ed..bc0faacb32 100644 --- a/source/libs/stream/src/streamMsg.c +++ b/source/libs/stream/src/streamMsg.c @@ -549,7 +549,7 @@ int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) { if (tEncodeCStrWithLen(pEncoder, pTask->reserve, sizeof(pTask->reserve) - 1) < 0) return -1; tEndEncode(pEncoder); - return pEncoder->pos; + return 0; } int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) { diff --git a/source/libs/stream/src/streamSnapshot.c b/source/libs/stream/src/streamSnapshot.c index 02e4ed8d8b..3c27210a23 100644 --- a/source/libs/stream/src/streamSnapshot.c +++ b/source/libs/stream/src/streamSnapshot.c @@ -130,7 +130,6 @@ int32_t streamGetFileSize(char* path, char* name, int64_t* sz) { int32_t ret = 0; char* fullname = taosMemoryCalloc(1, strlen(path) + 32); - sprintf(fullname, "%s%s%s", path, TD_DIRSEP, name); ret = taosStatFile(fullname, sz, NULL, NULL); @@ -185,48 +184,89 @@ void snapFileDebugInfo(SBackendSnapFile2* pSnapFile) { } int32_t snapFileGenMeta(SBackendSnapFile2* pSnapFile) { + void* p = NULL; SBackendFileItem item = {0}; item.ref = 1; + // current item.name = pSnapFile->pCurrent; item.type = ROCKSDB_CURRENT_TYPE; - streamGetFileSize(pSnapFile->path, item.name, &item.size); - taosArrayPush(pSnapFile->pFileList, &item); + int32_t code = streamGetFileSize(pSnapFile->path, item.name, &item.size); + if (code) { + stError("failed to get file size"); + return code; + } + + p = taosArrayPush(pSnapFile->pFileList, &item); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } // mainfest item.name = pSnapFile->pMainfest; item.type = ROCKSDB_MAINFEST_TYPE; - streamGetFileSize(pSnapFile->path, item.name, &item.size); - taosArrayPush(pSnapFile->pFileList, &item); + code = streamGetFileSize(pSnapFile->path, item.name, &item.size); + if (code) { + return code; + } + + p = taosArrayPush(pSnapFile->pFileList, &item); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } // options item.name = pSnapFile->pOptions; item.type = ROCKSDB_OPTIONS_TYPE; - streamGetFileSize(pSnapFile->path, item.name, &item.size); - taosArrayPush(pSnapFile->pFileList, &item); + code = streamGetFileSize(pSnapFile->path, item.name, &item.size); + if (code) { + return code; + } + + p = taosArrayPush(pSnapFile->pFileList, &item); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + // sst for (int32_t i = 0; i < taosArrayGetSize(pSnapFile->pSst); i++) { char* sst = taosArrayGetP(pSnapFile->pSst, i); item.name = sst; item.type = ROCKSDB_SST_TYPE; - streamGetFileSize(pSnapFile->path, item.name, &item.size); - taosArrayPush(pSnapFile->pFileList, &item); + code = streamGetFileSize(pSnapFile->path, item.name, &item.size); + if (code) { + return code; + } + + p = taosArrayPush(pSnapFile->pFileList, &item); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } + // meta item.name = pSnapFile->pCheckpointMeta; item.type = ROCKSDB_CHECKPOINT_META_TYPE; if (streamGetFileSize(pSnapFile->path, item.name, &item.size) == 0) { - taosArrayPush(pSnapFile->pFileList, &item); + p = taosArrayPush(pSnapFile->pFileList, &item); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } item.name = pSnapFile->pCheckpointSelfcheck; item.type = ROCKSDB_CHECKPOINT_SELFCHECK_TYPE; if (streamGetFileSize(pSnapFile->path, item.name, &item.size) == 0) { - taosArrayPush(pSnapFile->pFileList, &item); + p = taosArrayPush(pSnapFile->pFileList, &item); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } + return 0; } + int32_t snapFileReadMeta(SBackendSnapFile2* pSnapFile) { int32_t code = 0; TdDirPtr pDir = taosOpenDir(pSnapFile->path); @@ -288,12 +328,18 @@ int32_t snapFileReadMeta(SBackendSnapFile2* pSnapFile) { code = TSDB_CODE_OUT_OF_MEMORY; break; } - taosArrayPush(pSnapFile->pSst, &sst); + + void* p = taosArrayPush(pSnapFile->pSst, &sst); + if (p == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } } } - taosCloseDir(&pDir); - return code; + + return taosCloseDir(&pDir); } + int32_t streamBackendSnapInitFile(char* metaPath, SStreamTaskSnap* pSnap, SBackendSnapFile2* pSnapFile) { int32_t code = 0; int32_t nBytes = 0; @@ -359,13 +405,16 @@ void snapFileDestroy(SBackendSnapFile2* pSnap) { } taosArrayDestroy(pSnap->pFileList); taosArrayDestroy(pSnap->pSst); - taosCloseFile(&pSnap->fd); - - return; + int32_t code = taosCloseFile(&pSnap->fd); + if (code) { + stError("failed to close snapshot fd"); + } } + int32_t streamSnapHandleInit(SStreamSnapHandle* pHandle, char* path, void* pMeta) { - // impl later int32_t code = 0; + SArray* pDbSnapSet = NULL; + SArray* pSnapInfoSet = taosArrayInit(4, sizeof(SStreamTaskSnap)); if (pSnapInfoSet == NULL) { return TSDB_CODE_OUT_OF_MEMORY; @@ -374,15 +423,13 @@ int32_t streamSnapHandleInit(SStreamSnapHandle* pHandle, char* path, void* pMeta code = streamCreateTaskDbSnapInfo(pMeta, path, pSnapInfoSet); if (code != 0) { stError("failed to do task db snap info, reason:%s", tstrerror(code)); - taosArrayDestroy(pSnapInfoSet); - return code; + goto _err; } - SArray* pDbSnapSet = taosArrayInit(8, sizeof(SBackendSnapFile2)); + pDbSnapSet = taosArrayInit(8, sizeof(SBackendSnapFile2)); if (pDbSnapSet == NULL) { - taosArrayDestroy(pSnapInfoSet); code = TSDB_CODE_OUT_OF_MEMORY; - return code; + goto _err; } for (int32_t i = 0; i < taosArrayGetSize(pSnapInfoSet); i++) { @@ -391,16 +438,24 @@ int32_t streamSnapHandleInit(SStreamSnapHandle* pHandle, char* path, void* pMeta SBackendSnapFile2 snapFile = {0}; code = streamBackendSnapInitFile(path, pSnap, &snapFile); ASSERT(code == 0); - taosArrayPush(pDbSnapSet, &snapFile); + + void* p = taosArrayPush(pDbSnapSet, &snapFile); + if (p == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _err; + } } pHandle->pDbSnapSet = pDbSnapSet; pHandle->pSnapInfoSet = pSnapInfoSet; pHandle->currIdx = 0; pHandle->pMeta = pMeta; - return 0; + + return code; _err: + taosArrayDestroy(pSnapInfoSet); + taosArrayDestroy(pDbSnapSet); streamSnapHandleDestroy(pHandle); return code; } @@ -414,7 +469,8 @@ void streamSnapHandleDestroy(SStreamSnapHandle* handle) { } taosArrayDestroy(handle->pDbSnapSet); } - streamDestroyTaskDbSnapInfo(handle->pMeta, handle->pSnapInfoSet); + + (void) streamDestroyTaskDbSnapInfo(handle->pMeta, handle->pSnapInfoSet); if (handle->pSnapInfoSet) { for (int32_t i = 0; i < taosArrayGetSize(handle->pSnapInfoSet); i++) { SStreamTaskSnap* pSnap = taosArrayGet(handle->pSnapInfoSet, i); @@ -422,8 +478,8 @@ void streamSnapHandleDestroy(SStreamSnapHandle* handle) { } taosArrayDestroy(handle->pSnapInfoSet); } + taosMemoryFree(handle->metaPath); - return; } int32_t streamSnapReaderOpen(void* pMeta, int64_t sver, int64_t chkpId, char* path, SStreamSnapReader** ppReader) { @@ -506,14 +562,22 @@ _NEXT: item->name, (int64_t)pSnapFile->offset, item->size, pSnapFile->currFileIdx); pSnapFile->offset += nread; if (pSnapFile->offset >= item->size || nread < kBlockSize) { - taosCloseFile(&pSnapFile->fd); + code = taosCloseFile(&pSnapFile->fd); + if (code) { + stError("failed to close snapshot fd"); + } + pSnapFile->offset = 0; pSnapFile->currFileIdx += 1; } } else { stDebug("%s no data read, close file no.%d, move to next file, open and read", STREAM_STATE_TRANSFER, pSnapFile->currFileIdx); - taosCloseFile(&pSnapFile->fd); + code = taosCloseFile(&pSnapFile->fd); + if (code) { + stError("failed to close snapshot fd"); + } + pSnapFile->offset = 0; pSnapFile->currFileIdx += 1; @@ -577,14 +641,22 @@ int32_t streamSnapWriterOpen(void* pMeta, int64_t sver, int64_t ever, char* path pHandle->pDbSnapSet = taosArrayInit(8, sizeof(SBackendSnapFile2)); if (pHandle->pDbSnapSet == NULL) { - streamSnapWriterClose(pWriter, 0); + int32_t c = streamSnapWriterClose(pWriter, 0); // not override the error code, and igore this error code + if (c) { + stError("failed close snaphost writer"); + } + code = TSDB_CODE_OUT_OF_MEMORY; return code; } SBackendSnapFile2 snapFile = {0}; if (taosArrayPush(pHandle->pDbSnapSet, &snapFile) == NULL) { - streamSnapWriterClose(pWriter, 0); + int32_t c = streamSnapWriterClose(pWriter, 0); + if (c) { + stError("failed close snaphost writer"); + } + code = TSDB_CODE_OUT_OF_MEMORY; return code; } @@ -614,46 +686,62 @@ int32_t streamSnapWriteImpl(SStreamSnapWriter* pWriter, uint8_t* pData, uint32_t pHdr->name, tstrerror(code)); } } + if (strlen(pHdr->name) == strlen(pItem->name) && strcmp(pHdr->name, pItem->name) == 0) { int64_t bytes = taosPWriteFile(pSnapFile->fd, pHdr->data, pHdr->size, pSnapFile->offset); if (bytes != pHdr->size) { code = TAOS_SYSTEM_ERROR(errno); stError("%s failed to write snap, file name:%s, reason:%s", STREAM_STATE_TRANSFER, pHdr->name, tstrerror(code)); - return code; + goto _err; } else { stInfo("succ to write data %s", pItem->name); } pSnapFile->offset += bytes; } else { - taosCloseFile(&pSnapFile->fd); + code = taosCloseFile(&pSnapFile->fd); + if (code) { + stError("failed to close snapshot fd"); + } + pSnapFile->offset = 0; pSnapFile->currFileIdx += 1; SBackendFileItem item = {0}; item.name = taosStrdup(pHdr->name); item.type = pHdr->type; + if (item.name == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } - taosArrayPush(pSnapFile->pFileList, &item); + void* p = taosArrayPush(pSnapFile->pFileList, &item); + if (p == NULL) { // can NOT goto _err here. + return TSDB_CODE_OUT_OF_MEMORY; + } - SBackendFileItem* pItem = taosArrayGet(pSnapFile->pFileList, pSnapFile->currFileIdx); - pSnapFile->fd = streamOpenFile(pSnapFile->path, pItem->name, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND); + SBackendFileItem* pItem2 = taosArrayGet(pSnapFile->pFileList, pSnapFile->currFileIdx); + pSnapFile->fd = streamOpenFile(pSnapFile->path, pItem2->name, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND); if (pSnapFile->fd == NULL) { code = TAOS_SYSTEM_ERROR(errno); stError("%s failed to open file name:%s%s%s, reason:%s", STREAM_STATE_TRANSFER, pSnapFile->path, TD_DIRSEP, pHdr->name, tstrerror(code)); + return code; } + // open fd again, let's close fd during handle errors. if (taosPWriteFile(pSnapFile->fd, pHdr->data, pHdr->size, pSnapFile->offset) != pHdr->size) { code = TAOS_SYSTEM_ERROR(errno); stError("%s failed to write snap, file name:%s, reason:%s", STREAM_STATE_TRANSFER, pHdr->name, tstrerror(code)); - return code; + goto _err; } - stInfo("succ to write data %s", pItem->name); + + stInfo("succ to write data %s", pItem2->name); pSnapFile->offset += pHdr->size; } - code = 0; -_EXIT: + return TSDB_CODE_SUCCESS; + +_err: + (void) taosCloseFile(&pSnapFile->fd); return code; } @@ -688,7 +776,10 @@ int32_t streamSnapWrite(SStreamSnapWriter* pWriter, uint8_t* pData, uint32_t nDa item.name = taosStrdup((char*)ROCKSDB_CURRENT); item.type = ROCKSDB_CURRENT_TYPE; - taosArrayPush(pDbSnapFile->pFileList, &item); + void* p = taosArrayPush(pDbSnapFile->pFileList, &item); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } pDbSnapFile->inited = 1; return streamSnapWriteImpl(pWriter, pData, nData, pDbSnapFile); @@ -697,9 +788,12 @@ int32_t streamSnapWrite(SStreamSnapWriter* pWriter, uint8_t* pData, uint32_t nDa return streamSnapWriteImpl(pWriter, pData, nData, pDbSnapFile); } else { SBackendSnapFile2 snapFile = {0}; - taosArrayPush(pHandle->pDbSnapSet, &snapFile); - pHandle->currIdx += 1; + void* p = taosArrayPush(pHandle->pDbSnapSet, &snapFile); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pHandle->currIdx += 1; return streamSnapWrite(pWriter, pData, nData); } } diff --git a/source/libs/stream/src/streamStartHistory.c b/source/libs/stream/src/streamStartHistory.c index 1efb2af381..db0784d572 100644 --- a/source/libs/stream/src/streamStartHistory.c +++ b/source/libs/stream/src/streamStartHistory.c @@ -29,19 +29,19 @@ typedef struct SLaunchHTaskInfo { STaskId hTaskId; } SLaunchHTaskInfo; -static int32_t streamSetParamForScanHistory(SStreamTask* pTask); -static void streamTaskSetRangeStreamCalc(SStreamTask* pTask); -static int32_t initScanHistoryReq(SStreamTask* pTask, SStreamScanHistoryReq* pReq, int8_t igUntreated); -static SLaunchHTaskInfo* createHTaskLaunchInfo(SStreamMeta* pMeta, STaskId* pTaskId, int64_t hStreamId, - int32_t hTaskId); -static void tryLaunchHistoryTask(void* param, void* tmrId); -static void doExecScanhistoryInFuture(void* param, void* tmrId); -static int32_t doStartScanHistoryTask(SStreamTask* pTask); -static int32_t streamTaskStartScanHistory(SStreamTask* pTask); -static void checkFillhistoryTaskStatus(SStreamTask* pTask, SStreamTask* pHTask); -static int32_t launchNotBuiltFillHistoryTask(SStreamTask* pTask); -static void doRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, int64_t now); -static void notRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, int64_t now); +static int32_t streamSetParamForScanHistory(SStreamTask* pTask); +static int32_t streamTaskSetRangeStreamCalc(SStreamTask* pTask); +static void initScanHistoryReq(SStreamTask* pTask, SStreamScanHistoryReq* pReq, int8_t igUntreated); +static int32_t createHTaskLaunchInfo(SStreamMeta* pMeta, STaskId* pTaskId, int64_t hStreamId, int32_t hTaskId, + SLaunchHTaskInfo** pInfo); +static void tryLaunchHistoryTask(void* param, void* tmrId); +static void doExecScanhistoryInFuture(void* param, void* tmrId); +static int32_t doStartScanHistoryTask(SStreamTask* pTask); +static int32_t streamTaskStartScanHistory(SStreamTask* pTask); +static void checkFillhistoryTaskStatus(SStreamTask* pTask, SStreamTask* pHTask); +static int32_t launchNotBuiltFillHistoryTask(SStreamTask* pTask); +static void doRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, int64_t now); +static void notRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, int64_t now); static int32_t streamTaskSetReady(SStreamTask* pTask) { int32_t numOfDowns = streamTaskGetNumOfDownstream(pTask); @@ -65,22 +65,19 @@ static int32_t streamTaskSetReady(SStreamTask* pTask) { int32_t streamStartScanHistoryAsync(SStreamTask* pTask, int8_t igUntreated) { SStreamScanHistoryReq req; + int32_t code = 0; initScanHistoryReq(pTask, &req, igUntreated); int32_t len = sizeof(SStreamScanHistoryReq); void* serializedReq = rpcMallocCont(len); if (serializedReq == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } memcpy(serializedReq, &req, len); SRpcMsg rpcMsg = {.contLen = len, .pCont = serializedReq, .msgType = TDMT_VND_STREAM_SCAN_HISTORY}; - if (tmsgPutToQueue(pTask->pMsgCb, STREAM_QUEUE, &rpcMsg) < 0) { - /*ASSERT(0);*/ - } - - return 0; + return tmsgPutToQueue(pTask->pMsgCb, STREAM_QUEUE, &rpcMsg); } int32_t streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration) { @@ -109,8 +106,8 @@ int32_t streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration) pTask->schedHistoryInfo.pTimer = taosTmrStart(doExecScanhistoryInFuture, SCANHISTORY_IDLE_TIME_SLICE, pTask, streamTimer); } else { - taosTmrReset(doExecScanhistoryInFuture, SCANHISTORY_IDLE_TIME_SLICE, pTask, streamTimer, - &pTask->schedHistoryInfo.pTimer); + streamTmrReset(doExecScanhistoryInFuture, SCANHISTORY_IDLE_TIME_SLICE, pTask, streamTimer, + &pTask->schedHistoryInfo.pTimer, pTask->pMeta->vgId, " start-history-task-tmr"); } return TSDB_CODE_SUCCESS; @@ -135,9 +132,19 @@ int32_t streamTaskStartScanHistory(SStreamTask* pTask) { int32_t streamTaskOnNormalTaskReady(SStreamTask* pTask) { const char* id = pTask->id.idStr; + int32_t code = 0; - streamTaskSetReady(pTask); - streamTaskSetRangeStreamCalc(pTask); + code = streamTaskSetReady(pTask); + if (code) { + stError("s-task:%s failed to set task status ready", id); + return code; + } + + code = streamTaskSetRangeStreamCalc(pTask); + if (code) { + stError("s-task:%s failed to set the time range for stream task", id); + return code; + } SStreamTaskState p = streamTaskGetStatus(pTask); ASSERT(p.state == TASK_STATUS__READY); @@ -155,19 +162,23 @@ int32_t streamTaskOnNormalTaskReady(SStreamTask* pTask) { stDebug("s-task:%s level:%d status:%s sched-status:%d", id, pTask->info.taskLevel, p.name, schedStatus); } - return TSDB_CODE_SUCCESS; + return code; } int32_t streamTaskOnScanHistoryTaskReady(SStreamTask* pTask) { // set the state to be ready - streamTaskSetReady(pTask); - streamTaskSetRangeStreamCalc(pTask); + int32_t code = streamTaskSetReady(pTask); + if (code == 0) { + code = streamTaskSetRangeStreamCalc(pTask); + } - SStreamTaskState p = streamTaskGetStatus(pTask); - ASSERT((p.state == TASK_STATUS__SCAN_HISTORY) && (pTask->info.fillHistory == 1)); + if (code == 0) { + SStreamTaskState p = streamTaskGetStatus(pTask); + ASSERT((p.state == TASK_STATUS__SCAN_HISTORY) && (pTask->info.fillHistory == 1)); - stDebug("s-task:%s fill-history task enters into scan-history data stage, status:%s", pTask->id.idStr, p.name); - streamTaskStartScanHistory(pTask); + stDebug("s-task:%s fill-history task enters into scan-history data stage, status:%s", pTask->id.idStr, p.name); + code = streamTaskStartScanHistory(pTask); + } // NOTE: there will be an deadlock if launch fill history here. // start the related fill-history task, when current task is ready @@ -175,7 +186,7 @@ int32_t streamTaskOnScanHistoryTaskReady(SStreamTask* pTask) { // streamLaunchFillHistoryTask(pTask); // } - return TSDB_CODE_SUCCESS; + return code; } // common @@ -212,8 +223,7 @@ int32_t streamLaunchFillHistoryTask(SStreamTask* pTask) { stDebug("s-task:%s not launch related fill-history task:0x%" PRIx64 "-0x%x, status:%s", idStr, hStreamId, hTaskId, pStatus.name); - (void) streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); - return -1; // todo set the correct error code + return streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); } stDebug("s-task:%s start to launch related fill-history task:0x%" PRIx64 "-0x%x", idStr, hStreamId, hTaskId); @@ -257,12 +267,11 @@ int32_t streamLaunchFillHistoryTask(SStreamTask* pTask) { } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -int32_t initScanHistoryReq(SStreamTask* pTask, SStreamScanHistoryReq* pReq, int8_t igUntreated) { +void initScanHistoryReq(SStreamTask* pTask, SStreamScanHistoryReq* pReq, int8_t igUntreated) { pReq->msgHead.vgId = pTask->info.nodeId; pReq->streamId = pTask->id.streamId; pReq->taskId = pTask->id.taskId; pReq->igUntreated = igUntreated; - return 0; } void checkFillhistoryTaskStatus(SStreamTask* pTask, SStreamTask* pHTask) { @@ -281,7 +290,10 @@ void checkFillhistoryTaskStatus(SStreamTask* pTask, SStreamTask* pHTask) { } // check if downstream tasks have been ready - streamTaskHandleEvent(pHTask->status.pSM, TASK_EVENT_INIT_SCANHIST); + int32_t code = streamTaskHandleEvent(pHTask->status.pSM, TASK_EVENT_INIT_SCANHIST); + if (code) { + stError("s-task:%s handle event init_scanhist failed", pTask->id.idStr); + } } void notRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, int64_t now) { @@ -316,7 +328,8 @@ void doRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, i stDebug("s-task:%s status:%s failed to launch fill-history task:0x%x, retry launch:%dms, retryCount:%d", pTask->id.idStr, p, hTaskId, pHTaskInfo->waitInterval, pHTaskInfo->retryTimes); - taosTmrReset(tryLaunchHistoryTask, LAUNCH_HTASK_INTERVAL, pInfo, streamTimer, &pHTaskInfo->pTimer); + streamTmrReset(tryLaunchHistoryTask, LAUNCH_HTASK_INTERVAL, pInfo, streamTimer, &pHTaskInfo->pTimer, + pTask->pMeta->vgId, " start-history-task-tmr"); } } @@ -367,7 +380,8 @@ void tryLaunchHistoryTask(void* param, void* tmrId) { pHTaskInfo->tickCount -= 1; if (pHTaskInfo->tickCount > 0) { - taosTmrReset(tryLaunchHistoryTask, LAUNCH_HTASK_INTERVAL, pInfo, streamTimer, &pHTaskInfo->pTimer); + streamTmrReset(tryLaunchHistoryTask, LAUNCH_HTASK_INTERVAL, pInfo, streamTimer, &pHTaskInfo->pTimer, + pTask->pMeta->vgId, " start-history-task-tmr"); streamMetaReleaseTask(pMeta, pTask); return; } @@ -417,21 +431,21 @@ void tryLaunchHistoryTask(void* param, void* tmrId) { taosMemoryFree(pInfo); } -SLaunchHTaskInfo* createHTaskLaunchInfo(SStreamMeta* pMeta, STaskId* pTaskId, int64_t hStreamId, int32_t hTaskId) { - SLaunchHTaskInfo* pInfo = taosMemoryCalloc(1, sizeof(SLaunchHTaskInfo)); - if (pInfo == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; +int32_t createHTaskLaunchInfo(SStreamMeta* pMeta, STaskId* pTaskId, int64_t hStreamId, int32_t hTaskId, + SLaunchHTaskInfo** pInfo) { + *pInfo = taosMemoryCalloc(1, sizeof(SLaunchHTaskInfo)); + if ((*pInfo) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; } - pInfo->id.streamId = pTaskId->streamId; - pInfo->id.taskId = pTaskId->taskId; + (*pInfo)->id.streamId = pTaskId->streamId; + (*pInfo)->id.taskId = pTaskId->taskId; - pInfo->hTaskId.streamId = hStreamId; - pInfo->hTaskId.taskId = hTaskId; + (*pInfo)->hTaskId.streamId = hStreamId; + (*pInfo)->hTaskId.taskId = hTaskId; - pInfo->pMeta = pMeta; - return pInfo; + (*pInfo)->pMeta = pMeta; + return TSDB_CODE_SUCCESS; } int32_t launchNotBuiltFillHistoryTask(SStreamTask* pTask) { @@ -440,16 +454,18 @@ int32_t launchNotBuiltFillHistoryTask(SStreamTask* pTask) { const char* idStr = pTask->id.idStr; int64_t hStreamId = pTask->hTaskInfo.id.streamId; int32_t hTaskId = pTask->hTaskInfo.id.taskId; + SLaunchHTaskInfo* pInfo = NULL; + ASSERT(hTaskId != 0); stWarn("s-task:%s vgId:%d failed to launch history task:0x%x, since not built yet", idStr, pMeta->vgId, hTaskId); - STaskId id = streamTaskGetTaskId(pTask); - SLaunchHTaskInfo* pInfo = createHTaskLaunchInfo(pMeta, &id, hStreamId, hTaskId); - if (pInfo == NULL) { + STaskId id = streamTaskGetTaskId(pTask); + int32_t code = createHTaskLaunchInfo(pMeta, &id, hStreamId, hTaskId, &pInfo); + if (code) { stError("s-task:%s failed to launch related fill-history task, since Out Of Memory", idStr); - (void) streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); - return terrno; + (void)streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); + return code; } // set the launch time info @@ -475,7 +491,8 @@ int32_t launchNotBuiltFillHistoryTask(SStreamTask* pTask) { } else { // timer exists ASSERT(pTask->status.timerActive >= 1); stDebug("s-task:%s set timer active flag, task timer not null", idStr); - taosTmrReset(tryLaunchHistoryTask, WAIT_FOR_MINIMAL_INTERVAL, pInfo, streamTimer, &pTask->hTaskInfo.pTimer); + streamTmrReset(tryLaunchHistoryTask, WAIT_FOR_MINIMAL_INTERVAL, pInfo, streamTimer, &pTask->hTaskInfo.pTimer, + pTask->pMeta->vgId, " start-history-task-tmr"); } return TSDB_CODE_SUCCESS; @@ -510,7 +527,7 @@ bool streamHistoryTaskSetVerRangeStep2(SStreamTask* pTask, int64_t nextProcessVe } } -void streamTaskSetRangeStreamCalc(SStreamTask* pTask) { +int32_t streamTaskSetRangeStreamCalc(SStreamTask* pTask) { SDataRange* pRange = &pTask->dataRange; if (!HAS_RELATED_FILLHISTORY_TASK(pTask)) { @@ -523,10 +540,12 @@ void streamTaskSetRangeStreamCalc(SStreamTask* pTask) { "window:%" PRId64 "-%" PRId64 ", verRange:%" PRId64 "-%" PRId64, pTask->id.idStr, pRange->window.skey, pRange->window.ekey, pRange->range.minVer, pRange->range.maxVer); } + + return TSDB_CODE_SUCCESS; } else { ASSERT(pTask->info.fillHistory == 0); if (pTask->info.taskLevel >= TASK_LEVEL__AGG) { - return; + return TSDB_CODE_SUCCESS; } stDebug("s-task:%s level:%d related fill-history task exists, stream task timeWindow:%" PRId64 " - %" PRId64 @@ -536,7 +555,7 @@ void streamTaskSetRangeStreamCalc(SStreamTask* pTask) { SVersionRange verRange = pRange->range; STimeWindow win = pRange->window; - streamSetParamForStreamScannerStep2(pTask, &verRange, &win); + return streamSetParamForStreamScannerStep2(pTask, &verRange, &win); } } @@ -554,7 +573,10 @@ void doExecScanhistoryInFuture(void* param, void* tmrId) { } if (pTask->schedHistoryInfo.numOfTicks <= 0) { - streamStartScanHistoryAsync(pTask, 0); + int32_t code = streamStartScanHistoryAsync(pTask, 0); + if (code) { + stError("s-task:%s async start history task failed", pTask->id.idStr); + } int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s fill-history:%d start scan-history data, out of tmr, ref:%d", pTask->id.idStr, @@ -563,18 +585,26 @@ void doExecScanhistoryInFuture(void* param, void* tmrId) { // release the task. streamMetaReleaseTask(pTask->pMeta, pTask); } else { - taosTmrReset(doExecScanhistoryInFuture, SCANHISTORY_IDLE_TIME_SLICE, pTask, streamTimer, - &pTask->schedHistoryInfo.pTimer); + streamTmrReset(doExecScanhistoryInFuture, SCANHISTORY_IDLE_TIME_SLICE, pTask, streamTimer, + &pTask->schedHistoryInfo.pTimer, pTask->pMeta->vgId, " start-history-task-tmr"); } } int32_t doStartScanHistoryTask(SStreamTask* pTask) { + int32_t code = 0; SVersionRange* pRange = &pTask->dataRange.range; + if (pTask->info.fillHistory) { - streamSetParamForScanHistory(pTask); + code = streamSetParamForScanHistory(pTask); + if (code) { + return code; + } } - streamSetParamForStreamScannerStep1(pTask, pRange, &pTask->dataRange.window); - int32_t code = streamStartScanHistoryAsync(pTask, 0); - return code; + code = streamSetParamForStreamScannerStep1(pTask, pRange, &pTask->dataRange.window); + if (code) { + return code; + } + + return streamStartScanHistoryAsync(pTask, 0); } diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c index 7c2d0b3556..0110a9825c 100644 --- a/source/libs/stream/src/streamTask.c +++ b/source/libs/stream/src/streamTask.c @@ -29,20 +29,20 @@ static void streamTaskDestroyActiveChkptInfo(SActiveCheckpointInfo* pInfo); static int32_t addToTaskset(SArray* pArray, SStreamTask* pTask) { int32_t childId = taosArrayGetSize(pArray); pTask->info.selfChildId = childId; - taosArrayPush(pArray, &pTask); - return 0; + void* p = taosArrayPush(pArray, &pTask); + return (p == NULL)? TSDB_CODE_OUT_OF_MEMORY:TSDB_CODE_SUCCESS; } static int32_t doUpdateTaskEpset(SStreamTask* pTask, int32_t nodeId, SEpSet* pEpSet, bool* pUpdated) { char buf[512] = {0}; if (pTask->info.nodeId == nodeId) { // execution task should be moved away bool isEqual = isEpsetEqual(&pTask->info.epSet, pEpSet); - epsetToStr(pEpSet, buf, tListLen(buf)); + (void)epsetToStr(pEpSet, buf, tListLen(buf)); if (!isEqual) { (*pUpdated) = true; char tmp[512] = {0}; - epsetToStr(&pTask->info.epSet, tmp, tListLen(tmp)); + (void) epsetToStr(&pTask->info.epSet, tmp, tListLen(tmp)); // only for log file, ignore errors epsetAssign(&pTask->info.epSet, pEpSet); stDebug("s-task:0x%x (vgId:%d) self node epset is updated %s, old:%s", pTask->id.taskId, nodeId, buf, tmp); @@ -127,7 +127,10 @@ int32_t tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool pTask->outputq.status = TASK_OUTPUT_STATUS__NORMAL; pTask->taskCheckInfo.pList = taosArrayInit(4, sizeof(SDownstreamStatusInfo)); - taosThreadMutexInit(&pTask->taskCheckInfo.checkInfoLock, NULL); + code = taosThreadMutexInit(&pTask->taskCheckInfo.checkInfoLock, NULL); + if (code) { + return code; + } if (fillHistory) { ASSERT(hasFillhistory); @@ -135,7 +138,7 @@ int32_t tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool epsetAssign(&(pTask->info.mnodeEpset), pEpset); - addToTaskset(pTaskList, pTask); + code = addToTaskset(pTaskList, pTask); *p = pTask; return code; @@ -221,17 +224,17 @@ void tFreeStreamTask(SStreamTask* pTask) { } if (pTask->schedInfo.pDelayTimer != NULL) { - taosTmrStop(pTask->schedInfo.pDelayTimer); + (void) taosTmrStop(pTask->schedInfo.pDelayTimer); pTask->schedInfo.pDelayTimer = NULL; } if (pTask->hTaskInfo.pTimer != NULL) { - /*bool ret = */ taosTmrStop(pTask->hTaskInfo.pTimer); + (void) taosTmrStop(pTask->hTaskInfo.pTimer); pTask->hTaskInfo.pTimer = NULL; } if (pTask->msgInfo.pRetryTmr != NULL) { - /*bool ret = */ taosTmrStop(pTask->msgInfo.pRetryTmr); + (void) taosTmrStop(pTask->msgInfo.pRetryTmr); pTask->msgInfo.pRetryTmr = NULL; } @@ -394,10 +397,12 @@ int32_t streamTaskInit(SStreamTask* pTask, SStreamMeta* pMeta, SMsgCb* pMsgCb, i return terrno; } - taosThreadMutexInit(&pTask->msgInfo.lock, NULL); + code = taosThreadMutexInit(&pTask->msgInfo.lock, NULL); + if (code) { + return code; + } TdThreadMutexAttr attr = {0}; - code = taosThreadMutexAttrInit(&attr); if (code != 0) { stError("s-task:%s initElapsed mutex attr failed, code:%s", pTask->id.idStr, tstrerror(code)); @@ -410,8 +415,16 @@ int32_t streamTaskInit(SStreamTask* pTask, SStreamMeta* pMeta, SMsgCb* pMsgCb, i return code; } - taosThreadMutexInit(&pTask->lock, &attr); - taosThreadMutexAttrDestroy(&attr); + code = taosThreadMutexInit(&pTask->lock, &attr); + if (code) { + return code; + } + + code = taosThreadMutexAttrDestroy(&attr); + if (code) { + return code; + } + streamTaskOpenAllUpstreamInput(pTask); STaskOutputInfo* pOutputInfo = &pTask->outputInfo; @@ -424,7 +437,11 @@ int32_t streamTaskInit(SStreamTask* pTask, SStreamMeta* pMeta, SMsgCb* pMsgCb, i // 2MiB per second for sink task // 50 times sink operator per second - streamTaskInitTokenBucket(pOutputInfo->pTokenBucket, 35, 35, tsSinkDataRate, pTask->id.idStr); + code = streamTaskInitTokenBucket(pOutputInfo->pTokenBucket, 35, 35, tsSinkDataRate, pTask->id.idStr); + if (code) { + return code; + } + pOutputInfo->pNodeEpsetUpdateList = taosArrayInit(4, sizeof(SDownstreamTaskEpset)); if (pOutputInfo->pNodeEpsetUpdateList == NULL) { stError("s-task:%s failed to prepare downstreamUpdateList, code:%s", pTask->id.idStr, @@ -474,13 +491,13 @@ int32_t streamTaskSetUpstreamInfo(SStreamTask* pTask, const SStreamTask* pUpstre pTask->upstreamInfo.pList = taosArrayInit(4, POINTER_BYTES); } - taosArrayPush(pTask->upstreamInfo.pList, &pEpInfo); - return TSDB_CODE_SUCCESS; + void* p = taosArrayPush(pTask->upstreamInfo.pList, &pEpInfo); + return (p == NULL)? TSDB_CODE_OUT_OF_MEMORY:TSDB_CODE_SUCCESS; } void streamTaskUpdateUpstreamInfo(SStreamTask* pTask, int32_t nodeId, const SEpSet* pEpSet, bool* pUpdated) { char buf[512] = {0}; - epsetToStr(pEpSet, buf, tListLen(buf)); + (void) epsetToStr(pEpSet, buf, tListLen(buf)); // ignore error since it is only for log file. int32_t numOfUpstream = taosArrayGetSize(pTask->upstreamInfo.pList); for (int32_t i = 0; i < numOfUpstream; ++i) { @@ -491,7 +508,7 @@ void streamTaskUpdateUpstreamInfo(SStreamTask* pTask, int32_t nodeId, const SEpS *pUpdated = true; char tmp[512] = {0}; - epsetToStr(&pInfo->epSet, tmp, tListLen(tmp)); + (void) epsetToStr(&pInfo->epSet, tmp, tListLen(tmp)); epsetAssign(&pInfo->epSet, pEpSet); stDebug("s-task:0x%x update the upstreamInfo taskId:0x%x(nodeId:%d) newEpset:%s old:%s", pTask->id.taskId, @@ -526,7 +543,7 @@ void streamTaskSetFixedDownstreamInfo(SStreamTask* pTask, const SStreamTask* pDo void streamTaskUpdateDownstreamInfo(SStreamTask* pTask, int32_t nodeId, const SEpSet* pEpSet, bool* pUpdated) { char buf[512] = {0}; - epsetToStr(pEpSet, buf, tListLen(buf)); + (void) epsetToStr(pEpSet, buf, tListLen(buf)); // ignore the error since only for log files. int32_t id = pTask->id.taskId; int8_t type = pTask->outputInfo.type; @@ -542,7 +559,7 @@ void streamTaskUpdateDownstreamInfo(SStreamTask* pTask, int32_t nodeId, const SE if (!isEqual) { *pUpdated = true; char tmp[512] = {0}; - epsetToStr(&pVgInfo->epSet, tmp, tListLen(tmp)); + (void) epsetToStr(&pVgInfo->epSet, tmp, tListLen(tmp)); epsetAssign(&pVgInfo->epSet, pEpSet); stDebug("s-task:0x%x update dispatch info, task:0x%x(nodeId:%d) newEpset:%s old:%s", id, pVgInfo->taskId, @@ -562,7 +579,7 @@ void streamTaskUpdateDownstreamInfo(SStreamTask* pTask, int32_t nodeId, const SE *pUpdated = true; char tmp[512] = {0}; - epsetToStr(&pDispatcher->epSet, tmp, tListLen(tmp)); + (void) epsetToStr(&pDispatcher->epSet, tmp, tListLen(tmp)); epsetAssign(&pDispatcher->epSet, pEpSet); stDebug("s-task:0x%x update dispatch info, task:0x%x(nodeId:%d) newEpset:%s old:%s", id, pDispatcher->taskId, @@ -580,8 +597,16 @@ int32_t streamTaskStop(SStreamTask* pTask) { int64_t st = taosGetTimestampMs(); const char* id = pTask->id.idStr; - streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_STOP); - qKillTask(pTask->exec.pExecutor, TSDB_CODE_SUCCESS); + int32_t code = streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_STOP); + if (code) { + stError("failed to handle STOP event, s-task:%s", id); + } + + code = qKillTask(pTask->exec.pExecutor, TSDB_CODE_SUCCESS); + if (code) { + stError("s-task:%s failed to kill task related query handle", id); + } + while (!streamTaskIsIdle(pTask)) { stDebug("s-task:%s level:%d wait for task to be idle and then close, check again in 100ms", id, pTask->info.taskLevel); @@ -590,7 +615,7 @@ int32_t streamTaskStop(SStreamTask* pTask) { int64_t el = taosGetTimestampMs() - st; stDebug("vgId:%d s-task:%s is closed in %" PRId64 " ms", vgId, id, el); - return 0; + return code; } bool streamTaskUpdateEpsetInfo(SStreamTask* pTask, SArray* pNodeList) { @@ -607,7 +632,10 @@ bool streamTaskUpdateEpsetInfo(SStreamTask* pTask, SArray* pNodeList) { bool updated = false; for (int32_t i = 0; i < taosArrayGetSize(pNodeList); ++i) { SNodeUpdateInfo* pInfo = taosArrayGet(pNodeList, i); - doUpdateTaskEpset(pTask, pInfo->nodeId, &pInfo->newEp, &updated); + int32_t code = doUpdateTaskEpset(pTask, pInfo->nodeId, &pInfo->newEp, &updated); + if (code) { + stError("s-task:0x%x failed to update the task nodeEp epset, code:%s", pTask->id.taskId, tstrerror(code)); + } } return updated; @@ -704,10 +732,11 @@ int8_t streamTaskSetSchedStatusInactive(SStreamTask* pTask) { } int32_t streamTaskClearHTaskAttr(SStreamTask* pTask, int32_t resetRelHalt) { + int32_t code = 0; SStreamMeta* pMeta = pTask->pMeta; STaskId sTaskId = {.streamId = pTask->streamTaskId.streamId, .taskId = pTask->streamTaskId.taskId}; if (pTask->info.fillHistory == 0) { - return TSDB_CODE_SUCCESS; + return code; } SStreamTask** ppStreamTask = (SStreamTask**)taosHashGet(pMeta->pTasksMap, &sTaskId, sizeof(sTaskId)); @@ -725,11 +754,11 @@ int32_t streamTaskClearHTaskAttr(SStreamTask* pTask, int32_t resetRelHalt) { (*ppStreamTask)->status.taskStatus = TASK_STATUS__READY; } - streamMetaSaveTask(pMeta, *ppStreamTask); + code = streamMetaSaveTask(pMeta, *ppStreamTask); streamMutexUnlock(&(*ppStreamTask)->lock); } - return TSDB_CODE_SUCCESS; + return code; } int32_t streamBuildAndSendDropTaskMsg(SMsgCb* pMsgCb, int32_t vgId, SStreamTaskId* pTaskId, int64_t resetRelHalt) { @@ -797,8 +826,7 @@ int32_t streamSendChkptReportMsg(SStreamTask* pTask, SCheckpointInfo* pCheckpoin initRpcMsg(&msg, TDMT_MND_STREAM_CHKPT_REPORT, buf, tlen); stDebug("s-task:%s vgId:%d build and send task checkpoint-report to mnode", id, vgId); - tmsgSendReq(&pTask->info.mnodeEpset, &msg); - return 0; + return tmsgSendReq(&pTask->info.mnodeEpset, &msg); } STaskId streamTaskGetTaskId(const SStreamTask* pTask) { @@ -880,6 +908,7 @@ STaskStatusEntry streamTaskGetStatusEntry(SStreamTask* pTask) { static int32_t taskPauseCallback(SStreamTask* pTask, void* param) { SStreamMeta* pMeta = pTask->pMeta; + int32_t code = 0; int32_t num = atomic_add_fetch_32(&pMeta->numOfPausedTasks, 1); stInfo("vgId:%d s-task:%s pause stream task. paused task num:%d", pMeta->vgId, pTask->id.idStr, num); @@ -887,15 +916,15 @@ static int32_t taskPauseCallback(SStreamTask* pTask, void* param) { // in case of fill-history task, stop the tsdb file scan operation. if (pTask->info.fillHistory == 1) { void* pExecutor = pTask->exec.pExecutor; - qKillTask(pExecutor, TSDB_CODE_SUCCESS); + code = qKillTask(pExecutor, TSDB_CODE_SUCCESS); } stDebug("vgId:%d s-task:%s set pause flag and pause task", pMeta->vgId, pTask->id.idStr); - return TSDB_CODE_SUCCESS; + return code; } void streamTaskPause(SStreamTask* pTask) { - streamTaskHandleEventAsync(pTask->status.pSM, TASK_EVENT_PAUSE, taskPauseCallback, NULL); + (void) streamTaskHandleEventAsync(pTask->status.pSM, TASK_EVENT_PAUSE, taskPauseCallback, NULL); } void streamTaskResume(SStreamTask* pTask) { @@ -949,8 +978,7 @@ int32_t streamTaskSendCheckpointReq(SStreamTask* pTask) { initRpcMsg(&msg, TDMT_MND_STREAM_REQ_CHKPT, buf, tlen); stDebug("s-task:%s vgId:%d build and send task checkpoint req", id, vgId); - tmsgSendReq(&pTask->info.mnodeEpset, &msg); - return 0; + return tmsgSendReq(&pTask->info.mnodeEpset, &msg); } void streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId, SStreamUpstreamEpInfo** pEpInfo) { @@ -1044,7 +1072,7 @@ int32_t streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq) { void streamTaskSetRemoveBackendFiles(SStreamTask* pTask) { pTask->status.removeBackendFiles = true; } -int32_t streamTaskGetActiveCheckpointInfo(const SStreamTask* pTask, int32_t* pTransId, int64_t* pCheckpointId) { +void streamTaskGetActiveCheckpointInfo(const SStreamTask* pTask, int32_t* pTransId, int64_t* pCheckpointId) { if (pTransId != NULL) { *pTransId = pTask->chkInfo.pActiveInfo->transId; } @@ -1052,8 +1080,6 @@ int32_t streamTaskGetActiveCheckpointInfo(const SStreamTask* pTask, int32_t* pTr if (pCheckpointId != NULL) { *pCheckpointId = pTask->chkInfo.pActiveInfo->activeId; } - - return TSDB_CODE_SUCCESS; } int32_t streamTaskSetActiveCheckpointInfo(SStreamTask* pTask, int64_t activeCheckpointId) { @@ -1084,7 +1110,7 @@ int32_t streamTaskCreateActiveChkptInfo(SActiveCheckpointInfo** pRes) { pInfo->pCheckpointReadyRecvList = taosArrayInit(4, sizeof(STaskDownstreamReadyInfo)); *pRes = pInfo; - return TSDB_CODE_SUCCESS; + return code; } void streamTaskDestroyActiveChkptInfo(SActiveCheckpointInfo* pInfo) { @@ -1101,12 +1127,12 @@ void streamTaskDestroyActiveChkptInfo(SActiveCheckpointInfo* pInfo) { pInfo->pCheckpointReadyRecvList = NULL; if (pInfo->pChkptTriggerTmr != NULL) { - taosTmrStop(pInfo->pChkptTriggerTmr); + (void) taosTmrStop(pInfo->pChkptTriggerTmr); pInfo->pChkptTriggerTmr = NULL; } if (pInfo->pSendReadyMsgTmr != NULL) { - taosTmrStop(pInfo->pSendReadyMsgTmr); + (void) taosTmrStop(pInfo->pSendReadyMsgTmr); pInfo->pSendReadyMsgTmr = NULL; } diff --git a/source/libs/stream/src/streamTimer.c b/source/libs/stream/src/streamTimer.c index 931de397cc..fb1740ae0a 100644 --- a/source/libs/stream/src/streamTimer.c +++ b/source/libs/stream/src/streamTimer.c @@ -35,8 +35,9 @@ void streamTimerCleanUp() { streamTimer = NULL; } -tmr_h streamTimerGetInstance() { - return streamTimer; +int32_t streamTimerGetInstance(tmr_h* pTmr) { + *pTmr = streamTimer; + return TSDB_CODE_SUCCESS; } void streamTmrReset(TAOS_TMR_CALLBACK fp, int32_t mseconds, void* param, void* handle, tmr_h* pTmrId, int32_t vgId, diff --git a/source/libs/stream/src/streamUpdate.c b/source/libs/stream/src/streamUpdate.c index 76b0d6a561..6a2c85323a 100644 --- a/source/libs/stream/src/streamUpdate.c +++ b/source/libs/stream/src/streamUpdate.c @@ -36,7 +36,6 @@ static int64_t adjustExpEntries(int64_t entries) { return TMIN(DEFAULT_EXPECTED_ int compareKeyTs(void* pTs1, void* pTs2, void* pPkVal, __compar_fn_t cmpPkFn) { return compareInt64Val(pTs1, pTs2); - ; } int compareKeyTsAndPk(void* pValue1, void* pTs, void* pPkVal, __compar_fn_t cmpPkFn) { diff --git a/source/libs/tdb/CMakeLists.txt b/source/libs/tdb/CMakeLists.txt index cc50919413..bb8d33366c 100644 --- a/source/libs/tdb/CMakeLists.txt +++ b/source/libs/tdb/CMakeLists.txt @@ -10,7 +10,6 @@ target_sources(tdb "src/db/tdbTable.c" "src/db/tdbTxn.c" "src/db/tdbPage.c" - "src/db/tdbOs.c" ) target_include_directories( diff --git a/source/libs/tdb/src/db/tdbBtree.c b/source/libs/tdb/src/db/tdbBtree.c index 4cca63a966..4dd3d3298c 100644 --- a/source/libs/tdb/src/db/tdbBtree.c +++ b/source/libs/tdb/src/db/tdbBtree.c @@ -76,14 +76,14 @@ int tdbBtreeOpen(int keyLen, int valLen, SPager *pPager, char const *tbname, SPg if (keyLen == 0) { tdbError("tdb/btree-open: key len cannot be zero."); - return -1; + return TSDB_CODE_INVALID_PARA; } *ppBt = NULL; pBt = (SBTree *)tdbOsCalloc(1, sizeof(*pBt)); if (pBt == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } // pBt->keyLen diff --git a/source/libs/tdb/src/db/tdbDb.c b/source/libs/tdb/src/db/tdbDb.c index 9a1d89eeac..b9ba9de51f 100644 --- a/source/libs/tdb/src/db/tdbDb.c +++ b/source/libs/tdb/src/db/tdbDb.c @@ -15,8 +15,8 @@ #include "tdbInt.h" -int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, int8_t rollback, int32_t encryptAlgorithm, - char *encryptKey) { +int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, int8_t rollback, + int32_t encryptAlgorithm, char *encryptKey) { TDB *pDb; int dsize; int zsize; @@ -31,7 +31,7 @@ int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, i pPtr = (uint8_t *)tdbOsCalloc(1, zsize); if (pPtr == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } pDb = (TDB *)pPtr; @@ -51,38 +51,38 @@ int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, i pDb->jfd = -1; pDb->encryptAlgorithm = encryptAlgorithm; - if(encryptKey != NULL){ - strncpy(pDb->encryptKey, encryptKey, ENCRYPT_KEY_LEN); + if (encryptKey != NULL) { + strncpy(pDb->encryptKey, encryptKey, ENCRYPT_KEY_LEN); } ret = tdbPCacheOpen(szPage, pages, &(pDb->pCache)); if (ret < 0) { - return -1; + return ret; } pDb->nPgrHash = 8; tsize = sizeof(SPager *) * pDb->nPgrHash; pDb->pgrHash = tdbOsMalloc(tsize); if (pDb->pgrHash == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } memset(pDb->pgrHash, 0, tsize); ret = taosMulModeMkDir(dbname, 0755, false); if (ret < 0) { - return -1; + return TAOS_SYSTEM_ERROR(ret); } #ifdef USE_MAINDB // open main db ret = tdbTbOpen(TDB_MAINDB_NAME, -1, sizeof(SBtInfo), NULL, pDb, &pDb->pMainDb, rollback); if (ret < 0) { - return -1; + return ret; } ret = tdbTbOpen(TDB_FREEDB_NAME, sizeof(SPgno), 0, NULL, pDb, &pDb->pFreeDb, rollback); if (ret < 0) { - return -1; + return ret; } #endif @@ -125,12 +125,13 @@ int32_t tdbBegin(TDB *pDb, TXN **ppTxn, void *(*xMalloc)(void *, size_t), void ( TXN *pTxn = tdbOsCalloc(1, sizeof(*pTxn)); if (!pTxn) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } - if (tdbTxnOpen(pTxn, txnId, xMalloc, xFree, xArg, flags) < 0) { + ret = tdbTxnOpen(pTxn, txnId, xMalloc, xFree, xArg, flags); + if (ret < 0) { tdbOsFree(pTxn); - return -1; + return ret; } for (pPager = pDb->pgrList; pPager; pPager = pPager->pNext) { @@ -139,7 +140,7 @@ int32_t tdbBegin(TDB *pDb, TXN **ppTxn, void *(*xMalloc)(void *, size_t), void ( tdbError("failed to begin pager since %s. dbName:%s, txnId:%" PRId64, tstrerror(terrno), pDb->dbName, pTxn->txnId); tdbTxnClose(pTxn); - return -1; + return ret; } } @@ -157,7 +158,7 @@ int32_t tdbCommit(TDB *pDb, TXN *pTxn) { if (ret < 0) { tdbError("failed to commit pager since %s. dbName:%s, txnId:%" PRId64, tstrerror(terrno), pDb->dbName, pTxn->txnId); - return -1; + return ret; } } @@ -173,7 +174,7 @@ int32_t tdbPostCommit(TDB *pDb, TXN *pTxn) { if (ret < 0) { tdbError("failed to commit pager since %s. dbName:%s, txnId:%" PRId64, tstrerror(terrno), pDb->dbName, pTxn->txnId); - return -1; + return ret; } } @@ -191,7 +192,7 @@ int32_t tdbPrepareAsyncCommit(TDB *pDb, TXN *pTxn) { if (ret < 0) { tdbError("failed to commit pager since %s. dbName:%s, txnId:%" PRId64, tstrerror(terrno), pDb->dbName, pTxn->txnId); - return -1; + return ret; } } @@ -207,7 +208,7 @@ int32_t tdbAbort(TDB *pDb, TXN *pTxn) { if (ret < 0) { tdbError("failed to abort pager since %s. dbName:%s, txnId:%" PRId64, tstrerror(terrno), pDb->dbName, pTxn->txnId); - return -1; + return ret; } } diff --git a/source/libs/tdb/src/db/tdbOs.c b/source/libs/tdb/src/db/tdbOs.c deleted file mode 100644 index a2fce8925b..0000000000 --- a/source/libs/tdb/src/db/tdbOs.c +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#include "tdbOs.h" - -#ifndef TDB_FOR_TDENGINE - -// tdbOsRead -i64 tdbOsRead(tdb_fd_t fd, void *pData, i64 nBytes) { - i64 nRead = 0; - i64 iRead = 0; - u8 *pBuf = (u8 *)pData; - - while (nBytes > 0) { - iRead = read(fd, pBuf, nBytes); - if (iRead < 0) { - if (errno == EINTR) { - continue; - } else { - return -1; - } - } else if (iRead == 0) { - break; - } - - nRead += iRead; - pBuf += iRead; - nBytes -= iRead; - } - - return nRead; -} - -// tdbOsPRead -i64 tdbOsPRead(tdb_fd_t fd, void *pData, i64 nBytes, i64 offset) { - i64 nRead = 0; - i64 iRead = 0; - i64 iOffset = offset; - u8 *pBuf = (u8 *)pData; - - while (nBytes > 0) { - iRead = pread(fd, pBuf, nBytes, iOffset); - if (iRead < 0) { - if (errno == EINTR) { - continue; - } else { - return -1; - } - } else if (iRead == 0) { - break; - } - - nRead += iRead; - pBuf += iRead; - iOffset += iRead; - nBytes -= iRead; - } - - return nRead; -} - -// tdbOsWrite -i64 tdbOsWrite(tdb_fd_t fd, const void *pData, i64 nBytes) { - i64 nWrite = 0; - i64 iWrite = 0; - u8 *pBuf = (u8 *)pData; - - while (nBytes > 0) { - iWrite = write(fd, pBuf, nBytes); - if (iWrite < 0) { - if (errno == EINTR) { - continue; - } - - return -1; - } - - nWrite += iWrite; - pBuf += iWrite; - nBytes -= iWrite; - } - - return nWrite; -} - -#endif \ No newline at end of file diff --git a/source/libs/tdb/src/db/tdbPCache.c b/source/libs/tdb/src/db/tdbPCache.c index 455128e6ec..6cb5f89758 100644 --- a/source/libs/tdb/src/db/tdbPCache.c +++ b/source/libs/tdb/src/db/tdbPCache.c @@ -50,30 +50,36 @@ static void tdbPCacheLock(SPCache *pCache) { tdbMutexLock(&(pCache->mutex)); } static void tdbPCacheUnlock(SPCache *pCache) { tdbMutexUnlock(&(pCache->mutex)); } int tdbPCacheOpen(int pageSize, int cacheSize, SPCache **ppCache) { + int32_t code = 0; + int32_t lino; SPCache *pCache; void *pPtr; SPage *pPgHdr; pCache = (SPCache *)tdbOsCalloc(1, sizeof(*pCache) + sizeof(SPage *) * cacheSize); if (pCache == NULL) { - return -1; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } pCache->szPage = pageSize; pCache->nPages = cacheSize; pCache->aPage = (SPage **)tdbOsCalloc(cacheSize, sizeof(SPage *)); if (pCache->aPage == NULL) { - tdbOsFree(pCache); - return -1; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } - if (tdbPCacheOpenImpl(pCache) < 0) { - tdbOsFree(pCache); - return -1; - } + code = tdbPCacheOpenImpl(pCache); + TSDB_CHECK_CODE(code, lino, _exit); - *ppCache = pCache; - return 0; +_exit: + if (code) { + tdbError("%s failed at %s:%d since %s", __func__, __FILE__, __LINE__, tstrerror(code)); + tdbPCacheClose(pCache); + *ppCache = NULL; + } else { + *ppCache = pCache; + } + return code; } int tdbPCacheClose(SPCache *pCache) { @@ -99,14 +105,14 @@ static int tdbPCacheAlterImpl(SPCache *pCache, int32_t nPage) { } else if (pCache->nPages < nPage) { SPage **aPage = tdbOsCalloc(nPage, sizeof(SPage *)); if (aPage == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } for (int32_t iPage = pCache->nPages; iPage < nPage; iPage++) { - if (tdbPageCreate(pCache->szPage, &aPage[iPage], tdbDefaultMalloc, NULL) < 0) { - // TODO: handle error + int32_t code = tdbPageCreate(pCache->szPage, &aPage[iPage], tdbDefaultMalloc, NULL); + if (code) { tdbOsFree(aPage); - return -1; + return code; } // pPage->pgid = 0; @@ -156,15 +162,11 @@ static int tdbPCacheAlterImpl(SPCache *pCache, int32_t nPage) { } int tdbPCacheAlter(SPCache *pCache, int32_t nPage) { - int ret = 0; - + int code; tdbPCacheLock(pCache); - - ret = tdbPCacheAlterImpl(pCache, nPage); - + code = tdbPCacheAlterImpl(pCache, nPage); tdbPCacheUnlock(pCache); - - return ret; + return code; } SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) { @@ -180,9 +182,6 @@ SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) { tdbPCacheUnlock(pCache); - // printf("thread %" PRId64 " fetch page %d pgno %d pPage %p nRef %d\n", taosGetSelfPthreadId(), pPage->id, - // TDB_PAGE_PGNO(pPage), pPage, nRef); - if (pPage) { tdbTrace("pcache/fetch page %p/%d/%d/%d", pPage, TDB_PAGE_PGNO(pPage), pPage->id, nRef); } else { @@ -285,6 +284,7 @@ static SPage *tdbPCacheFetchImpl(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) if (!pTxn) { tdbError("tdb/pcache: null ptr pTxn, fetch impl failed."); + terrno = TSDB_CODE_INVALID_PARA; return NULL; } @@ -327,7 +327,7 @@ static SPage *tdbPCacheFetchImpl(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) ret = tdbPageCreate(pCache->szPage, &pPage, pTxn->xMalloc, pTxn->xArg); if (ret < 0 || pPage == NULL) { tdbError("tdb/pcache: ret: %" PRId32 " pPage: %p, page create failed.", ret, pPage); - // TODO: recycle other backup pages + terrno = ret; return NULL; } @@ -475,10 +475,8 @@ static int tdbPCacheOpenImpl(SPCache *pCache) { pCache->nFree = 0; pCache->pFree = NULL; for (int i = 0; i < pCache->nPages; i++) { - if (tdbPageCreate(pCache->szPage, &pPage, tdbDefaultMalloc, NULL) < 0) { - // TODO: handle error - return -1; - } + ret = tdbPageCreate(pCache->szPage, &pPage, tdbDefaultMalloc, NULL); + if (ret) return ret; // pPage->pgid = 0; pPage->isAnchor = 0; @@ -504,8 +502,7 @@ static int tdbPCacheOpenImpl(SPCache *pCache) { pCache->nHash = pCache->nPages < 8 ? 8 : pCache->nPages; pCache->pgHash = (SPage **)tdbOsCalloc(pCache->nHash, sizeof(SPage *)); if (pCache->pgHash == NULL) { - // TODO - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } // Open LRU list diff --git a/source/libs/tdb/src/db/tdbPage.c b/source/libs/tdb/src/db/tdbPage.c index c6310f4985..322b735163 100644 --- a/source/libs/tdb/src/db/tdbPage.c +++ b/source/libs/tdb/src/db/tdbPage.c @@ -45,12 +45,12 @@ int tdbPageCreate(int pageSize, SPage **ppPage, void *(*xMalloc)(void *, size_t) if (!xMalloc) { tdbError("tdb/page-create: null xMalloc."); - return -1; + return TSDB_CODE_INVALID_PARA; } if (!TDB_IS_PGSIZE_VLD(pageSize)) { tdbError("tdb/page-create: invalid pageSize: %d.", pageSize); - return -1; + return TSDB_CODE_INVALID_PARA; } *ppPage = NULL; @@ -58,7 +58,7 @@ int tdbPageCreate(int pageSize, SPage **ppPage, void *(*xMalloc)(void *, size_t) ptr = (u8 *)(xMalloc(arg, size)); if (ptr == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } memset(ptr, 0, size); @@ -86,12 +86,12 @@ int tdbPageDestroy(SPage *pPage, void (*xFree)(void *arg, void *ptr), void *arg) if (pPage->isDirty) { tdbError("tdb/page-destroy: dirty page: %" PRIu8 ".", pPage->isDirty); - return -1; + return TSDB_CODE_INVALID_PARA; } if (!xFree) { tdbError("tdb/page-destroy: null xFree."); - return -1; + return TSDB_CODE_INVALID_PARA; } for (int iOvfl = 0; iOvfl < pPage->nOverflow; iOvfl++) { @@ -129,7 +129,8 @@ void tdbPageInit(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell tdbTrace("page/init: %p %" PRIu8 " %p", pPage, szAmHdr, xCellSize); pPage->pPageHdr = pPage->pData + szAmHdr; if (TDB_PAGE_NCELLS(pPage) == 0) { - return tdbPageZero(pPage, szAmHdr, xCellSize); + tdbPageZero(pPage, szAmHdr, xCellSize); + return; } pPage->pCellIdx = pPage->pPageHdr + TDB_PAGE_HDR_SIZE(pPage); pPage->pFreeStart = pPage->pCellIdx + TDB_PAGE_OFFSET_SIZE(pPage) * TDB_PAGE_NCELLS(pPage); @@ -159,7 +160,7 @@ int tdbPageInsertCell(SPage *pPage, int idx, SCell *pCell, int szCell, u8 asOvfl if (szCell > TDB_PAGE_MAX_FREE_BLOCK(pPage, pPage->pPageHdr - pPage->pData)) { tdbError("tdb/page-insert-cell: invalid page, szCell: %d, max free: %lu", szCell, TDB_PAGE_MAX_FREE_BLOCK(pPage, pPage->pPageHdr - pPage->pData)); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } nFree = TDB_PAGE_NFREE(pPage); @@ -207,7 +208,7 @@ int tdbPageInsertCell(SPage *pPage, int idx, SCell *pCell, int szCell, u8 asOvfl if (pPage->pFreeStart != pPage->pCellIdx + TDB_PAGE_OFFSET_SIZE(pPage) * (nCells + 1)) { tdbError("tdb/page-insert-cell: invalid page, pFreeStart: %p, pCellIdx: %p, nCells: %d", pPage->pFreeStart, pPage->pCellIdx, nCells); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } } @@ -234,7 +235,7 @@ int tdbPageDropCell(SPage *pPage, int idx, TXN *pTxn, SBTree *pBt) { if (idx < 0 || idx >= nCells + pPage->nOverflow) { tdbError("tdb/page-drop-cell: idx: %d out of range, nCells: %d, nOvfl: %d.", idx, nCells, pPage->nOverflow); - return -1; + return TSDB_CODE_INVALID_PARA; } iOvfl = 0; @@ -265,14 +266,14 @@ int tdbPageDropCell(SPage *pPage, int idx, TXN *pTxn, SBTree *pBt) { pPage->aiOvfl[iOvfl]--; if (pPage->aiOvfl[iOvfl] <= 0) { tdbError("tdb/page-drop-cell: invalid ai idx: %d", pPage->aiOvfl[iOvfl]); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } } return 0; } -void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl) { +int32_t tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl) { int delta, nFree; pToPage->pFreeStart = pToPage->pPageHdr + (pFromPage->pFreeStart - pFromPage->pPageHdr); @@ -280,7 +281,7 @@ void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl) { if (pToPage->pFreeEnd < pToPage->pFreeStart) { tdbError("tdb/page-copy: invalid to page, pFreeStart: %p, pFreeEnd: %p", pToPage->pFreeStart, pToPage->pFreeEnd); - return; + return TSDB_CODE_INVALID_DATA_FMT; } memcpy(pToPage->pPageHdr, pFromPage->pPageHdr, pFromPage->pFreeStart - pFromPage->pPageHdr); @@ -289,7 +290,7 @@ void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl) { if (TDB_PAGE_CCELLS(pToPage) != pToPage->pFreeEnd - pToPage->pData) { tdbError("tdb/page-copy: invalid to page, cell body: %d, range: %ld", TDB_PAGE_CCELLS(pToPage), pToPage->pFreeEnd - pToPage->pData); - return; + return TSDB_CODE_INVALID_DATA_FMT; } delta = (pToPage->pPageHdr - pToPage->pData) - (pFromPage->pPageHdr - pFromPage->pData); @@ -304,6 +305,10 @@ void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl) { if (deepCopyOvfl) { int szCell = (*pFromPage->xCellSize)(pFromPage, pFromPage->apOvfl[iOvfl], 0, NULL, NULL); pNewCell = (SCell *)tdbOsMalloc(szCell); + if (pNewCell == NULL) { + tdbError("tdb/page-copy: out of memory, size: %d", szCell); + return TSDB_CODE_OUT_OF_MEMORY; + } memcpy(pNewCell, pFromPage->apOvfl[iOvfl], szCell); tdbTrace("tdbPage/copy/new ovfl cell: %p/%p/%p", pNewCell, pToPage, pFromPage); } @@ -312,6 +317,7 @@ void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl) { pToPage->aiOvfl[iOvfl] = pFromPage->aiOvfl[iOvfl]; } pToPage->nOverflow = pFromPage->nOverflow; + return 0; } int tdbPageCapacity(int pageSize, int amHdrSize) { @@ -343,12 +349,12 @@ static int tdbPageAllocate(SPage *pPage, int szCell, SCell **ppCell) { if (nFree < szCell + TDB_PAGE_OFFSET_SIZE(pPage)) { tdbError("tdb/page-allocate: invalid cell size, nFree: %d, szCell: %d, szOffset: %d", nFree, szCell, TDB_PAGE_OFFSET_SIZE(pPage)); - return -1; + return TSDB_CODE_INVALID_PARA; } if (TDB_PAGE_CCELLS(pPage) != pPage->pFreeEnd - pPage->pData) { tdbError("tdb/page-allocate: invalid page, cell body: %d, range: %ld", TDB_PAGE_CCELLS(pPage), pPage->pFreeEnd - pPage->pData); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } // 1. Try to allocate from the free space block area @@ -363,7 +369,7 @@ static int tdbPageAllocate(SPage *pPage, int szCell, SCell **ppCell) { cellFree = TDB_PAGE_FCELL(pPage); if (cellFree != 0 && cellFree < pPage->pFreeEnd - pPage->pData) { tdbError("tdb/page-allocate: cellFree: %d, pFreeEnd: %p, pData: %p.", cellFree, pPage->pFreeEnd, pPage->pData); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } if (cellFree && pPage->pFreeEnd - pPage->pFreeStart >= TDB_PAGE_OFFSET_SIZE(pPage)) { SCell *pPrevFreeCell = NULL; @@ -408,19 +414,19 @@ static int tdbPageAllocate(SPage *pPage, int szCell, SCell **ppCell) { } // 3. Try to dfragment and allocate again - tdbPageDefragment(pPage); + TAOS_CHECK_RETURN(tdbPageDefragment(pPage)); if (pPage->pFreeEnd - pPage->pFreeStart != nFree) { tdbError("tdb/page-allocate: nFree: %d, pFreeStart: %p, pFreeEnd: %p.", nFree, pPage->pFreeStart, pPage->pFreeEnd); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } if (TDB_PAGE_NFREE(pPage) != nFree) { tdbError("tdb/page-allocate: nFree: %d, page free: %d.", nFree, TDB_PAGE_NFREE(pPage)); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } if (pPage->pFreeEnd - pPage->pData != TDB_PAGE_CCELLS(pPage)) { tdbError("tdb/page-allocate: ccells: %d, pFreeStart: %p, pData: %p.", TDB_PAGE_CCELLS(pPage), pPage->pFreeStart, pPage->pData); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } pPage->pFreeEnd -= szCell; @@ -430,7 +436,7 @@ static int tdbPageAllocate(SPage *pPage, int szCell, SCell **ppCell) { _alloc_finish: if (NULL == pCell) { tdbError("tdb/page-allocate: null ptr pCell."); - return -1; + return TSDB_CODE_OUT_OF_BUFFER; } pPage->pFreeStart += TDB_PAGE_OFFSET_SIZE(pPage); @@ -447,15 +453,15 @@ static int tdbPageFree(SPage *pPage, int idx, SCell *pCell, int szCell) { if (pCell < pPage->pFreeEnd) { tdbError("tdb/page-free: invalid cell, cell: %p, free end: %p", pCell, pPage->pFreeEnd); - return -1; + return TSDB_CODE_INVALID_PARA; } if (pCell + szCell > (u8 *)(pPage->pPageFtr)) { tdbError("tdb/page-free: cell crosses page footer, cell: %p, size: %d footer: %p", pCell, szCell, pPage->pFreeEnd); - return -1; + return TSDB_CODE_INVALID_PARA; } if (pCell != TDB_PAGE_CELL_AT(pPage, idx)) { tdbError("tdb/page-free: cell pos incorrect, cell: %p, pos: %p", pCell, TDB_PAGE_CELL_AT(pPage, idx)); - return -1; + return TSDB_CODE_INVALID_PARA; } nFree = TDB_PAGE_NFREE(pPage); @@ -470,7 +476,7 @@ static int tdbPageFree(SPage *pPage, int idx, SCell *pCell, int szCell) { TDB_PAGE_FCELL_SET(pPage, pCell - pPage->pData); } else { tdbError("tdb/page-free: invalid cell size: %d", szCell); - return -1; + return TSDB_CODE_INVALID_PARA; } } @@ -502,7 +508,9 @@ static int tdbPageDefragment(SPage *pPage) { int32_t nCell = TDB_PAGE_NCELLS(pPage); SCellIdx *aCellIdx = (SCellIdx *)tdbOsMalloc(sizeof(SCellIdx) * nCell); - if (aCellIdx == NULL) return -1; + if (aCellIdx == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t iCell = 0; iCell < nCell; iCell++) { aCellIdx[iCell].iCell = iCell; aCellIdx[iCell].offset = TDB_PAGE_CELL_OFFSET_AT(pPage, iCell); diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c index 9dbac11b02..14165045ca 100644 --- a/source/libs/tdb/src/db/tdbPager.c +++ b/source/libs/tdb/src/db/tdbPager.c @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#include "tdbInt.h" #include "crypt.h" +#include "tdbInt.h" #include "tglobal.h" /* #pragma pack(push, 1) @@ -41,9 +41,10 @@ struct hashset_st { static const unsigned int prime = 39; static const unsigned int prime2 = 5009; -hashset_t hashset_create(void) { +static hashset_t hashset_create(void) { hashset_t set = tdbOsCalloc(1, sizeof(struct hashset_st)); if (!set) { + terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } @@ -52,6 +53,7 @@ hashset_t hashset_create(void) { set->items = tdbOsCalloc(set->capacity, sizeof(size_t)); if (!set->items) { tdbOsFree(set); + terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } set->mask = set->capacity - 1; @@ -69,7 +71,7 @@ void hashset_destroy(hashset_t set) { } } -int hashset_add_member(hashset_t set, void *item) { +static int hashset_add_member(hashset_t set, void *item) { size_t value = (size_t)item; size_t h; @@ -88,7 +90,7 @@ int hashset_add_member(hashset_t set, void *item) { return 1; } -int hashset_add(hashset_t set, void *item) { +static int hashset_add(hashset_t set, void *item) { int ret = hashset_add_member(set, item); size_t old_capacity = set->capacity; @@ -113,7 +115,7 @@ int hashset_add(hashset_t set, void *item) { return ret; } -int hashset_remove(hashset_t set, void *item) { +static int hashset_remove(hashset_t set, void *item) { size_t value = (size_t)item; for (size_t h = set->mask & (prime * value); set->items[h] != 0; h = set->mask & (h + prime2)) { @@ -127,7 +129,7 @@ int hashset_remove(hashset_t set, void *item) { return 0; } -int hashset_contains(hashset_t set, void *item) { +static int hashset_contains(hashset_t set, void *item) { size_t value = (size_t)item; for (size_t h = set->mask & (prime * value); set->items[h] != 0; h = set->mask & (h + prime2)) { @@ -177,7 +179,7 @@ int tdbPagerOpen(SPCache *pCache, const char *fileName, SPager **ppPager) { + fsize + 8 + 1; /* jFileName */ pPtr = (uint8_t *)tdbOsCalloc(1, zsize); if (pPtr == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } pPager = (SPager *)pPtr; @@ -198,12 +200,12 @@ int tdbPagerOpen(SPCache *pCache, const char *fileName, SPager **ppPager) { pPager->fd = tdbOsOpen(pPager->dbFileName, TDB_O_CREAT | TDB_O_RDWR, 0755); if (TDB_FD_INVALID(pPager->fd)) { // if (pPager->fd < 0) { - return -1; + return TAOS_SYSTEM_ERROR(errno); } ret = tdbGnrtFileID(pPager->fd, pPager->fid, false); if (ret < 0) { - return -1; + return TAOS_SYSTEM_ERROR(errno); } // pPager->jfd = -1; @@ -221,11 +223,6 @@ int tdbPagerOpen(SPCache *pCache, const char *fileName, SPager **ppPager) { int tdbPagerClose(SPager *pPager) { if (pPager) { - /* - if (pPager->inTran) { - tdbOsClose(pPager->jfd); - } - */ tdbOsClose(pPager->fd); tdbOsFree(pPager); } @@ -254,8 +251,8 @@ int tdbPagerWrite(SPager *pPager, SPage *pPage) { !hashset_contains(pPager->pActiveTxn->jPageSet, (void *)((long)TDB_PAGE_PGNO(pPage))))) { ret = tdbPagerWritePageToJournal(pPager, pPage); if (ret < 0) { - tdbError("failed to write page to journal since %s", tstrerror(terrno)); - return -1; + tdbError("failed to write page to journal since %s", tstrerror(ret)); + return ret; } if (pPager->pActiveTxn->jPageSet) { @@ -278,11 +275,13 @@ int tdbPagerBegin(SPager *pPager, TXN *pTxn) { pTxn->jfd = tdbOsOpen(jTxnFileName, TDB_O_CREAT | TDB_O_RDWR, 0755); if (TDB_FD_INVALID(pTxn->jfd)) { tdbError("failed to open file due to %s. jFileName:%s", strerror(errno), pPager->jFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } pTxn->jPageSet = hashset_create(); + if (pTxn->jPageSet == NULL) { + return terrno; + } pPager->pActiveTxn = pTxn; @@ -319,8 +318,7 @@ int tdbPagerCommit(SPager *pPager, TXN *pTxn) { ret = tdbOsFSync(pTxn->jfd); if (ret < 0) { tdbError("failed to fsync: %s. jFileName:%s, %" PRId64, strerror(errno), pPager->jFileName, pTxn->txnId); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } // loop to write the dirty pages to file @@ -331,13 +329,13 @@ int tdbPagerCommit(SPager *pPager, TXN *pTxn) { if (pPage->nOverflow != 0) { tdbError("tdb/pager-commit: %p, pPage: %p, ovfl: %d, commit page failed.", pPager, pPage, pPage->nOverflow); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } ret = tdbPagerPWritePageToDB(pPager, pPage); if (ret < 0) { tdbError("failed to write page to db since %s", tstrerror(terrno)); - return -1; + return ret; } } @@ -368,8 +366,7 @@ int tdbPagerCommit(SPager *pPager, TXN *pTxn) { // sync the db file if (tdbOsFSync(pPager->fd) < 0) { tdbError("failed to fsync fd due to %s. file:%s", strerror(errno), pPager->dbFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } return 0; @@ -382,14 +379,12 @@ int tdbPagerPostCommit(SPager *pPager, TXN *pTxn) { // remove the journal file if (tdbOsClose(pTxn->jfd) < 0) { tdbError("failed to close jfd: %s. file:%s, %" PRId64, strerror(errno), pPager->jFileName, pTxn->txnId); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } if (tdbOsRemove(jTxnFileName) < 0 && errno != ENOENT) { tdbError("failed to remove file due to %s. file:%s", strerror(errno), jTxnFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } // pPager->inTran = 0; @@ -408,8 +403,7 @@ int tdbPagerPrepareAsyncCommit(SPager *pPager, TXN *pTxn) { ret = tdbOsFSync(pTxn->jfd); if (ret < 0) { tdbError("failed to fsync jfd: %s. jfile:%s, %" PRId64, strerror(errno), pPager->jFileName, pTxn->txnId); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } // loop to write the dirty pages to file @@ -426,7 +420,7 @@ int tdbPagerPrepareAsyncCommit(SPager *pPager, TXN *pTxn) { ret = tdbPagerPWritePageToDB(pPager, pPage); if (ret < 0) { tdbError("failed to write page to db since %s", tstrerror(terrno)); - return -1; + return ret; } } @@ -445,36 +439,28 @@ int tdbPagerPrepareAsyncCommit(SPager *pPager, TXN *pTxn) { tdbPCacheRelease(pPager->pCache, pPage, pTxn); } - /* - tdbTrace("reset dirty tree: %p", &pPager->rbt); - tRBTreeCreate(&pPager->rbt, pageCmpFn); - - // sync the db file - if (tdbOsFSync(pPager->fd) < 0) { - tdbError("failed to fsync fd due to %s. file:%s", strerror(errno), pPager->dbFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; - } - */ return 0; } -static char* tdbEncryptPage(SPager *pPager, char* pPageData, int32_t pageSize, const char* function, - int64_t offset){ +static char *tdbEncryptPage(SPager *pPager, char *pPageData, int32_t pageSize, const char *function, int64_t offset) { int32_t encryptAlgorithm = pPager->pEnv->encryptAlgorithm; - char* encryptKey = pPager->pEnv->encryptKey; + char *encryptKey = pPager->pEnv->encryptKey; - char* buf = pPageData; + char *buf = pPageData; - if(encryptAlgorithm == DND_CA_SM4){ - //tdbInfo("CBC_Encrypt key:%d %s %s", encryptAlgorithm, encryptKey, __FUNCTION__); - //ASSERT(strlen(encryptKey) > 0); + if (encryptAlgorithm == DND_CA_SM4) { + // tdbInfo("CBC_Encrypt key:%d %s %s", encryptAlgorithm, encryptKey, __FUNCTION__); + // ASSERT(strlen(encryptKey) > 0); - //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d before Encrypt", offset, pPage->pData[0]); + // tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d before Encrypt", offset, pPage->pData[0]); buf = taosMemoryMalloc(pageSize); + if (buf == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } - unsigned char packetData[128]; + unsigned char packetData[128]; int32_t count = 0; while (count < pageSize) { @@ -488,19 +474,19 @@ static char* tdbEncryptPage(SPager *pPager, char* pPageData, int32_t pageSize, c int32_t newLen = CBC_Encrypt(&opts); memcpy(buf + count, packetData, newLen); - count += newLen; + count += newLen; } - //tdbInfo("CBC tdb offset:%" PRId64 ", Encrypt count:%d %s", offset, count, function); + // tdbInfo("CBC tdb offset:%" PRId64 ", Encrypt count:%d %s", offset, count, function); - //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d after Encrypt", offset, (uint8_t)buf[0]); + // tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d after Encrypt", offset, (uint8_t)buf[0]); } return buf; } -void tdbFreeEncryptBuf(SPager *pPager, char* buf){ +void tdbFreeEncryptBuf(SPager *pPager, char *buf) { int32_t encryptAlgorithm = pPager->pEnv->encryptAlgorithm; - if(encryptAlgorithm == DND_CA_SM4) taosMemoryFreeClear(buf); + if (encryptAlgorithm == DND_CA_SM4) taosMemoryFreeClear(buf); } // recovery dirty pages int tdbPagerAbort(SPager *pPager, TXN *pTxn) { @@ -518,26 +504,24 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) { ret = tdbOsFSync(pTxn->jfd); if (ret < 0) { tdbError("failed to fsync jfd: %s. jfile:%s, %" PRId64, strerror(errno), pPager->jFileName, pTxn->txnId); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } tdb_fd_t jfd = pTxn->jfd; ret = tdbGetFileSize(jfd, pPager->pageSize, &journalSize); if (ret < 0) { - return -1; + return ret; } if (tdbOsLSeek(jfd, 0L, SEEK_SET) < 0) { tdbError("failed to lseek jfd due to %s. file:%s, offset:0", strerror(errno), pPager->dbFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } u8 *pageBuf = tdbOsCalloc(1, pPager->pageSize); if (pageBuf == NULL) { - return -1; + return terrno = TSDB_CODE_OUT_OF_MEMORY; } tdbDebug("pager/abort: %p, %d/%d, txnId:%" PRId64, pPager, pPager->dbOrigSize, pPager->dbFileSize, pTxn->txnId); @@ -549,7 +533,7 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) { int ret = tdbOsRead(jfd, &pgno, sizeof(pgno)); if (ret < 0) { tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } tdbTrace("pager/abort: restore pgno:%d,", pgno); @@ -559,27 +543,28 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) { ret = tdbOsRead(jfd, pageBuf, pPager->pageSize); if (ret < 0) { tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } i64 offset = pPager->pageSize * (pgno - 1); if (tdbOsLSeek(pPager->fd, offset, SEEK_SET) < 0) { tdbError("failed to lseek fd due to %s. file:%s, offset:%" PRId64, strerror(errno), pPager->dbFileName, offset); - terrno = TAOS_SYSTEM_ERROR(errno); tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } - char* buf = tdbEncryptPage(pPager, pageBuf, pPager->pageSize, __FUNCTION__, offset); + char *buf = tdbEncryptPage(pPager, pageBuf, pPager->pageSize, __FUNCTION__, offset); + if (buf == NULL) { + return terrno; + } ret = tdbOsWrite(pPager->fd, buf, pPager->pageSize); if (ret < 0) { tdbError("failed to write buf due to %s. file: %s, bufsize:%d", strerror(errno), pPager->dbFileName, pPager->pageSize); tdbFreeEncryptBuf(pPager, buf); - terrno = TAOS_SYSTEM_ERROR(errno); tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } tdbFreeEncryptBuf(pPager, buf); @@ -587,9 +572,8 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) { if (tdbOsFSync(pPager->fd) < 0) { tdbError("failed to fsync fd due to %s. dbfile:%s", strerror(errno), pPager->dbFileName); - terrno = TAOS_SYSTEM_ERROR(errno); tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } tdbOsFree(pageBuf); @@ -617,8 +601,7 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) { // 4, remove the journal file if (tdbOsClose(pTxn->jfd) < 0) { tdbError("failed to close jfd: %s. file:%s, %" PRId64, strerror(errno), pPager->jFileName, pTxn->txnId); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } char jTxnFileName[TDB_FILENAME_LEN]; @@ -626,8 +609,7 @@ int tdbPagerAbort(SPager *pPager, TXN *pTxn) { if (tdbOsRemove(jTxnFileName) < 0 && errno != ENOENT) { tdbError("failed to remove file due to %s. file:%s", strerror(errno), jTxnFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } // pPager->inTran = 0; @@ -658,7 +640,7 @@ int tdbPagerFlushPage(SPager *pPager, TXN *pTxn) { ret = tdbPagerPWritePageToDB(pPager, pPage); if (ret < 0) { tdbError("failed to write page to db since %s", tstrerror(terrno)); - return -1; + return ret; } tdbTrace("tdb/flush:%p, pgno:%d, %d/%d/%d", pPager, pgno, pPager->dbOrigSize, pPager->dbFileSize, maxPgno); @@ -717,13 +699,13 @@ int tdbPagerFetchPage(SPager *pPager, SPgno *ppgno, SPage **ppPage, int (*initPa ret = tdbPagerAllocPage(pPager, &pgno, pTxn); if (ret < 0) { tdbError("tdb/pager: %p, ret: %d pgno: %" PRIu32 ", alloc page failed.", pPager, ret, pgno); - return -1; + return ret; } } if (pgno == 0) { tdbError("tdb/pager: %p, ret: %d pgno: %" PRIu32 ", alloc page failed.", pPager, ret, pgno); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } // fetch a page container @@ -739,7 +721,7 @@ int tdbPagerFetchPage(SPager *pPager, SPgno *ppgno, SPage **ppPage, int (*initPa ret = tdbPagerInitPage(pPager, pPage, initPage, arg, loadPage); if (ret < 0) { tdbError("tdb/pager: %p, pPage: %p, init page failed.", pPager, pPage); - return -1; + return ret; } } @@ -748,11 +730,11 @@ int tdbPagerFetchPage(SPager *pPager, SPgno *ppgno, SPage **ppPage, int (*initPa if (!TDB_PAGE_INITIALIZED(pPage)) { tdbError("tdb/pager: %p, pPage: %p, fetch page uninited.", pPager, pPage); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } if (pPage->pPager != pPager) { tdbError("tdb/pager: %p/%p, fetch page failed.", pPager, pPage->pPager); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } *ppgno = pgno; @@ -771,12 +753,17 @@ int tdbPagerInsertFreePage(SPager *pPager, SPage *pPage, TXN *pTxn) { SPgno pgno = TDB_PAGE_PGNO(pPage); if (pPager->frps) { - taosArrayPush(pPager->frps, &pgno); + if (taosArrayPush(pPager->frps, &pgno) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } pPage->pPager = NULL; return code; } pPager->frps = taosArrayInit(8, sizeof(SPgno)); + if (pPager->frps == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } // memset(pPage->pData, 0, pPage->pageSize); tdbTrace("tdb/insert-free-page: tbc recycle page: %d.", pgno); // printf("tdb/insert-free-page: tbc recycle page: %d.\n", pgno); @@ -785,7 +772,7 @@ int tdbPagerInsertFreePage(SPager *pPager, SPage *pPage, TXN *pTxn) { tdbError("tdb/insert-free-page: tb insert failed with ret: %d.", code); taosArrayDestroy(pPager->frps); pPager->frps = NULL; - return -1; + return code; } while (TARRAY_SIZE(pPager->frps) > 0) { @@ -796,7 +783,7 @@ int tdbPagerInsertFreePage(SPager *pPager, SPage *pPage, TXN *pTxn) { tdbError("tdb/insert-free-page: tb insert failed with ret: %d.", code); taosArrayDestroy(pPager->frps); pPager->frps = NULL; - return -1; + return code; } } @@ -822,7 +809,7 @@ static int tdbPagerRemoveFreePage(SPager *pPager, SPgno *pPgno, TXN *pTxn) { code = tdbTbcOpen(pPager->pEnv->pFreeDb, &pCur, pTxn); if (code < 0) { - return 0; + return code; } code = tdbTbcMoveToFirst(pCur); @@ -924,20 +911,19 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage } int32_t encryptAlgorithm = pPager->pEnv->encryptAlgorithm; - char* encryptKey = pPager->pEnv->encryptKey; + char *encryptKey = pPager->pEnv->encryptKey; - if(encryptAlgorithm == DND_CA_SM4){ - //tdbInfo("CBC_Decrypt key:%d %s %s", encryptAlgorithm, encryptKey, __FUNCTION__); - //ASSERT(strlen(encryptKey) > 0); + if (encryptAlgorithm == DND_CA_SM4) { + // tdbInfo("CBC_Decrypt key:%d %s %s", encryptAlgorithm, encryptKey, __FUNCTION__); + // ASSERT(strlen(encryptKey) > 0); - //uint8_t flags = pPage->pData[0]; - //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d before Decrypt", ((i64)pPage->pageSize) * (pgno - 1), flags); + // uint8_t flags = pPage->pData[0]; + // tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d before Decrypt", ((i64)pPage->pageSize) * (pgno - 1), flags); - unsigned char packetData[128]; + unsigned char packetData[128]; int32_t count = 0; - while(count < pPage->pageSize) - { + while (count < pPage->pageSize) { SCryptOpts opts = {0}; opts.len = 128; opts.source = pPage->pData + count; @@ -945,20 +931,23 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage opts.unitLen = 128; strncpy(opts.key, encryptKey, ENCRYPT_KEY_LEN); - int newLen = CBC_Decrypt(&opts); + int newLen = CBC_Decrypt(&opts); memcpy(pPage->pData + count, packetData, newLen); count += newLen; } - //tdbInfo("CBC tdb offset:%" PRId64 ", Decrypt count:%d %s", ((i64)pPage->pageSize) * (pgno - 1), count, __FUNCTION__); + // tdbInfo("CBC tdb offset:%" PRId64 ", Decrypt count:%d %s", ((i64)pPage->pageSize) * (pgno - 1), count, + // __FUNCTION__); - //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d after Decrypt %s", ((i64)pPage->pageSize) * (pgno - 1), pPage->pData[0], __FUNCTION__); + // tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d after Decrypt %s", ((i64)pPage->pageSize) * (pgno - 1), + // pPage->pData[0], __FUNCTION__); } } else { init = 0; } - //tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d initPage %s", ((i64)pPage->pageSize) * (pgno - 1), pPage->pData[0], __FUNCTION__); + // tdbInfo("CBC tdb offset:%" PRId64 ", flag:%d initPage %s", ((i64)pPage->pageSize) * (pgno - 1), pPage->pData[0], + // __FUNCTION__); ret = (*initPage)(pPage, arg, init); if (ret < 0) { @@ -1001,16 +990,14 @@ static int tdbPagerWritePageToJournal(SPager *pPager, SPage *pPage) { if (ret < 0) { tdbError("failed to write pgno due to %s. file:%s, pgno:%u, txnId:%" PRId64, strerror(errno), pPager->jFileName, pgno, pPager->pActiveTxn->txnId); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } ret = tdbOsWrite(pPager->pActiveTxn->jfd, pPage->pData, pPage->pageSize); if (ret < 0) { tdbError("failed to write page data due to %s. file:%s, pageSize:%d, txnId:%" PRId64, strerror(errno), pPager->jFileName, pPage->pageSize, pPager->pActiveTxn->txnId); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } return 0; @@ -1044,15 +1031,14 @@ static int tdbPagerPWritePageToDB(SPager *pPager, SPage *pPage) { offset = (i64)pPage->pageSize * (TDB_PAGE_PGNO(pPage) - 1); - char* buf = tdbEncryptPage(pPager, pPage->pData, pPage->pageSize, __FUNCTION__, offset); + char *buf = tdbEncryptPage(pPager, pPage->pData, pPage->pageSize, __FUNCTION__, offset); ret = tdbOsPWrite(pPager->fd, buf, pPage->pageSize, offset); if (ret < 0) { tdbFreeEncryptBuf(pPager, buf); tdbError("failed to pwrite page data due to %s. file:%s, pageSize:%d", strerror(errno), pPager->dbFileName, pPage->pageSize); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } tdbFreeEncryptBuf(pPager, buf); @@ -1072,18 +1058,17 @@ static int tdbPagerRestore(SPager *pPager, const char *jFileName) { ret = tdbGetFileSize(jfd, pPager->pageSize, &journalSize); if (ret < 0) { - return -1; + return TAOS_SYSTEM_ERROR(errno); } if (tdbOsLSeek(jfd, 0L, SEEK_SET) < 0) { tdbError("failed to lseek jfd due to %s. file:%s, offset:0", strerror(errno), pPager->dbFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } pageBuf = tdbOsCalloc(1, pPager->pageSize); if (pageBuf == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } tdbDebug("pager/restore: %p, %d/%d, txnId:%s", pPager, pPager->dbOrigSize, pPager->dbFileSize, jFileName); @@ -1095,7 +1080,7 @@ static int tdbPagerRestore(SPager *pPager, const char *jFileName) { int ret = tdbOsRead(jfd, &pgno, sizeof(pgno)); if (ret < 0) { tdbOsFree(pageBuf); - return -1; + return TAOS_SYSTEM_ERROR(errno); } tdbTrace("pager/restore: restore pgno:%d,", pgno); @@ -1103,27 +1088,28 @@ static int tdbPagerRestore(SPager *pPager, const char *jFileName) { ret = tdbOsRead(jfd, pageBuf, pPager->pageSize); if (ret < 0) { tdbOsFree(pageBuf); - return -1; + return TAOS_SYSTEM_ERROR(errno); } i64 offset = pPager->pageSize * (pgno - 1); if (tdbOsLSeek(pPager->fd, offset, SEEK_SET) < 0) { tdbError("failed to lseek fd due to %s. file:%s, offset:%" PRId64, strerror(errno), pPager->dbFileName, offset); - terrno = TAOS_SYSTEM_ERROR(errno); tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } - char* buf = tdbEncryptPage(pPager, pageBuf, pPager->pageSize, __FUNCTION__, offset); + char *buf = tdbEncryptPage(pPager, pageBuf, pPager->pageSize, __FUNCTION__, offset); + if (buf == NULL) { + return terrno; + } ret = tdbOsWrite(pPager->fd, buf, pPager->pageSize); if (ret < 0) { tdbError("failed to write buf due to %s. file: %s, bufsize:%d", strerror(errno), pPager->dbFileName, pPager->pageSize); tdbFreeEncryptBuf(pPager, buf); - terrno = TAOS_SYSTEM_ERROR(errno); tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } tdbFreeEncryptBuf(pPager, buf); @@ -1131,9 +1117,8 @@ static int tdbPagerRestore(SPager *pPager, const char *jFileName) { if (tdbOsFSync(pPager->fd) < 0) { tdbError("failed to fsync fd due to %s. dbfile:%s", strerror(errno), pPager->dbFileName); - terrno = TAOS_SYSTEM_ERROR(errno); tdbOsFree(pageBuf); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } tdbOsFree(pageBuf); @@ -1160,21 +1145,27 @@ static int32_t txnIdCompareDesc(const void *pLeft, const void *pRight) { } int tdbPagerRestoreJournals(SPager *pPager) { + int32_t code = 0; tdbDirEntryPtr pDirEntry; tdbDirPtr pDir = taosOpenDir(pPager->pEnv->dbName); if (pDir == NULL) { tdbError("failed to open %s since %s", pPager->pEnv->dbName, strerror(errno)); - return -1; + return TAOS_SYSTEM_ERROR(errno); } SArray *pTxnList = taosArrayInit(16, sizeof(int64_t)); + if (pTxnList == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } while ((pDirEntry = tdbReadDir(pDir)) != NULL) { char *name = tdbDirEntryBaseName(tdbGetDirEntryName(pDirEntry)); if (strncmp(TDB_MAINDB_NAME "-journal", name, 16) == 0) { int64_t txnId = -1; sscanf(name, TDB_MAINDB_NAME "-journal.%" PRId64, &txnId); - taosArrayPush(pTxnList, &txnId); + if (taosArrayPush(pTxnList, &txnId) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } } taosArraySort(pTxnList, txnIdCompareDesc); @@ -1185,12 +1176,12 @@ int tdbPagerRestoreJournals(SPager *pPager) { memcpy(jname, pPager->pEnv->dbName, dirLen); jname[dirLen] = '/'; sprintf(jname + dirLen + 1, TDB_MAINDB_NAME "-journal.%" PRId64, *pTxnId); - if (tdbPagerRestore(pPager, jname) < 0) { + code = tdbPagerRestore(pPager, jname); + if (code) { taosArrayDestroy(pTxnList); tdbCloseDir(&pDir); - - tdbError("failed to restore file due to %s. jFileName:%s", strerror(errno), jname); - return -1; + tdbError("failed to restore file due to %s. jFileName:%s", strerror(code), jname); + return code; } } @@ -1205,7 +1196,7 @@ int tdbPagerRollback(SPager *pPager) { tdbDirPtr pDir = taosOpenDir(pPager->pEnv->dbName); if (pDir == NULL) { tdbError("failed to open %s since %s", pPager->pEnv->dbName, strerror(errno)); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } while ((pDirEntry = tdbReadDir(pDir)) != NULL) { @@ -1221,8 +1212,7 @@ int tdbPagerRollback(SPager *pPager) { tdbCloseDir(&pDir); tdbError("failed to remove file due to %s. jFileName:%s", strerror(errno), name); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } } } diff --git a/source/libs/tdb/src/db/tdbTable.c b/source/libs/tdb/src/db/tdbTable.c index 3bc6f75bef..365be222ef 100644 --- a/source/libs/tdb/src/db/tdbTable.c +++ b/source/libs/tdb/src/db/tdbTable.c @@ -41,7 +41,7 @@ int tdbTbOpen(const char *tbname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprF pTb = (TTB *)tdbOsCalloc(1, sizeof(*pTb)); if (pTb == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } // pTb->pEnv @@ -54,7 +54,7 @@ int tdbTbOpen(const char *tbname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprF pPager = tdbEnvGetPager(pEnv, fFullName); if (!pPager) { tdbOsFree(pTb); - return -1; + return terrno; } ret = tdbTbGet(pPager->pEnv->pMainDb, tbname, strlen(tbname) + 1, &pData, &nData); @@ -74,7 +74,7 @@ int tdbTbOpen(const char *tbname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprF ret = tdbPagerOpen(pEnv->pCache, fFullName, &pPager); if (ret < 0) { tdbOsFree(pTb); - return -1; + return ret; } tdbEnvAddPager(pEnv, pPager); @@ -109,7 +109,7 @@ int tdbTbOpen(const char *tbname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprF ret = tdbPagerRestoreJournals(pPager); if (ret < 0) { tdbOsFree(pTb); - return -1; + return ret; } } else { tdbPagerRollback(pPager); @@ -119,7 +119,7 @@ int tdbTbOpen(const char *tbname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprF ret = tdbBtreeOpen(keyLen, valLen, pPager, tbname, pgno, keyCmprFn, pEnv, &(pTb->pBt)); if (ret < 0) { tdbOsFree(pTb); - return -1; + return ret; } *ppTb = pTb; diff --git a/source/libs/tdb/src/db/tdbTxn.c b/source/libs/tdb/src/db/tdbTxn.c index 0aeed3c140..24a70f62b2 100644 --- a/source/libs/tdb/src/db/tdbTxn.c +++ b/source/libs/tdb/src/db/tdbTxn.c @@ -20,7 +20,7 @@ int tdbTxnOpen(TXN *pTxn, int64_t txnid, void *(*xMalloc)(void *, size_t), void // not support read-committed version at the moment if (flags != 0 && flags != (TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED)) { tdbError("tdb/txn: invalid txn flags: %" PRId32, flags); - return -1; + return TSDB_CODE_INVALID_PARA; } pTxn->flags = flags; @@ -39,7 +39,7 @@ int tdbTxnCloseImpl(TXN *pTxn) { } if (pTxn->jfd) { - tdbOsClose(pTxn->jfd); + TAOS_UNUSED(tdbOsClose(pTxn->jfd)); ASSERT(pTxn->jfd == NULL); } diff --git a/source/libs/tdb/src/db/tdbUtil.c b/source/libs/tdb/src/db/tdbUtil.c index 9021e08ffe..d6d33bc7d8 100644 --- a/source/libs/tdb/src/db/tdbUtil.c +++ b/source/libs/tdb/src/db/tdbUtil.c @@ -38,9 +38,8 @@ void tdbFree(void *p) { int tdbGnrtFileID(tdb_fd_t fd, uint8_t *fileid, bool unique) { int64_t stDev = 0, stIno = 0; - if (taosDevInoFile(fd, &stDev, &stIno) < 0) { - return -1; - } + int32_t code = taosDevInoFile(fd, &stDev, &stIno); + return code; memset(fileid, 0, TDB_FILE_ID_LEN); @@ -59,7 +58,7 @@ int tdbGetFileSize(tdb_fd_t fd, int szPage, SPgno *size) { ret = tdbOsFileSize(fd, &szBytes); if (ret < 0) { - return -1; + return TAOS_SYSTEM_ERROR(errno); } *size = szBytes / szPage; diff --git a/source/libs/tdb/src/inc/tdbInt.h b/source/libs/tdb/src/inc/tdbInt.h index b359f8a4cc..605fe6a1a4 100644 --- a/source/libs/tdb/src/inc/tdbInt.h +++ b/source/libs/tdb/src/inc/tdbInt.h @@ -17,6 +17,7 @@ #define _TD_TDB_INTERNAL_H_ #include "tdb.h" +#include "tutil.h" #include "tdef.h" #include "tlog.h" @@ -338,15 +339,15 @@ static inline int tdbTryLockPage(tdb_spinlock_t *pLock) { ((*(pPage)->xCellSize)(pPage, pCell, 0, NULL, NULL) + (pPage)->pPageMethods->szOffset) #define TDB_PAGE_OFFSET_SIZE(pPage) ((pPage)->pPageMethods->szOffset) -int tdbPageCreate(int pageSize, SPage **ppPage, void *(*xMalloc)(void *, size_t), void *arg); -int tdbPageDestroy(SPage *pPage, void (*xFree)(void *arg, void *ptr), void *arg); -void tdbPageZero(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *, int, TXN *, SBTree *pBt)); -void tdbPageInit(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *, int, TXN *, SBTree *pBt)); -int tdbPageInsertCell(SPage *pPage, int idx, SCell *pCell, int szCell, u8 asOvfl); -int tdbPageDropCell(SPage *pPage, int idx, TXN *pTxn, SBTree *pBt); -int tdbPageUpdateCell(SPage *pPage, int idx, SCell *pCell, int szCell, TXN *pTxn, SBTree *pBt); -void tdbPageCopy(SPage *pFromPage, SPage *pToPage, int copyOvflCells); -int tdbPageCapacity(int pageSize, int amHdrSize); +int tdbPageCreate(int pageSize, SPage **ppPage, void *(*xMalloc)(void *, size_t), void *arg); +int tdbPageDestroy(SPage *pPage, void (*xFree)(void *arg, void *ptr), void *arg); +void tdbPageZero(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *, int, TXN *, SBTree *pBt)); +void tdbPageInit(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *, int, TXN *, SBTree *pBt)); +int tdbPageInsertCell(SPage *pPage, int idx, SCell *pCell, int szCell, u8 asOvfl); +int tdbPageDropCell(SPage *pPage, int idx, TXN *pTxn, SBTree *pBt); +int tdbPageUpdateCell(SPage *pPage, int idx, SCell *pCell, int szCell, TXN *pTxn, SBTree *pBt); +int32_t tdbPageCopy(SPage *pFromPage, SPage *pToPage, int deepCopyOvfl); +int tdbPageCapacity(int pageSize, int amHdrSize); static inline SCell *tdbPageGetCell(SPage *pPage, int idx) { SCell *pCell; diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c index f63339bcfc..79acec1211 100644 --- a/source/os/src/osFile.c +++ b/source/os/src/osFile.c @@ -67,7 +67,7 @@ typedef struct TdFile { void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, char *dstPath) { #ifdef WINDOWS - char tmpPath[PATH_MAX]; + char tmpPath[PATH_MAX]; int32_t len = (int32_t)strlen(inputTmpDir); memcpy(tmpPath, inputTmpDir, len); @@ -269,13 +269,13 @@ int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno) { #else if (pFile == NULL || pFile->fd < 0) { - return -1; + return TSDB_CODE_INVALID_PARA; } struct stat fileStat; int32_t code = fstat(pFile->fd, &fileStat); if (code < 0) { printf("taosFStatFile run fstat fail."); - return code; + return TAOS_SYSTEM_ERROR(errno); } if (stDev != NULL) { @@ -1239,7 +1239,7 @@ int64_t taosGetLineFile(TdFilePtr pFile, char **__restrict ptrBuf) { #ifdef WINDOWS size_t bufferSize = 512; *ptrBuf = taosMemoryMalloc(bufferSize); - if (*ptrBuf == NULL) goto END; + if (*ptrBuf == NULL) goto END; size_t bytesRead = 0; size_t totalBytesRead = 0; @@ -1274,7 +1274,7 @@ int64_t taosGetLineFile(TdFilePtr pFile, char **__restrict ptrBuf) { ret = getline(ptrBuf, &len, pFile->fp); #endif - END: +END: #if FILE_WITH_LOCK taosThreadRwlockUnlock(&(pFile->rwlock)); #endif @@ -1413,34 +1413,30 @@ int32_t taosLinkFile(char *src, char *dst) { return 0; } -FILE* taosOpenCFile(const char* filename, const char* mode) { - return fopen(filename, mode); -} +FILE *taosOpenCFile(const char *filename, const char *mode) { return fopen(filename, mode); } -int taosSeekCFile(FILE* file, int64_t offset, int whence) { +int taosSeekCFile(FILE *file, int64_t offset, int whence) { #ifdef WINDOWS return _fseeki64(file, offset, whence); #else return fseeko(file, offset, whence); -#endif +#endif } -size_t taosReadFromCFile(void *buffer, size_t size, size_t count, FILE *stream ) { +size_t taosReadFromCFile(void *buffer, size_t size, size_t count, FILE *stream) { return fread(buffer, size, count, stream); } -size_t taosWriteToCFile(const void* ptr, size_t size, size_t nitems, FILE* stream) { +size_t taosWriteToCFile(const void *ptr, size_t size, size_t nitems, FILE *stream) { return fwrite(ptr, size, nitems, stream); } -int taosCloseCFile(FILE *f) { - return fclose(f); -} +int taosCloseCFile(FILE *f) { return fclose(f); } -int taosSetAutoDelFile(char* path) { +int taosSetAutoDelFile(char *path) { #ifdef WINDOWS return SetFileAttributes(path, FILE_ATTRIBUTE_TEMPORARY); #else return unlink(path); -#endif +#endif } \ No newline at end of file diff --git a/tests/ci/ci_deploy_dependency_file_list.txt b/tests/ci/ci_deploy_dependency_file_list.txt new file mode 100644 index 0000000000..1e7afdd7db --- /dev/null +++ b/tests/ci/ci_deploy_dependency_file_list.txt @@ -0,0 +1,8 @@ +/home/m.json +/home/log_server.json +/var/lib/jenkins/workspace/restore.sh +/var/lib/jenkins/workspace/start_http.sh +/var/lib/jenkins/workspace/TDinternal +/var/lib/jenkins/workspace/remove_corefile.sh +/var/lib/jenkins/workspace/CI_disk_Monitor.py +/var/lib/jenkins/workspace/start_CI_Monitor.sh diff --git a/tests/ci/container_build_newmachine.sh b/tests/ci/container_build_newmachine.sh new file mode 100755 index 0000000000..3c87cf156f --- /dev/null +++ b/tests/ci/container_build_newmachine.sh @@ -0,0 +1,88 @@ +#!/bin/bash +set -e + +function usage() { + echo "$0" + echo -e "\t -w work dir" + echo -e "\t -e enterprise edition" + echo -e "\t -t make thread count" + echo -e "\t -h help" +} + +ent=0 +while getopts "w:t:eh" opt; do + case $opt in + w) + WORKDIR=$OPTARG + ;; + e) + ent=1 + ;; + t) + THREAD_COUNT=$OPTARG + ;; + h) + usage + exit 0 + ;; + \?) + echo "Invalid option: -$OPTARG" + usage + exit 0 + ;; + esac +done + +if [ -z "$WORKDIR" ]; then + usage + exit 1 +fi +# if [ -z "$THREAD_COUNT" ]; then +# THREAD_COUNT=1 +# fi + +ulimit -c unlimited + +if [ $ent -eq 0 ]; then + REP_DIR=/home/TDengine + REP_REAL_PATH=$WORKDIR/TDengine + REP_MOUNT_PARAM=$REP_REAL_PATH:/home/TDengine +else + REP_DIR=/home/TDinternal + REP_REAL_PATH=$WORKDIR/TDinternal + REP_MOUNT_PARAM=$REP_REAL_PATH:/home/TDinternal + +fi +date +docker run \ + -v $REP_MOUNT_PARAM \ + -v /root/.cargo/registry:/root/.cargo/registry \ + -v /root/.cargo/git:/root/.cargo/git \ + -v /root/go/pkg/mod:/root/go/pkg/mod \ + -v /root/.cache/go-build:/root/.cache/go-build \ + -v /root/.cos-local.1:/root/.cos-local.2 \ + --rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=true -DWEBSOCKET=true -DBUILD_SANITIZER=1 -DTOOLS_SANITIZE=true $CMAKE_BUILD_TYPE -DTOOLS_BUILD_TYPE=Debug -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j 10|| exit 1 " + # -v ${REP_REAL_PATH}/community/contrib/jemalloc/:${REP_DIR}/community/contrib/jemalloc \ + +if [[ -d ${WORKDIR}/debugNoSan ]] ;then + echo "delete ${WORKDIR}/debugNoSan" + rm -rf ${WORKDIR}/debugNoSan +fi +if [[ -d ${WORKDIR}/debugSan ]] ;then + echo "delete ${WORKDIR}/debugSan" + rm -rf ${WORKDIR}/debugSan +fi + +if [ "$(uname -m)" = "aarch64" ] ;then + CMAKE_BUILD_TYPE="-DCMAKE_BUILD_TYPE=Debug" +else + CMAKE_BUILD_TYPE="-DCMAKE_BUILD_TYPE=Release" +fi + + +mv ${REP_REAL_PATH}/debug ${WORKDIR}/debugSan +date + +ret=$? +exit $ret + diff --git a/tests/ci/deploy_ci_machines.sh b/tests/ci/deploy_ci_machines.sh new file mode 100644 index 0000000000..e34ec1d6e5 --- /dev/null +++ b/tests/ci/deploy_ci_machines.sh @@ -0,0 +1,69 @@ +#!/bin/bash + +function scp_file_from_host { + # check at least three parameters + if [ "$#" -lt 3 ]; then + echo "Usage: $0 host passwd source_filename [dest_filename]" + exit 1 + fi + + host=$1 + passwd=$2 + source_filename=$3 + # If the fourth parameter is not provided, use the third parameter as the default value + dest_filename=${4:-$3} + + # use sshpass and scp for secure file transfer + sshpass -p "$passwd" scp -o StrictHostKeyChecking=no -r "$host":"$source_filename" "$dest_filename" +} + + +# install docker and sshpass +curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | sudo apt-key add - +sudo add-apt-repository "deb [arch=amd64] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu $(lsb_release -cs) stable" +sudo apt-get update +sudo apt-get install -y docker-ce sshpass jq +sudo systemctl enable docker +sudo systemctl start docker + +# create a log directory +mkdir -p /var/lib/jenkins/workspace/log + +# Assuming you have a file called 'file_list.txt' with one filename per line +file_list="ci_deploy_dependency_file_list.txt" +monitorip="192.168.1.59" +passwd_all="abcdefg" + +# Read the file list and call scp_file_from_host for each file +while IFS= read -r source_filename; do + scp_file_from_host "$monitorip" "$passwd_all" "$source_filename" +done < "$file_list" + +# modify the configuration file +ip=$(ifconfig |grep inet|grep 192 |awk '{print $2}') +sed -i "s/${monitorip}/$ip/" /home/log_server.json +sed -i "s/${monitorip}/$ip/" /home/m.json + +#mkdir corefile dir and configure the system to automatically set corefile dir at startup +mkdir -p /home/coredump/ && echo "echo '/home/coredump/core_%e-%p' | sudo tee /proc/sys/kernel/core_pattern " >> /root/.bashrc + + +# get image from 0.212 +image_ip="192.168.0.212" +scp_file_from_host $image_ip $passwd_all "/home/tang/work/image/taos_image.tar " "/home/taos_image.tar" +docker load -i /home/taos_image.tar + +#start http server +nohup /var/lib/jenkins/workspace/log/start_http.sh & + +# start CI monitor and remove corefile in crontable +(crontab -l;echo "0 1 * * * /usr/bin/bash /var/lib/jenkins/workspace/remove_corefile.sh") | crontab +(crontab -l;echo "@reboot /usr/bin/bash /var/lib/jenkins/workspace/start_CI_Monitor.sh") | crontab + + +# generate cache dir +cd /var/lib/jenkins/workspace/TDinternal/community/tests/parallel_test || exit +time ./container_build_newmachine.sh -w /var/lib/jenkins/workspace -e + +# test if the CI machine compilation is successful +time ./container_build.sh -w /var/lib/jenkins/workspace -e \ No newline at end of file diff --git a/tests/ci/remove_corefile.sh b/tests/ci/remove_corefile.sh new file mode 100644 index 0000000000..7374101547 --- /dev/null +++ b/tests/ci/remove_corefile.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +date_str=$(date -d "4 day ago" +%Y%m%d) +if [ ! -z "$1" ]; then + date_str="$1" +fi +script_dir=$(dirname $0) +cd "${script_dir}"/log || exit +# date >>core.list +# find . -name "core.*" | grep "$date_str" >>core.list +# find . -name "core.*" | grep "$date_str" | xargs rm -rf +# find . -name "build_*" | grep "$date_str" | xargs rm -rf +for file in *; do + if [[ $file == *"$date_str"* ]]; then + rm -rf "$file" + fi +done diff --git a/tests/ci/restore.sh b/tests/ci/restore.sh new file mode 100644 index 0000000000..4c9daf73fe --- /dev/null +++ b/tests/ci/restore.sh @@ -0,0 +1,159 @@ +#!/bin/bash + set -x +JENKINS_LOG=jenkins.log +# pr_num=14228 +# n=1 +function usage() { + echo "$0" + echo -e "\t -p PR number" + echo -e "\t -n build number" + echo -e "\t -c container name" + echo -e "\t -h help" +} +while getopts "p:n:c:h" opt; do + case $opt in + p) + pr_num=$OPTARG + ;; + n) + n=$OPTARG + ;; + c) + container_name=$OPTARG + ;; + h) + usage + exit 0 + ;; + \?) + echo "Invalid option: -$OPTARG" + usage + exit 1 + ;; + esac +done +if [ -z "$container_name" ]; then + echo "container name not specified" + usage + exit 1 +fi +if [ -z "$pr_num" ]; then + echo "PR number not specified" + usage + exit 1 +fi +if [ -z "$n" ]; then + echo "build number not specified" + usage + exit 1 +fi +pr_num=`echo "$pr_num"|sed "s/PR-//"` +container_count=`docker ps -a -f name=$container_name|wc -l` +if [ $container_count -gt 1 ]; then + docker ps -a -f name=$container_name + echo "container $container_name exists" + exit 1 +fi +cd $(dirname $0) +info=`grep -n "^[0-9]\{8\}-[0-9]\{6\}" jenkins.log | grep -A 1 "PR-${pr_num}:${n}:"` +# 22131:20220625-113105 NewTest/PR-14228:PR-14228:1:3.0 +# 22270:20220625-121154 NewTest/PR-14221:PR-14221:2:3.0 +ci_hosts="\ +192.168.0.212 \ +192.168.0.215 \ +192.168.0.217 \ +192.168.0.219 \ +" +if [ -z "$info" ]; then + echo "PR-${pr_num}:${n} not found" + for host in $ci_hosts; do + ssh root@$host "sh -c \"grep -n \\\"^[0-9]\\\\\{8\\\\\}-[0-9]\\\\\{6\\\\\}\\\" /var/lib/jenkins/workspace/jenkins.log | grep \\\"PR-${pr_num}:${n}:\\\"\"" + if [ $? -eq 0 ]; then + echo "this PR is possibly on host $host" + break + fi + done + exit 1 +fi +line_num=`echo "$info"|wc -l` +curr=`echo "$info"|head -n1` +if [ "$line_num" == "2" ]; then + next=`echo "$info"|tail -n1` +fi + +# check if it is TDinternal CI +internal=0 +commit_prefix=community +echo "$curr"|grep -q TDinternalCI +if [ $? -eq 0 ]; then + internal=1 + commit_prefix=tdinternal +fi + +curr_line=`echo "$curr"|cut -d: -f1` +next_line='$' +if [ ! -z "$next" ]; then + next_line=`echo "$next"|cut -d: -f1` + next_line=$(( next_line - 1 )) +fi +# echo "$curr_line, $next_line" + +details=`sed -n "${curr_line},${next_line}p" $JENKINS_LOG` +merge_line=`echo "$details"|grep -A 10 "$commit_prefix log merged: "|grep "Merge .* into"|head -n1` +if [ -z "$merge_line" ]; then + echo "merge commit not found" + exit 1 +fi +echo "$merge_line" +branch=`echo "$merge_line"|awk '{print $2}'` +commit_id=`echo "$merge_line"|awk '{print $4}'` +# echo "$details" +community_id=`echo "$details"|grep "community log: commit"|awk '{print $NF}'` +internal_id=`echo "$details"|grep "tdinternal log: commit"|awk '{print $NF}'` +python_connector_id=`echo "$details"|grep "python connector log: commit"|awk '{print $NF}'` +# change_branch=`echo "$details"|grep "CHANGE_BRANCH"|sed "s/CHANGE_BRANCH://"` + +# if [ -z "${branch}" ]; then +# branch="$change_branch" +# fi + +PWD=`pwd` +log_dir=`ls log|grep "PR-${pr_num}_${n}_"` +if [ -z "$log_dir" ]; then + echo "no log dir found" +else + mount_dir="-v ${PWD}/log/$log_dir:/home/log" + build_dir=`ls log/$log_dir | grep "build_"` + if [ ! -z "$build_dir" ]; then + mount_dir="$mount_dir -v ${PWD}/log/$log_dir/$build_dir:/home/TDinternal/debug/build" + fi +fi + +docker run -d --privileged -it --name $container_name \ + $mount_dir \ + taos_test:v1.0 bash + +if [ $internal -eq 0 ]; then + docker exec $container_name /home/setup.sh -c $commit_id -m $branch -n + echo "TDinternal checkout: $internal_id" + docker exec $container_name sh -c "cd /home/TDinternal; git checkout $internal_id" +else + docker exec $container_name /home/setup.sh -e -c $commit_id -m $branch -n + echo "community checkout: $community_id" + docker exec $container_name sh -c "cd /home/TDinternal/community; git checkout $community_id" +fi +echo +echo "* run the following command to enter the container:" +echo " docker exec -it $container_name bash" +if [ -z "$log_dir" ]; then + echo "* no log dir found" +else + echo "* log and coredump files are located in /home/log" +fi +if [ -z "$build_dir" ]; then + echo "* no build dir found" +else + echo "* build files are located in /home/TDinternal/debug/build" +fi +echo "* source files are located in /home/TDinternal" + diff --git a/tests/ci/start_http.sh b/tests/ci/start_http.sh new file mode 100644 index 0000000000..f73ffc85c8 --- /dev/null +++ b/tests/ci/start_http.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +script_dir=$(dirname $0) +cd $script_dir || exit +script_name=$(basename $0) +ps -ef|grep -v grep|grep -v $$|grep -q "$script_name" +if [ $? -eq 0 ]; then + exit 0 +fi +while [ 1 ]; do + ps -ef|grep python|grep -q 8081 + if [ $? -ne 0 ]; then + python3 -m http.server 8081 + fi + sleep 60 +done \ No newline at end of file diff --git a/tests/parallel_test/container_build.sh b/tests/parallel_test/container_build.sh index 3d3069f05f..85e3d2ab73 100755 --- a/tests/parallel_test/container_build.sh +++ b/tests/parallel_test/container_build.sh @@ -61,14 +61,28 @@ docker run \ -v /root/go/pkg/mod:/root/go/pkg/mod \ -v /root/.cache/go-build:/root/.cache/go-build \ -v /root/.cos-local.1:/root/.cos-local.2 \ - -v ${REP_REAL_PATH}/enterprise/src/plugins/taosx/target:${REP_DIR}/enterprise/src/plugins/taosx/target \ - -v ${REP_REAL_PATH}/community/tools/taosws-rs/target:${REP_DIR}/community/tools/taosws-rs/target \ + -v ${REP_REAL_PATH}/enterprise/contrib/grant-lib:${REP_DIR}/enterprise/contrib/grant-lib \ + -v ${REP_REAL_PATH}/community/tools/taosadapter:${REP_DIR}/community/tools/taosadapter \ + -v ${REP_REAL_PATH}/community/tools/taos-tools:${REP_DIR}/community/tools/taos-tools \ + -v ${REP_REAL_PATH}/community/tools/taosws-rs:${REP_DIR}/community/tools/taosws-rs \ + -v ${REP_REAL_PATH}/community/contrib/apr/:${REP_DIR}/community/contrib/apr \ + -v ${REP_REAL_PATH}/community/contrib/apr-util/:${REP_DIR}/community/contrib/apr-util \ -v ${REP_REAL_PATH}/community/contrib/cJson/:${REP_DIR}/community/contrib/cJson \ - -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \ -v ${REP_REAL_PATH}/community/contrib/cpp-stub/:${REP_DIR}/community/contrib/cpp-stub \ + -v ${REP_REAL_PATH}/community/contrib/curl/:${REP_DIR}/community/contrib/curl \ + -v ${REP_REAL_PATH}/community/contrib/curl2/:${REP_DIR}/community/contrib/curl2 \ + -v ${REP_REAL_PATH}/community/contrib/geos/:${REP_DIR}/community/contrib/geos \ + -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \ + -v ${REP_REAL_PATH}/community/contrib/libs3/:${REP_DIR}/community/contrib/libs3 \ -v ${REP_REAL_PATH}/community/contrib/libuv/:${REP_DIR}/community/contrib/libuv \ -v ${REP_REAL_PATH}/community/contrib/lz4/:${REP_DIR}/community/contrib/lz4 \ + -v ${REP_REAL_PATH}/community/contrib/lzma2/:${REP_DIR}/community/contrib/lzma2 \ + -v ${REP_REAL_PATH}/community/contrib/mxml/:${REP_DIR}/community/contrib/mxml \ + -v ${REP_REAL_PATH}/community/contrib/openssl/:${REP_DIR}/community/contrib/openssl \ + -v ${REP_REAL_PATH}/community/contrib/pcre2/:${REP_DIR}/community/contrib/pcre2 \ + -v ${REP_REAL_PATH}/community/contrib/xml2/:${REP_DIR}/community/contrib/xml2 \ -v ${REP_REAL_PATH}/community/contrib/zlib/:${REP_DIR}/community/contrib/zlib \ + -v ${REP_REAL_PATH}/community/contrib/zstd/:${REP_DIR}/community/contrib/zstd \ --rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=true -DWEBSOCKET=true -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j 10|| exit 1" # -v ${REP_REAL_PATH}/community/contrib/jemalloc/:${REP_DIR}/community/contrib/jemalloc \ @@ -96,15 +110,29 @@ docker run \ -v /root/go/pkg/mod:/root/go/pkg/mod \ -v /root/.cache/go-build:/root/.cache/go-build \ -v /root/.cos-local.1:/root/.cos-local.2 \ - -v ${REP_REAL_PATH}/enterprise/src/plugins/taosx/target:${REP_DIR}/enterprise/src/plugins/taosx/target \ + -v ${REP_REAL_PATH}/enterprise/contrib/grant-lib:${REP_DIR}/enterprise/contrib/grant-lib \ + -v ${REP_REAL_PATH}/community/tools/taosadapter:${REP_DIR}/community/tools/taosadapter \ + -v ${REP_REAL_PATH}/community/tools/taos-tools:${REP_DIR}/community/tools/taos-tools \ + -v ${REP_REAL_PATH}/community/tools/taosws-rs:${REP_DIR}/community/tools/taosws-rs \ -v ${REP_REAL_PATH}/community/tools/taosws-rs/target:${REP_DIR}/community/tools/taosws-rs/target \ + -v ${REP_REAL_PATH}/community/contrib/apr/:${REP_DIR}/community/contrib/apr \ + -v ${REP_REAL_PATH}/community/contrib/apr-util/:${REP_DIR}/community/contrib/apr-util \ -v ${REP_REAL_PATH}/community/contrib/cJson/:${REP_DIR}/community/contrib/cJson \ - -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \ -v ${REP_REAL_PATH}/community/contrib/cpp-stub/:${REP_DIR}/community/contrib/cpp-stub \ + -v ${REP_REAL_PATH}/community/contrib/curl/:${REP_DIR}/community/contrib/curl \ + -v ${REP_REAL_PATH}/community/contrib/curl2/:${REP_DIR}/community/contrib/curl2 \ + -v ${REP_REAL_PATH}/community/contrib/geos/:${REP_DIR}/community/contrib/geos \ + -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \ + -v ${REP_REAL_PATH}/community/contrib/libs3/:${REP_DIR}/community/contrib/libs3 \ -v ${REP_REAL_PATH}/community/contrib/libuv/:${REP_DIR}/community/contrib/libuv \ -v ${REP_REAL_PATH}/community/contrib/lz4/:${REP_DIR}/community/contrib/lz4 \ + -v ${REP_REAL_PATH}/community/contrib/lzma2/:${REP_DIR}/community/contrib/lzma2 \ + -v ${REP_REAL_PATH}/community/contrib/mxml/:${REP_DIR}/community/contrib/mxml \ + -v ${REP_REAL_PATH}/community/contrib/openssl/:${REP_DIR}/community/contrib/openssl \ + -v ${REP_REAL_PATH}/community/contrib/pcre2/:${REP_DIR}/community/contrib/pcre2 \ + -v ${REP_REAL_PATH}/community/contrib/xml2/:${REP_DIR}/community/contrib/xml2 \ -v ${REP_REAL_PATH}/community/contrib/zlib/:${REP_DIR}/community/contrib/zlib \ - -v ${REP_REAL_PATH}/community/contrib/jemalloc/:${REP_DIR}/community/contrib/jemalloc \ + -v ${REP_REAL_PATH}/community/contrib/zstd/:${REP_DIR}/community/contrib/zstd \ --rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=false -DWEBSOCKET=true -DBUILD_SANITIZER=1 -DTOOLS_SANITIZE=true $CMAKE_BUILD_TYPE -DTOOLS_BUILD_TYPE=Debug -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j 10|| exit 1 " mv ${REP_REAL_PATH}/debug ${WORKDIR}/debugSan