From faa18162452a472953daf72d1e94c7cfae668298 Mon Sep 17 00:00:00 2001 From: xiao-77 Date: Fri, 20 Sep 2024 13:09:11 +0800 Subject: [PATCH] remove void at mnode 4 --- source/dnode/mnode/impl/src/mndMnode.c | 1569 ++++++++++++----------- source/dnode/mnode/impl/src/mndVgroup.c | 290 ++++- 2 files changed, 1019 insertions(+), 840 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c index 300eef8cf9..c00c88c4f9 100644 --- a/source/dnode/mnode/impl/src/mndMnode.c +++ b/source/dnode/mnode/impl/src/mndMnode.c @@ -285,851 +285,852 @@ void mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet) { } epsetSort(pEpSet); } +} - static int32_t mndSetCreateMnodeRedoLogs(SMnode * pMnode, STrans * pTrans, SMnodeObj * pObj) { - int32_t code = 0; - SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); - if (pRedoRaw == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - TAOS_RETURN(code); - } - TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw)); - TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING)); +static int32_t mndSetCreateMnodeRedoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + int32_t code = 0; + SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); + if (pRedoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + TAOS_RETURN(code); + } + TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw)); + TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING)); + TAOS_RETURN(code); +} + +int32_t mndSetRestoreCreateMnodeRedoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + int32_t code = 0; + SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); + if (pRedoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + TAOS_RETURN(code); + } + TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw)); + TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY)); + TAOS_RETURN(code); +} + +static int32_t mndSetCreateMnodeUndoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + int32_t code = 0; + SSdbRaw *pUndoRaw = mndMnodeActionEncode(pObj); + if (pUndoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + TAOS_RETURN(code); + } + TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pUndoRaw)); + TAOS_CHECK_RETURN(sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED)); + TAOS_RETURN(code); +} + +int32_t mndSetCreateMnodeCommitLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + int32_t code = 0; + SSdbRaw *pCommitRaw = mndMnodeActionEncode(pObj); + 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); +} + +static int32_t mndBuildCreateMnodeRedoAction(STrans *pTrans, SDCreateMnodeReq *pCreateReq, SEpSet *pCreateEpSet) { + int32_t code = 0; + int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pCreateReq); + void *pReq = taosMemoryMalloc(contLen); + code = tSerializeSDCreateMnodeReq(pReq, contLen, pCreateReq); + if (code < 0) { + taosMemoryFree(pReq); TAOS_RETURN(code); } - int32_t mndSetRestoreCreateMnodeRedoLogs(SMnode * pMnode, STrans * pTrans, SMnodeObj * pObj) { - int32_t code = 0; - SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); - if (pRedoRaw == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - TAOS_RETURN(code); - } - TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw)); - TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY)); + STransAction action = { + .epSet = *pCreateEpSet, + .pCont = pReq, + .contLen = contLen, + .msgType = TDMT_DND_CREATE_MNODE, + .acceptableCode = TSDB_CODE_MNODE_ALREADY_DEPLOYED, + }; + + if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { + taosMemoryFree(pReq); + TAOS_RETURN(code); + } + TAOS_RETURN(code); +} + +static int32_t mndBuildAlterMnodeTypeRedoAction(STrans *pTrans, SDAlterMnodeTypeReq *pAlterMnodeTypeReq, + SEpSet *pAlterMnodeTypeEpSet) { + int32_t code = 0; + int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterMnodeTypeReq); + void *pReq = taosMemoryMalloc(contLen); + code = tSerializeSDCreateMnodeReq(pReq, contLen, pAlterMnodeTypeReq); + if (code < 0) { + taosMemoryFree(pReq); TAOS_RETURN(code); } - static int32_t mndSetCreateMnodeUndoLogs(SMnode * pMnode, STrans * pTrans, SMnodeObj * pObj) { - int32_t code = 0; - SSdbRaw *pUndoRaw = mndMnodeActionEncode(pObj); - if (pUndoRaw == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - TAOS_RETURN(code); - } - TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pUndoRaw)); - TAOS_CHECK_RETURN(sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED)); + STransAction action = { + .epSet = *pAlterMnodeTypeEpSet, + .pCont = pReq, + .contLen = contLen, + .msgType = TDMT_DND_ALTER_MNODE_TYPE, + .retryCode = TSDB_CODE_MNODE_NOT_CATCH_UP, + .acceptableCode = TSDB_CODE_MNODE_ALREADY_IS_VOTER, + }; + + if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { + taosMemoryFree(pReq); + TAOS_RETURN(code); + } + TAOS_RETURN(code); +} + +static int32_t mndBuildAlterMnodeRedoAction(STrans *pTrans, SDCreateMnodeReq *pAlterReq, SEpSet *pAlterEpSet) { + int32_t code = 0; + int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterReq); + void *pReq = taosMemoryMalloc(contLen); + code = tSerializeSDCreateMnodeReq(pReq, contLen, pAlterReq); + if (code < 0) { + taosMemoryFree(pReq); + TAOS_RETURN(code); + } + STransAction action = { + .epSet = *pAlterEpSet, + .pCont = pReq, + .contLen = contLen, + .msgType = TDMT_MND_ALTER_MNODE, + .acceptableCode = 0, + }; + + if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { + taosMemoryFree(pReq); TAOS_RETURN(code); } - int32_t mndSetCreateMnodeCommitLogs(SMnode * pMnode, STrans * pTrans, SMnodeObj * pObj) { - int32_t code = 0; - SSdbRaw *pCommitRaw = mndMnodeActionEncode(pObj); - 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); +} + +static int32_t mndBuildDropMnodeRedoAction(STrans *pTrans, SDDropMnodeReq *pDropReq, SEpSet *pDroprEpSet) { + int32_t code = 0; + int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, pDropReq); + void *pReq = taosMemoryMalloc(contLen); + code = tSerializeSCreateDropMQSNodeReq(pReq, contLen, pDropReq); + if (code < 0) { + taosMemoryFree(pReq); TAOS_RETURN(code); } - static int32_t mndBuildCreateMnodeRedoAction(STrans * pTrans, SDCreateMnodeReq * pCreateReq, SEpSet * pCreateEpSet) { - int32_t code = 0; - int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pCreateReq); - void *pReq = taosMemoryMalloc(contLen); - code = tSerializeSDCreateMnodeReq(pReq, contLen, pCreateReq); - if (code < 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } + STransAction action = { + .epSet = *pDroprEpSet, + .pCont = pReq, + .contLen = contLen, + .msgType = TDMT_DND_DROP_MNODE, + .acceptableCode = TSDB_CODE_MNODE_NOT_DEPLOYED, + }; - STransAction action = { - .epSet = *pCreateEpSet, - .pCont = pReq, - .contLen = contLen, - .msgType = TDMT_DND_CREATE_MNODE, - .acceptableCode = TSDB_CODE_MNODE_ALREADY_DEPLOYED, - }; - - if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } + if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { + taosMemoryFree(pReq); TAOS_RETURN(code); } - - static int32_t mndBuildAlterMnodeTypeRedoAction(STrans * pTrans, SDAlterMnodeTypeReq * pAlterMnodeTypeReq, - SEpSet * pAlterMnodeTypeEpSet) { - int32_t code = 0; - int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterMnodeTypeReq); - void *pReq = taosMemoryMalloc(contLen); - code = tSerializeSDCreateMnodeReq(pReq, contLen, pAlterMnodeTypeReq); - if (code < 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } - - STransAction action = { - .epSet = *pAlterMnodeTypeEpSet, - .pCont = pReq, - .contLen = contLen, - .msgType = TDMT_DND_ALTER_MNODE_TYPE, - .retryCode = TSDB_CODE_MNODE_NOT_CATCH_UP, - .acceptableCode = TSDB_CODE_MNODE_ALREADY_IS_VOTER, - }; - - if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } - TAOS_RETURN(code); - } - - static int32_t mndBuildAlterMnodeRedoAction(STrans * pTrans, SDCreateMnodeReq * pAlterReq, SEpSet * pAlterEpSet) { - int32_t code = 0; - int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterReq); - void *pReq = taosMemoryMalloc(contLen); - code = tSerializeSDCreateMnodeReq(pReq, contLen, pAlterReq); - if (code < 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } - STransAction action = { - .epSet = *pAlterEpSet, - .pCont = pReq, - .contLen = contLen, - .msgType = TDMT_MND_ALTER_MNODE, - .acceptableCode = 0, - }; - - if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } - - TAOS_RETURN(code); - } - - static int32_t mndBuildDropMnodeRedoAction(STrans * pTrans, SDDropMnodeReq * pDropReq, SEpSet * pDroprEpSet) { - int32_t code = 0; - int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, pDropReq); - void *pReq = taosMemoryMalloc(contLen); - code = tSerializeSCreateDropMQSNodeReq(pReq, contLen, pDropReq); - if (code < 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } - - STransAction action = { - .epSet = *pDroprEpSet, - .pCont = pReq, - .contLen = contLen, - .msgType = TDMT_DND_DROP_MNODE, - .acceptableCode = TSDB_CODE_MNODE_NOT_DEPLOYED, - }; - - if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) { - taosMemoryFree(pReq); - TAOS_RETURN(code); - } - TAOS_RETURN(code); - } - - static int32_t mndSetCreateMnodeRedoActions(SMnode * pMnode, STrans * pTrans, SDnodeObj * pDnode, SMnodeObj * pObj) { - SSdb *pSdb = pMnode->pSdb; - void *pIter = NULL; - int32_t numOfReplicas = 0; - int32_t numOfLearnerReplicas = 0; - SDCreateMnodeReq createReq = {0}; - SEpSet createEpset = {0}; - - while (1) { - SMnodeObj *pMObj = NULL; - pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); - if (pIter == NULL) break; - - if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { - createReq.replicas[numOfReplicas].id = pMObj->id; - createReq.replicas[numOfReplicas].port = pMObj->pDnode->port; - memcpy(createReq.replicas[numOfReplicas].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - numOfReplicas++; - } else { - createReq.learnerReplicas[numOfLearnerReplicas].id = pMObj->id; - createReq.learnerReplicas[numOfLearnerReplicas].port = pMObj->pDnode->port; - memcpy(createReq.learnerReplicas[numOfLearnerReplicas].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - numOfLearnerReplicas++; - } - - sdbRelease(pSdb, pMObj); - } - - createReq.replica = numOfReplicas; - createReq.learnerReplica = numOfLearnerReplicas + 1; - createReq.learnerReplicas[numOfLearnerReplicas].id = pDnode->id; - createReq.learnerReplicas[numOfLearnerReplicas].port = pDnode->port; - memcpy(createReq.learnerReplicas[numOfLearnerReplicas].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - - createReq.lastIndex = pObj->lastIndex; - - createEpset.inUse = 0; - createEpset.numOfEps = 1; - createEpset.eps[0].port = pDnode->port; - memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - - TAOS_CHECK_RETURN(mndBuildCreateMnodeRedoAction(pTrans, &createReq, &createEpset)); - - TAOS_RETURN(0); - } - - int32_t mndSetRestoreCreateMnodeRedoActions(SMnode * pMnode, STrans * pTrans, SDnodeObj * pDnode, SMnodeObj * pObj) { - SSdb *pSdb = pMnode->pSdb; - void *pIter = NULL; - SDCreateMnodeReq createReq = {0}; - SEpSet createEpset = {0}; - - while (1) { - SMnodeObj *pMObj = NULL; - pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); - if (pIter == NULL) break; - - if (pMObj->id == pDnode->id) { - sdbRelease(pSdb, pMObj); - continue; - } - - if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { - createReq.replicas[createReq.replica].id = pMObj->id; - createReq.replicas[createReq.replica].port = pMObj->pDnode->port; - memcpy(createReq.replicas[createReq.replica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - createReq.replica++; - } else { - createReq.learnerReplicas[createReq.learnerReplica].id = pMObj->id; - createReq.learnerReplicas[createReq.learnerReplica].port = pMObj->pDnode->port; - memcpy(createReq.learnerReplicas[createReq.learnerReplica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - createReq.learnerReplica++; - } - - sdbRelease(pSdb, pMObj); - } - - createReq.learnerReplicas[createReq.learnerReplica].id = pDnode->id; - createReq.learnerReplicas[createReq.learnerReplica].port = pDnode->port; - memcpy(createReq.learnerReplicas[createReq.learnerReplica].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - createReq.learnerReplica++; - - createReq.lastIndex = pObj->lastIndex; - - createEpset.inUse = 0; - createEpset.numOfEps = 1; - createEpset.eps[0].port = pDnode->port; - memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - - TAOS_CHECK_RETURN(mndBuildCreateMnodeRedoAction(pTrans, &createReq, &createEpset)); - - TAOS_RETURN(0); - } - - static int32_t mndSetAlterMnodeTypeRedoActions(SMnode * pMnode, STrans * pTrans, SDnodeObj * pDnode, - SMnodeObj * pObj) { - SSdb *pSdb = pMnode->pSdb; - void *pIter = NULL; - SDAlterMnodeTypeReq alterReq = {0}; - SEpSet createEpset = {0}; - - while (1) { - SMnodeObj *pMObj = NULL; - pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); - if (pIter == NULL) break; - - if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { - alterReq.replicas[alterReq.replica].id = pMObj->id; - alterReq.replicas[alterReq.replica].port = pMObj->pDnode->port; - memcpy(alterReq.replicas[alterReq.replica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - alterReq.replica++; - } else { - alterReq.learnerReplicas[alterReq.learnerReplica].id = pMObj->id; - alterReq.learnerReplicas[alterReq.learnerReplica].port = pMObj->pDnode->port; - memcpy(alterReq.learnerReplicas[alterReq.learnerReplica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - alterReq.learnerReplica++; - } - - sdbRelease(pSdb, pMObj); - } - - alterReq.replicas[alterReq.replica].id = pDnode->id; - alterReq.replicas[alterReq.replica].port = pDnode->port; - memcpy(alterReq.replicas[alterReq.replica].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - alterReq.replica++; - - alterReq.lastIndex = pObj->lastIndex; - - createEpset.inUse = 0; - createEpset.numOfEps = 1; - createEpset.eps[0].port = pDnode->port; - memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - - TAOS_CHECK_RETURN(mndBuildAlterMnodeTypeRedoAction(pTrans, &alterReq, &createEpset)); - - TAOS_RETURN(0); - } - - int32_t mndSetRestoreAlterMnodeTypeRedoActions(SMnode * pMnode, STrans * pTrans, SDnodeObj * pDnode, - SMnodeObj * pObj) { - SSdb *pSdb = pMnode->pSdb; - void *pIter = NULL; - SDAlterMnodeTypeReq alterReq = {0}; - SEpSet createEpset = {0}; - - while (1) { - SMnodeObj *pMObj = NULL; - pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); - if (pIter == NULL) break; - - if (pMObj->id == pDnode->id) { - sdbRelease(pSdb, pMObj); - continue; - } - - if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { - alterReq.replicas[alterReq.replica].id = pMObj->id; - alterReq.replicas[alterReq.replica].port = pMObj->pDnode->port; - memcpy(alterReq.replicas[alterReq.replica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - alterReq.replica++; - } else { - alterReq.learnerReplicas[alterReq.learnerReplica].id = pMObj->id; - alterReq.learnerReplicas[alterReq.learnerReplica].port = pMObj->pDnode->port; - memcpy(alterReq.learnerReplicas[alterReq.learnerReplica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); - alterReq.learnerReplica++; - } - - sdbRelease(pSdb, pMObj); - } - - alterReq.replicas[alterReq.replica].id = pDnode->id; - alterReq.replicas[alterReq.replica].port = pDnode->port; - memcpy(alterReq.replicas[alterReq.replica].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - alterReq.replica++; - - alterReq.lastIndex = pObj->lastIndex; - - createEpset.inUse = 0; - createEpset.numOfEps = 1; - createEpset.eps[0].port = pDnode->port; - memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - - TAOS_CHECK_RETURN(mndBuildAlterMnodeTypeRedoAction(pTrans, &alterReq, &createEpset)); - - TAOS_RETURN(0); - } - - static int32_t mndCreateMnode(SMnode * pMnode, SRpcMsg * pReq, SDnodeObj * pDnode, SMCreateMnodeReq * pCreate) { - int32_t code = -1; - - STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "create-mnode"); - if (pTrans == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto _OVER; - } - mndTransSetSerial(pTrans); - mInfo("trans:%d, used to create mnode:%d", pTrans->id, pCreate->dnodeId); - TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER); - - SMnodeObj mnodeObj = {0}; - mnodeObj.id = pDnode->id; - mnodeObj.createdTime = taosGetTimestampMs(); - mnodeObj.updateTime = mnodeObj.createdTime; - mnodeObj.role = TAOS_SYNC_ROLE_LEARNER; - mnodeObj.lastIndex = pMnode->applied; - - TAOS_CHECK_GOTO(mndSetCreateMnodeRedoActions(pMnode, pTrans, pDnode, &mnodeObj), NULL, _OVER); - TAOS_CHECK_GOTO(mndSetCreateMnodeRedoLogs(pMnode, pTrans, &mnodeObj), NULL, _OVER); - - SMnodeObj mnodeLeaderObj = {0}; - mnodeLeaderObj.id = pDnode->id; - mnodeLeaderObj.createdTime = taosGetTimestampMs(); - mnodeLeaderObj.updateTime = mnodeLeaderObj.createdTime; - mnodeLeaderObj.role = TAOS_SYNC_ROLE_VOTER; - mnodeLeaderObj.lastIndex = pMnode->applied + 1; - - TAOS_CHECK_GOTO(mndSetAlterMnodeTypeRedoActions(pMnode, pTrans, pDnode, &mnodeLeaderObj), NULL, _OVER); - TAOS_CHECK_GOTO(mndSetCreateMnodeCommitLogs(pMnode, pTrans, &mnodeLeaderObj), NULL, _OVER); - TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); - - code = 0; - - _OVER: - mndTransDrop(pTrans); - TAOS_RETURN(code); - } - - static int32_t mndProcessCreateMnodeReq(SRpcMsg * pReq) { - SMnode *pMnode = pReq->info.node; - int32_t code = -1; - SMnodeObj *pObj = NULL; - SDnodeObj *pDnode = NULL; - SMCreateMnodeReq createReq = {0}; - - TAOS_CHECK_GOTO(tDeserializeSCreateDropMQSNodeReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER); - - mInfo("mnode:%d, start to create", createReq.dnodeId); - TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_MNODE), NULL, _OVER); - - pObj = mndAcquireMnode(pMnode, createReq.dnodeId); - if (pObj != NULL) { - code = TSDB_CODE_MND_MNODE_ALREADY_EXIST; - goto _OVER; - } else if (terrno != TSDB_CODE_MND_MNODE_NOT_EXIST) { - goto _OVER; - } - - pDnode = mndAcquireDnode(pMnode, createReq.dnodeId); - if (pDnode == NULL) { - code = TSDB_CODE_MND_DNODE_NOT_EXIST; - goto _OVER; - } - - if (sdbGetSize(pMnode->pSdb, SDB_MNODE) >= 3) { - code = TSDB_CODE_MND_TOO_MANY_MNODES; - goto _OVER; - } - - if (!mndIsDnodeOnline(pDnode, taosGetTimestampMs())) { - code = TSDB_CODE_DNODE_OFFLINE; - goto _OVER; - } - - code = mndCreateMnode(pMnode, pReq, pDnode, &createReq); - if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; - - char obj[40] = {0}; - sprintf(obj, "%d", createReq.dnodeId); - - auditRecord(pReq, pMnode->clusterId, "createMnode", "", obj, createReq.sql, createReq.sqlLen); - - _OVER: - if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("mnode:%d, failed to create since %s", createReq.dnodeId, terrstr()); - } - - mndReleaseMnode(pMnode, pObj); - mndReleaseDnode(pMnode, pDnode); - tFreeSMCreateQnodeReq(&createReq); - - TAOS_RETURN(code); - } - - static int32_t mndSetDropMnodeRedoLogs(SMnode * pMnode, STrans * pTrans, SMnodeObj * pObj) { - int32_t code = 0; - SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); - if (pRedoRaw == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - TAOS_RETURN(code); - } - TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw)); - TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING)); - TAOS_RETURN(code); - } - - static int32_t mndSetDropMnodeCommitLogs(SMnode * pMnode, STrans * pTrans, SMnodeObj * pObj) { - int32_t code = 0; - SSdbRaw *pCommitRaw = mndMnodeActionEncode(pObj); - 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_DROPPED)); - TAOS_RETURN(code); - } - - static int32_t mndSetDropMnodeRedoActions(SMnode * pMnode, STrans * pTrans, SDnodeObj * pDnode, SMnodeObj * pObj, - bool force) { - int32_t code = 0; - SSdb *pSdb = pMnode->pSdb; - void *pIter = NULL; - SDDropMnodeReq dropReq = {0}; - SEpSet dropEpSet = {0}; - - dropReq.dnodeId = pDnode->id; - dropEpSet.numOfEps = 1; - dropEpSet.eps[0].port = pDnode->port; - memcpy(dropEpSet.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - - int32_t totalMnodes = sdbGetSize(pSdb, SDB_MNODE); - if (totalMnodes == 2) { - if (force) { - mError("cant't force drop dnode, since a mnode on it and replica is 2"); - code = TSDB_CODE_MNODE_ONLY_TWO_MNODE; - TAOS_RETURN(code); - } - mInfo("vgId:1, has %d mnodes, exec redo log first", totalMnodes); - TAOS_CHECK_RETURN(mndSetDropMnodeRedoLogs(pMnode, pTrans, pObj)); - if (!force) { - TAOS_CHECK_RETURN(mndBuildDropMnodeRedoAction(pTrans, &dropReq, &dropEpSet)); - } - } else if (totalMnodes == 3) { - mInfo("vgId:1, has %d mnodes, exec redo action first", totalMnodes); - if (!force) { - TAOS_CHECK_RETURN(mndBuildDropMnodeRedoAction(pTrans, &dropReq, &dropEpSet)); - } - TAOS_CHECK_RETURN(mndSetDropMnodeRedoLogs(pMnode, pTrans, pObj)); + TAOS_RETURN(code); +} + +static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnodeObj *pDnode, SMnodeObj *pObj) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + int32_t numOfReplicas = 0; + int32_t numOfLearnerReplicas = 0; + SDCreateMnodeReq createReq = {0}; + SEpSet createEpset = {0}; + + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + + if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { + createReq.replicas[numOfReplicas].id = pMObj->id; + createReq.replicas[numOfReplicas].port = pMObj->pDnode->port; + memcpy(createReq.replicas[numOfReplicas].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + numOfReplicas++; } else { - TAOS_RETURN(-1); + createReq.learnerReplicas[numOfLearnerReplicas].id = pMObj->id; + createReq.learnerReplicas[numOfLearnerReplicas].port = pMObj->pDnode->port; + memcpy(createReq.learnerReplicas[numOfLearnerReplicas].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + numOfLearnerReplicas++; } + sdbRelease(pSdb, pMObj); + } + + createReq.replica = numOfReplicas; + createReq.learnerReplica = numOfLearnerReplicas + 1; + createReq.learnerReplicas[numOfLearnerReplicas].id = pDnode->id; + createReq.learnerReplicas[numOfLearnerReplicas].port = pDnode->port; + memcpy(createReq.learnerReplicas[numOfLearnerReplicas].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + + createReq.lastIndex = pObj->lastIndex; + + createEpset.inUse = 0; + createEpset.numOfEps = 1; + createEpset.eps[0].port = pDnode->port; + memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + + TAOS_CHECK_RETURN(mndBuildCreateMnodeRedoAction(pTrans, &createReq, &createEpset)); + + TAOS_RETURN(0); +} + +int32_t mndSetRestoreCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnodeObj *pDnode, SMnodeObj *pObj) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + SDCreateMnodeReq createReq = {0}; + SEpSet createEpset = {0}; + + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + + if (pMObj->id == pDnode->id) { + sdbRelease(pSdb, pMObj); + continue; + } + + if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { + createReq.replicas[createReq.replica].id = pMObj->id; + createReq.replicas[createReq.replica].port = pMObj->pDnode->port; + memcpy(createReq.replicas[createReq.replica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + createReq.replica++; + } else { + createReq.learnerReplicas[createReq.learnerReplica].id = pMObj->id; + createReq.learnerReplicas[createReq.learnerReplica].port = pMObj->pDnode->port; + memcpy(createReq.learnerReplicas[createReq.learnerReplica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + createReq.learnerReplica++; + } + + sdbRelease(pSdb, pMObj); + } + + createReq.learnerReplicas[createReq.learnerReplica].id = pDnode->id; + createReq.learnerReplicas[createReq.learnerReplica].port = pDnode->port; + memcpy(createReq.learnerReplicas[createReq.learnerReplica].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + createReq.learnerReplica++; + + createReq.lastIndex = pObj->lastIndex; + + createEpset.inUse = 0; + createEpset.numOfEps = 1; + createEpset.eps[0].port = pDnode->port; + memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + + TAOS_CHECK_RETURN(mndBuildCreateMnodeRedoAction(pTrans, &createReq, &createEpset)); + + TAOS_RETURN(0); +} + +static int32_t mndSetAlterMnodeTypeRedoActions(SMnode *pMnode, STrans *pTrans, SDnodeObj *pDnode, SMnodeObj *pObj) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + SDAlterMnodeTypeReq alterReq = {0}; + SEpSet createEpset = {0}; + + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + + if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { + alterReq.replicas[alterReq.replica].id = pMObj->id; + alterReq.replicas[alterReq.replica].port = pMObj->pDnode->port; + memcpy(alterReq.replicas[alterReq.replica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + alterReq.replica++; + } else { + alterReq.learnerReplicas[alterReq.learnerReplica].id = pMObj->id; + alterReq.learnerReplicas[alterReq.learnerReplica].port = pMObj->pDnode->port; + memcpy(alterReq.learnerReplicas[alterReq.learnerReplica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + alterReq.learnerReplica++; + } + + sdbRelease(pSdb, pMObj); + } + + alterReq.replicas[alterReq.replica].id = pDnode->id; + alterReq.replicas[alterReq.replica].port = pDnode->port; + memcpy(alterReq.replicas[alterReq.replica].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + alterReq.replica++; + + alterReq.lastIndex = pObj->lastIndex; + + createEpset.inUse = 0; + createEpset.numOfEps = 1; + createEpset.eps[0].port = pDnode->port; + memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + + TAOS_CHECK_RETURN(mndBuildAlterMnodeTypeRedoAction(pTrans, &alterReq, &createEpset)); + + TAOS_RETURN(0); +} + +int32_t mndSetRestoreAlterMnodeTypeRedoActions(SMnode *pMnode, STrans *pTrans, SDnodeObj *pDnode, SMnodeObj *pObj) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + SDAlterMnodeTypeReq alterReq = {0}; + SEpSet createEpset = {0}; + + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + + if (pMObj->id == pDnode->id) { + sdbRelease(pSdb, pMObj); + continue; + } + + if (pMObj->role == TAOS_SYNC_ROLE_VOTER) { + alterReq.replicas[alterReq.replica].id = pMObj->id; + alterReq.replicas[alterReq.replica].port = pMObj->pDnode->port; + memcpy(alterReq.replicas[alterReq.replica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + alterReq.replica++; + } else { + alterReq.learnerReplicas[alterReq.learnerReplica].id = pMObj->id; + alterReq.learnerReplicas[alterReq.learnerReplica].port = pMObj->pDnode->port; + memcpy(alterReq.learnerReplicas[alterReq.learnerReplica].fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + alterReq.learnerReplica++; + } + + sdbRelease(pSdb, pMObj); + } + + alterReq.replicas[alterReq.replica].id = pDnode->id; + alterReq.replicas[alterReq.replica].port = pDnode->port; + memcpy(alterReq.replicas[alterReq.replica].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + alterReq.replica++; + + alterReq.lastIndex = pObj->lastIndex; + + createEpset.inUse = 0; + createEpset.numOfEps = 1; + createEpset.eps[0].port = pDnode->port; + memcpy(createEpset.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + + TAOS_CHECK_RETURN(mndBuildAlterMnodeTypeRedoAction(pTrans, &alterReq, &createEpset)); + + TAOS_RETURN(0); +} + +static int32_t mndCreateMnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMCreateMnodeReq *pCreate) { + int32_t code = -1; + + STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "create-mnode"); + if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + mndTransSetSerial(pTrans); + mInfo("trans:%d, used to create mnode:%d", pTrans->id, pCreate->dnodeId); + TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER); + + SMnodeObj mnodeObj = {0}; + mnodeObj.id = pDnode->id; + mnodeObj.createdTime = taosGetTimestampMs(); + mnodeObj.updateTime = mnodeObj.createdTime; + mnodeObj.role = TAOS_SYNC_ROLE_LEARNER; + mnodeObj.lastIndex = pMnode->applied; + + TAOS_CHECK_GOTO(mndSetCreateMnodeRedoActions(pMnode, pTrans, pDnode, &mnodeObj), NULL, _OVER); + TAOS_CHECK_GOTO(mndSetCreateMnodeRedoLogs(pMnode, pTrans, &mnodeObj), NULL, _OVER); + + SMnodeObj mnodeLeaderObj = {0}; + mnodeLeaderObj.id = pDnode->id; + mnodeLeaderObj.createdTime = taosGetTimestampMs(); + mnodeLeaderObj.updateTime = mnodeLeaderObj.createdTime; + mnodeLeaderObj.role = TAOS_SYNC_ROLE_VOTER; + mnodeLeaderObj.lastIndex = pMnode->applied + 1; + + TAOS_CHECK_GOTO(mndSetAlterMnodeTypeRedoActions(pMnode, pTrans, pDnode, &mnodeLeaderObj), NULL, _OVER); + TAOS_CHECK_GOTO(mndSetCreateMnodeCommitLogs(pMnode, pTrans, &mnodeLeaderObj), NULL, _OVER); + TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); + + code = 0; + +_OVER: + mndTransDrop(pTrans); + TAOS_RETURN(code); +} + +static int32_t mndProcessCreateMnodeReq(SRpcMsg *pReq) { + SMnode *pMnode = pReq->info.node; + int32_t code = -1; + SMnodeObj *pObj = NULL; + SDnodeObj *pDnode = NULL; + SMCreateMnodeReq createReq = {0}; + + TAOS_CHECK_GOTO(tDeserializeSCreateDropMQSNodeReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER); + + mInfo("mnode:%d, start to create", createReq.dnodeId); + TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_MNODE), NULL, _OVER); + + pObj = mndAcquireMnode(pMnode, createReq.dnodeId); + if (pObj != NULL) { + code = TSDB_CODE_MND_MNODE_ALREADY_EXIST; + goto _OVER; + } else if (terrno != TSDB_CODE_MND_MNODE_NOT_EXIST) { + goto _OVER; + } + + pDnode = mndAcquireDnode(pMnode, createReq.dnodeId); + if (pDnode == NULL) { + code = TSDB_CODE_MND_DNODE_NOT_EXIST; + goto _OVER; + } + + if (sdbGetSize(pMnode->pSdb, SDB_MNODE) >= 3) { + code = TSDB_CODE_MND_TOO_MANY_MNODES; + goto _OVER; + } + + if (!mndIsDnodeOnline(pDnode, taosGetTimestampMs())) { + code = TSDB_CODE_DNODE_OFFLINE; + goto _OVER; + } + + code = mndCreateMnode(pMnode, pReq, pDnode, &createReq); + if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; + + char obj[40] = {0}; + sprintf(obj, "%d", createReq.dnodeId); + + auditRecord(pReq, pMnode->clusterId, "createMnode", "", obj, createReq.sql, createReq.sqlLen); + +_OVER: + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { + mError("mnode:%d, failed to create since %s", createReq.dnodeId, terrstr()); + } + + mndReleaseMnode(pMnode, pObj); + mndReleaseDnode(pMnode, pDnode); + tFreeSMCreateQnodeReq(&createReq); + + TAOS_RETURN(code); +} + +static int32_t mndSetDropMnodeRedoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + int32_t code = 0; + SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); + if (pRedoRaw == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; TAOS_RETURN(code); } + TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw)); + TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING)); + TAOS_RETURN(code); +} - int32_t mndSetDropMnodeInfoToTrans(SMnode * pMnode, STrans * pTrans, SMnodeObj * pObj, bool force) { - if (pObj == NULL) return 0; - pObj->lastIndex = pMnode->applied; - TAOS_CHECK_RETURN(mndSetDropMnodeRedoActions(pMnode, pTrans, pObj->pDnode, pObj, force)); - TAOS_CHECK_RETURN(mndSetDropMnodeCommitLogs(pMnode, pTrans, pObj)); - return 0; - } - - static int32_t mndDropMnode(SMnode * pMnode, SRpcMsg * pReq, SMnodeObj * pObj) { - int32_t code = -1; - STrans *pTrans = NULL; - - pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "drop-mnode"); - 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 mnode:%d", pTrans->id, pObj->id); - TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER); - - TAOS_CHECK_GOTO(mndSetDropMnodeInfoToTrans(pMnode, pTrans, pObj, false), NULL, _OVER); - TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); - - code = 0; - - _OVER: - mndTransDrop(pTrans); +static int32_t mndSetDropMnodeCommitLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + int32_t code = 0; + SSdbRaw *pCommitRaw = mndMnodeActionEncode(pObj); + 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_DROPPED)); + TAOS_RETURN(code); +} - static int32_t mndProcessDropMnodeReq(SRpcMsg * pReq) { - SMnode *pMnode = pReq->info.node; - int32_t code = -1; - SMnodeObj *pObj = NULL; - SMDropMnodeReq dropReq = {0}; +static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnodeObj *pDnode, SMnodeObj *pObj, + bool force) { + int32_t code = 0; + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + SDDropMnodeReq dropReq = {0}; + SEpSet dropEpSet = {0}; - TAOS_CHECK_GOTO(tDeserializeSCreateDropMQSNodeReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER); + dropReq.dnodeId = pDnode->id; + dropEpSet.numOfEps = 1; + dropEpSet.eps[0].port = pDnode->port; + memcpy(dropEpSet.eps[0].fqdn, pDnode->fqdn, TSDB_FQDN_LEN); - mInfo("mnode:%d, start to drop", dropReq.dnodeId); - TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_MNODE), NULL, _OVER); - - if (dropReq.dnodeId <= 0) { - code = TSDB_CODE_INVALID_MSG; - goto _OVER; + int32_t totalMnodes = sdbGetSize(pSdb, SDB_MNODE); + if (totalMnodes == 2) { + if (force) { + mError("cant't force drop dnode, since a mnode on it and replica is 2"); + code = TSDB_CODE_MNODE_ONLY_TWO_MNODE; + TAOS_RETURN(code); } - - pObj = mndAcquireMnode(pMnode, dropReq.dnodeId); - if (pObj == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto _OVER; + mInfo("vgId:1, has %d mnodes, exec redo log first", totalMnodes); + TAOS_CHECK_RETURN(mndSetDropMnodeRedoLogs(pMnode, pTrans, pObj)); + if (!force) { + TAOS_CHECK_RETURN(mndBuildDropMnodeRedoAction(pTrans, &dropReq, &dropEpSet)); } - - if (pMnode->selfDnodeId == dropReq.dnodeId) { - code = TSDB_CODE_MND_CANT_DROP_LEADER; - goto _OVER; + } else if (totalMnodes == 3) { + mInfo("vgId:1, has %d mnodes, exec redo action first", totalMnodes); + if (!force) { + TAOS_CHECK_RETURN(mndBuildDropMnodeRedoAction(pTrans, &dropReq, &dropEpSet)); } - - if (sdbGetSize(pMnode->pSdb, SDB_MNODE) <= 1) { - code = TSDB_CODE_MND_TOO_FEW_MNODES; - goto _OVER; - } - - if (!mndIsDnodeOnline(pObj->pDnode, taosGetTimestampMs())) { - code = TSDB_CODE_DNODE_OFFLINE; - goto _OVER; - } - - code = mndDropMnode(pMnode, pReq, pObj); - if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; - - char obj[40] = {0}; - sprintf(obj, "%d", dropReq.dnodeId); - - auditRecord(pReq, pMnode->clusterId, "dropMnode", "", obj, dropReq.sql, dropReq.sqlLen); - - _OVER: - if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("mnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr()); - } - - mndReleaseMnode(pMnode, pObj); - tFreeSMCreateQnodeReq(&dropReq); - TAOS_RETURN(code); + TAOS_CHECK_RETURN(mndSetDropMnodeRedoLogs(pMnode, pTrans, pObj)); + } else { + TAOS_RETURN(-1); } - static int32_t mndRetrieveMnodes(SRpcMsg * pReq, SShowObj * pShow, SSDataBlock * pBlock, int32_t rows) { - SMnode *pMnode = pReq->info.node; - SSdb *pSdb = pMnode->pSdb; - int32_t numOfRows = 0; - int32_t cols = 0; - SMnodeObj *pObj = NULL; - SMnodeObj *pSelfObj = NULL; - ESdbStatus objStatus = 0; - char *pWrite; - int64_t curMs = taosGetTimestampMs(); + TAOS_RETURN(code); +} - pSelfObj = sdbAcquire(pSdb, SDB_MNODE, &pMnode->selfDnodeId); - if (pSelfObj == NULL) { - mError("mnode:%d, failed to acquire self %s", pMnode->selfDnodeId, terrstr()); +int32_t mndSetDropMnodeInfoToTrans(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj, bool force) { + if (pObj == NULL) return 0; + pObj->lastIndex = pMnode->applied; + TAOS_CHECK_RETURN(mndSetDropMnodeRedoActions(pMnode, pTrans, pObj->pDnode, pObj, force)); + TAOS_CHECK_RETURN(mndSetDropMnodeCommitLogs(pMnode, pTrans, pObj)); + return 0; +} + +static int32_t mndDropMnode(SMnode *pMnode, SRpcMsg *pReq, SMnodeObj *pObj) { + int32_t code = -1; + STrans *pTrans = NULL; + + pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "drop-mnode"); + 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 mnode:%d", pTrans->id, pObj->id); + TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER); + + TAOS_CHECK_GOTO(mndSetDropMnodeInfoToTrans(pMnode, pTrans, pObj, false), NULL, _OVER); + TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); + + code = 0; + +_OVER: + mndTransDrop(pTrans); + TAOS_RETURN(code); +} + +static int32_t mndProcessDropMnodeReq(SRpcMsg *pReq) { + SMnode *pMnode = pReq->info.node; + int32_t code = -1; + SMnodeObj *pObj = NULL; + SMDropMnodeReq dropReq = {0}; + + TAOS_CHECK_GOTO(tDeserializeSCreateDropMQSNodeReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER); + + mInfo("mnode:%d, start to drop", dropReq.dnodeId); + TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_MNODE), NULL, _OVER); + + if (dropReq.dnodeId <= 0) { + code = TSDB_CODE_INVALID_MSG; + goto _OVER; + } + + pObj = mndAcquireMnode(pMnode, dropReq.dnodeId); + if (pObj == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + goto _OVER; + } + + if (pMnode->selfDnodeId == dropReq.dnodeId) { + code = TSDB_CODE_MND_CANT_DROP_LEADER; + goto _OVER; + } + + if (sdbGetSize(pMnode->pSdb, SDB_MNODE) <= 1) { + code = TSDB_CODE_MND_TOO_FEW_MNODES; + goto _OVER; + } + + if (!mndIsDnodeOnline(pObj->pDnode, taosGetTimestampMs())) { + code = TSDB_CODE_DNODE_OFFLINE; + goto _OVER; + } + + code = mndDropMnode(pMnode, pReq, pObj); + if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; + + char obj[40] = {0}; + sprintf(obj, "%d", dropReq.dnodeId); + + auditRecord(pReq, pMnode->clusterId, "dropMnode", "", obj, dropReq.sql, dropReq.sqlLen); + +_OVER: + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { + mError("mnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr()); + } + + mndReleaseMnode(pMnode, pObj); + tFreeSMCreateQnodeReq(&dropReq); + TAOS_RETURN(code); +} + +static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { + SMnode *pMnode = pReq->info.node; + SSdb *pSdb = pMnode->pSdb; + int32_t numOfRows = 0; + int32_t cols = 0; + SMnodeObj *pObj = NULL; + SMnodeObj *pSelfObj = NULL; + ESdbStatus objStatus = 0; + char *pWrite; + int64_t curMs = taosGetTimestampMs(); + int code = 0; + + pSelfObj = sdbAcquire(pSdb, SDB_MNODE, &pMnode->selfDnodeId); + if (pSelfObj == NULL) { + mError("mnode:%d, failed to acquire self %s", pMnode->selfDnodeId, terrstr()); + goto _out; + } + + while (numOfRows < rows) { + pShow->pIter = sdbFetchAll(pSdb, SDB_MNODE, pShow->pIter, (void **)&pObj, &objStatus, true); + if (pShow->pIter == NULL) break; + + cols = 0; + SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); + if (code != 0) { + mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); goto _out; } - while (numOfRows < rows) { - pShow->pIter = sdbFetchAll(pSdb, SDB_MNODE, pShow->pIter, (void **)&pObj, &objStatus, true); - if (pShow->pIter == NULL) break; + char b1[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; + STR_WITH_MAXSIZE_TO_VARSTR(b1, pObj->pDnode->ep, TSDB_EP_LEN + VARSTR_HEADER_SIZE); - cols = 0; - SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - code = colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); - if (code != 0) { - mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); - goto _out; - } - - char b1[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; - STR_WITH_MAXSIZE_TO_VARSTR(b1, pObj->pDnode->ep, TSDB_EP_LEN + VARSTR_HEADER_SIZE); - - pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - code = colDataSetVal(pColInfo, numOfRows, b1, false); - if (code != 0) { - mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); - goto _out; - } - - char role[20] = "offline"; - if (pObj->id == pMnode->selfDnodeId) { - snprintf(role, sizeof(role), "%s%s", syncStr(TAOS_SYNC_STATE_LEADER), pMnode->restored ? "" : "*"); - } - bool isDnodeOnline = mndIsDnodeOnline(pObj->pDnode, curMs); - if (isDnodeOnline) { - tstrncpy(role, syncStr(pObj->syncState), sizeof(role)); - if (pObj->syncState == TAOS_SYNC_STATE_LEADER && pObj->id != pMnode->selfDnodeId) { - tstrncpy(role, syncStr(TAOS_SYNC_STATE_ERROR), sizeof(role)); - mError("mnode:%d, is leader too", pObj->id); - } - } - char b2[12 + VARSTR_HEADER_SIZE] = {0}; - STR_WITH_MAXSIZE_TO_VARSTR(b2, role, pShow->pMeta->pSchemas[cols].bytes); - pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - code = colDataSetVal(pColInfo, numOfRows, (const char *)b2, false); - if (code != 0) { - mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); - goto _out; - } - const char *status = "ready"; - if (objStatus == SDB_STATUS_CREATING) status = "creating"; - if (objStatus == SDB_STATUS_DROPPING) status = "dropping"; - if (!isDnodeOnline) status = "offline"; - char b3[9 + VARSTR_HEADER_SIZE] = {0}; - STR_WITH_MAXSIZE_TO_VARSTR(b3, status, pShow->pMeta->pSchemas[cols].bytes); - pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - code = colDataSetVal(pColInfo, numOfRows, (const char *)b3, false); - if (code != 0) { - mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); - goto _out; - } - - pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - code = colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); - if (code != 0) { - mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); - goto _out; - } - - int64_t roleTimeMs = (isDnodeOnline) ? pObj->roleTimeMs : 0; - pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - code = colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false); - if (code != 0) { - mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); - goto _out; - } - - numOfRows++; - sdbRelease(pSdb, pObj); + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + code = colDataSetVal(pColInfo, numOfRows, b1, false); + if (code != 0) { + mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); + goto _out; } - pShow->numOfRows += numOfRows; + char role[20] = "offline"; + if (pObj->id == pMnode->selfDnodeId) { + snprintf(role, sizeof(role), "%s%s", syncStr(TAOS_SYNC_STATE_LEADER), pMnode->restored ? "" : "*"); + } + bool isDnodeOnline = mndIsDnodeOnline(pObj->pDnode, curMs); + if (isDnodeOnline) { + tstrncpy(role, syncStr(pObj->syncState), sizeof(role)); + if (pObj->syncState == TAOS_SYNC_STATE_LEADER && pObj->id != pMnode->selfDnodeId) { + tstrncpy(role, syncStr(TAOS_SYNC_STATE_ERROR), sizeof(role)); + mError("mnode:%d, is leader too", pObj->id); + } + } + char b2[12 + VARSTR_HEADER_SIZE] = {0}; + STR_WITH_MAXSIZE_TO_VARSTR(b2, role, pShow->pMeta->pSchemas[cols].bytes); + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + code = colDataSetVal(pColInfo, numOfRows, (const char *)b2, false); + if (code != 0) { + mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); + goto _out; + } + const char *status = "ready"; + if (objStatus == SDB_STATUS_CREATING) status = "creating"; + if (objStatus == SDB_STATUS_DROPPING) status = "dropping"; + if (!isDnodeOnline) status = "offline"; + char b3[9 + VARSTR_HEADER_SIZE] = {0}; + STR_WITH_MAXSIZE_TO_VARSTR(b3, status, pShow->pMeta->pSchemas[cols].bytes); + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + code = colDataSetVal(pColInfo, numOfRows, (const char *)b3, false); + if (code != 0) { + mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); + goto _out; + } - _out: - sdbRelease(pSdb, pSelfObj); - return numOfRows; + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); + if (code != 0) { + mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); + goto _out; + } + + int64_t roleTimeMs = (isDnodeOnline) ? pObj->roleTimeMs : 0; + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false); + if (code != 0) { + mError("mnode:%d, failed to set col data val since %s", pObj->id, terrstr()); + goto _out; + } + + numOfRows++; + sdbRelease(pSdb, pObj); } - static void mndCancelGetNextMnode(SMnode * pMnode, void *pIter) { - SSdb *pSdb = pMnode->pSdb; - sdbCancelFetchByType(pSdb, pIter, SDB_MNODE); - } + pShow->numOfRows += numOfRows; - static int32_t mndProcessAlterMnodeReq(SRpcMsg * pReq) { +_out: + sdbRelease(pSdb, pSelfObj); + return numOfRows; +} + +static void mndCancelGetNextMnode(SMnode *pMnode, void *pIter) { + SSdb *pSdb = pMnode->pSdb; + sdbCancelFetchByType(pSdb, pIter, SDB_MNODE); +} + +static int32_t mndProcessAlterMnodeReq(SRpcMsg *pReq) { #if 1 - return 0; + return 0; #else - int32_t code = 0; - SMnode *pMnode = pReq->info.node; - SDAlterMnodeReq alterReq = {0}; + int32_t code = 0; + SMnode *pMnode = pReq->info.node; + SDAlterMnodeReq alterReq = {0}; - TAOS_CHECK_RETURN(tDeserializeSDCreateMnodeReq(pReq->pCont, pReq->contLen, &alterReq)); + TAOS_CHECK_RETURN(tDeserializeSDCreateMnodeReq(pReq->pCont, pReq->contLen, &alterReq)); - SMnodeOpt option = {.deploy = true, .numOfReplicas = alterReq.replica, .selfIndex = -1}; - memcpy(option.replicas, alterReq.replicas, sizeof(alterReq.replicas)); - for (int32_t i = 0; i < option.numOfReplicas; ++i) { - if (alterReq.replicas[i].id == pMnode->selfDnodeId) { - option.selfIndex = i; - } + SMnodeOpt option = {.deploy = true, .numOfReplicas = alterReq.replica, .selfIndex = -1}; + memcpy(option.replicas, alterReq.replicas, sizeof(alterReq.replicas)); + for (int32_t i = 0; i < option.numOfReplicas; ++i) { + if (alterReq.replicas[i].id == pMnode->selfDnodeId) { + option.selfIndex = i; } + } - if (option.selfIndex == -1) { - mInfo("alter mnode not processed since selfIndex is -1", terrstr()); - return 0; + if (option.selfIndex == -1) { + mInfo("alter mnode not processed since selfIndex is -1", terrstr()); + return 0; + } + + if ((code = mndWriteFile(pMnode->path, &option)) != 0) { + mError("failed to write mnode file since %s", terrstr()); + TAOS_RETURN(code); + } + + SSyncCfg cfg = {.replicaNum = alterReq.replica, .myIndex = -1}; + for (int32_t i = 0; i < alterReq.replica; ++i) { + SNodeInfo *pNode = &cfg.nodeInfo[i]; + tstrncpy(pNode->nodeFqdn, alterReq.replicas[i].fqdn, sizeof(pNode->nodeFqdn)); + pNode->nodePort = alterReq.replicas[i].port; + if (alterReq.replicas[i].id == pMnode->selfDnodeId) { + cfg.myIndex = i; } + } - if ((code = mndWriteFile(pMnode->path, &option)) != 0) { - mError("failed to write mnode file since %s", terrstr()); - TAOS_RETURN(code); - } - - SSyncCfg cfg = {.replicaNum = alterReq.replica, .myIndex = -1}; + if (cfg.myIndex == -1) { + mError("failed to alter mnode since myindex is -1"); + return -1; + } else { + mInfo("start to alter mnode sync, replica:%d myIndex:%d", cfg.replicaNum, cfg.myIndex); for (int32_t i = 0; i < alterReq.replica; ++i) { SNodeInfo *pNode = &cfg.nodeInfo[i]; - tstrncpy(pNode->nodeFqdn, alterReq.replicas[i].fqdn, sizeof(pNode->nodeFqdn)); - pNode->nodePort = alterReq.replicas[i].port; - if (alterReq.replicas[i].id == pMnode->selfDnodeId) { - cfg.myIndex = i; - } + mInfo("index:%d, fqdn:%s port:%d", i, pNode->nodeFqdn, pNode->nodePort); } - - if (cfg.myIndex == -1) { - mError("failed to alter mnode since myindex is -1"); - return -1; - } else { - mInfo("start to alter mnode sync, replica:%d myIndex:%d", cfg.replicaNum, cfg.myIndex); - for (int32_t i = 0; i < alterReq.replica; ++i) { - SNodeInfo *pNode = &cfg.nodeInfo[i]; - mInfo("index:%d, fqdn:%s port:%d", i, pNode->nodeFqdn, pNode->nodePort); - } - } - - code = syncReconfig(pMnode->syncMgmt.sync, &cfg); - if (code != 0) { - mError("failed to sync reconfig since %s", terrstr()); - } else { - mInfo("alter mnode sync success"); - } - - TAOS_RETURN(code); -#endif } - static void mndReloadSyncConfig(SMnode * pMnode) { - SSdb *pSdb = pMnode->pSdb; - SMnodeObj *pObj = NULL; - ESdbStatus objStatus = 0; - void *pIter = NULL; - int32_t updatingMnodes = 0; - int32_t readyMnodes = 0; - SSyncCfg cfg = { - .myIndex = -1, - .lastIndex = 0, - }; - SyncIndex maxIndex = 0; + code = syncReconfig(pMnode->syncMgmt.sync, &cfg); + if (code != 0) { + mError("failed to sync reconfig since %s", terrstr()); + } else { + mInfo("alter mnode sync success"); + } - while (1) { - pIter = sdbFetchAll(pSdb, SDB_MNODE, pIter, (void **)&pObj, &objStatus, false); - if (pIter == NULL) break; - if (objStatus == SDB_STATUS_CREATING || objStatus == SDB_STATUS_DROPPING) { - mInfo("vgId:1, has updating mnode:%d, status:%s", pObj->id, sdbStatusName(objStatus)); - updatingMnodes++; - } - if (objStatus == SDB_STATUS_READY) { - mInfo("vgId:1, has ready mnode:%d, status:%s", pObj->id, sdbStatusName(objStatus)); - readyMnodes++; - } - - if (objStatus == SDB_STATUS_READY || objStatus == SDB_STATUS_CREATING) { - SNodeInfo *pNode = &cfg.nodeInfo[cfg.totalReplicaNum]; - pNode->nodeId = pObj->pDnode->id; - pNode->clusterId = mndGetClusterId(pMnode); - pNode->nodePort = pObj->pDnode->port; - pNode->nodeRole = pObj->role; - tstrncpy(pNode->nodeFqdn, pObj->pDnode->fqdn, TSDB_FQDN_LEN); - code = tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); - if (code != 0) { - mError("mnode:%d, failed to update dnode info since %s", pObj->id, terrstr()); - } - mInfo("vgId:1, ep:%s:%u dnode:%d", pNode->nodeFqdn, pNode->nodePort, pNode->nodeId); - if (pObj->pDnode->id == pMnode->selfDnodeId) { - cfg.myIndex = cfg.totalReplicaNum; - } - if (pNode->nodeRole == TAOS_SYNC_ROLE_VOTER) { - cfg.replicaNum++; - } - cfg.totalReplicaNum++; - if (pObj->lastIndex > cfg.lastIndex) { - cfg.lastIndex = pObj->lastIndex; - } - } - - if (objStatus == SDB_STATUS_DROPPING) { - if (pObj->lastIndex > cfg.lastIndex) { - cfg.lastIndex = pObj->lastIndex; - } - } - - mInfo("vgId:1, mnode:%d, role:%d, lastIndex:%" PRId64, pObj->id, pObj->role, pObj->lastIndex); - - sdbReleaseLock(pSdb, pObj, false); - } - - // if (readyMnodes <= 0 || updatingMnodes <= 0) { - // mInfo("vgId:1, mnode sync not reconfig since readyMnodes:%d updatingMnodes:%d", readyMnodes, updatingMnodes); - // return; - // } - - if (cfg.myIndex == -1) { -#if 1 - mInfo("vgId:1, mnode sync not reconfig since selfIndex is -1"); -#else - // cannot reconfig because the leader may fail to elect after reboot - mInfo("vgId:1, mnode sync not reconfig since selfIndex is -1, do sync stop oper"); - syncStop(pMnode->syncMgmt.sync); + TAOS_RETURN(code); #endif - return; +} + +static void mndReloadSyncConfig(SMnode *pMnode) { + SSdb *pSdb = pMnode->pSdb; + SMnodeObj *pObj = NULL; + ESdbStatus objStatus = 0; + void *pIter = NULL; + int32_t updatingMnodes = 0; + int32_t readyMnodes = 0; + int32_t code = 0; + SSyncCfg cfg = { + .myIndex = -1, + .lastIndex = 0, + }; + SyncIndex maxIndex = 0; + + while (1) { + pIter = sdbFetchAll(pSdb, SDB_MNODE, pIter, (void **)&pObj, &objStatus, false); + if (pIter == NULL) break; + if (objStatus == SDB_STATUS_CREATING || objStatus == SDB_STATUS_DROPPING) { + mInfo("vgId:1, has updating mnode:%d, status:%s", pObj->id, sdbStatusName(objStatus)); + updatingMnodes++; + } + if (objStatus == SDB_STATUS_READY) { + mInfo("vgId:1, has ready mnode:%d, status:%s", pObj->id, sdbStatusName(objStatus)); + readyMnodes++; } - if (pMnode->syncMgmt.sync > 0) { - mInfo("vgId:1, mnode sync reconfig, totalReplica:%d replica:%d myIndex:%d", cfg.totalReplicaNum, cfg.replicaNum, - cfg.myIndex); - - for (int32_t i = 0; i < cfg.totalReplicaNum; ++i) { - SNodeInfo *pNode = &cfg.nodeInfo[i]; - mInfo("vgId:1, index:%d, ep:%s:%u dnode:%d cluster:%" PRId64 " role:%d", i, pNode->nodeFqdn, pNode->nodePort, - pNode->nodeId, pNode->clusterId, pNode->nodeRole); - } - - int32_t code = syncReconfig(pMnode->syncMgmt.sync, &cfg); + if (objStatus == SDB_STATUS_READY || objStatus == SDB_STATUS_CREATING) { + SNodeInfo *pNode = &cfg.nodeInfo[cfg.totalReplicaNum]; + pNode->nodeId = pObj->pDnode->id; + pNode->clusterId = mndGetClusterId(pMnode); + pNode->nodePort = pObj->pDnode->port; + pNode->nodeRole = pObj->role; + tstrncpy(pNode->nodeFqdn, pObj->pDnode->fqdn, TSDB_FQDN_LEN); + code = tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); if (code != 0) { - mError("vgId:1, mnode sync reconfig failed since %s", terrstr()); - } else { - mInfo("vgId:1, mnode sync reconfig success"); + mError("mnode:%d, failed to update dnode info since %s", pObj->id, terrstr()); + } + mInfo("vgId:1, ep:%s:%u dnode:%d", pNode->nodeFqdn, pNode->nodePort, pNode->nodeId); + if (pObj->pDnode->id == pMnode->selfDnodeId) { + cfg.myIndex = cfg.totalReplicaNum; + } + if (pNode->nodeRole == TAOS_SYNC_ROLE_VOTER) { + cfg.replicaNum++; + } + cfg.totalReplicaNum++; + if (pObj->lastIndex > cfg.lastIndex) { + cfg.lastIndex = pObj->lastIndex; } } + + if (objStatus == SDB_STATUS_DROPPING) { + if (pObj->lastIndex > cfg.lastIndex) { + cfg.lastIndex = pObj->lastIndex; + } + } + + mInfo("vgId:1, mnode:%d, role:%d, lastIndex:%" PRId64, pObj->id, pObj->role, pObj->lastIndex); + + sdbReleaseLock(pSdb, pObj, false); } + + // if (readyMnodes <= 0 || updatingMnodes <= 0) { + // mInfo("vgId:1, mnode sync not reconfig since readyMnodes:%d updatingMnodes:%d", readyMnodes, updatingMnodes); + // return; + // } + + if (cfg.myIndex == -1) { +#if 1 + mInfo("vgId:1, mnode sync not reconfig since selfIndex is -1"); +#else + // cannot reconfig because the leader may fail to elect after reboot + mInfo("vgId:1, mnode sync not reconfig since selfIndex is -1, do sync stop oper"); + syncStop(pMnode->syncMgmt.sync); +#endif + return; + } + + if (pMnode->syncMgmt.sync > 0) { + mInfo("vgId:1, mnode sync reconfig, totalReplica:%d replica:%d myIndex:%d", cfg.totalReplicaNum, cfg.replicaNum, + cfg.myIndex); + + for (int32_t i = 0; i < cfg.totalReplicaNum; ++i) { + SNodeInfo *pNode = &cfg.nodeInfo[i]; + mInfo("vgId:1, index:%d, ep:%s:%u dnode:%d cluster:%" PRId64 " role:%d", i, pNode->nodeFqdn, pNode->nodePort, + pNode->nodeId, pNode->clusterId, pNode->nodeRole); + } + + int32_t code = syncReconfig(pMnode->syncMgmt.sync, &cfg); + if (code != 0) { + mError("vgId:1, mnode sync reconfig failed since %s", terrstr()); + } else { + mInfo("vgId:1, mnode sync reconfig success"); + } + } +} diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index 3199292a7d..2fe1ef4cfb 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -14,7 +14,6 @@ */ #define _DEFAULT_SOURCE -#include "mndVgroup.h" #include "audit.h" #include "mndArbGroup.h" #include "mndDb.h" @@ -27,6 +26,7 @@ #include "mndTopic.h" #include "mndTrans.h" #include "mndUser.h" +#include "mndVgroup.h" #include "tmisce.h" #define VGROUP_VER_NUMBER 1 @@ -320,6 +320,7 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg createReq.tsdbPageSize = pDb->cfg.tsdbPageSize; createReq.changeVersion = ++(pVgroup->syncConfChangeVer); createReq.encryptAlgorithm = pDb->cfg.encryptAlgorithm; + int32_t code = 0; for (int32_t v = 0; v < pVgroup->replica; ++v) { SReplica *pReplica = NULL; @@ -390,7 +391,13 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg return NULL; } - (void)tSerializeSCreateVnodeReq(pReq, contLen, &createReq); + code = tSerializeSCreateVnodeReq(pReq, contLen, &createReq); + if (code < 0) { + terrno = TSDB_CODE_APP_ERROR; + taosMemoryFree(pReq); + mError("vgId:%d, failed to serialize create vnode req,since %s", createReq.vgId, terrstr()); + return NULL; + } *pContLen = contLen; return pReq; } @@ -436,7 +443,12 @@ static void *mndBuildAlterVnodeConfigReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pV pHead->contLen = htonl(contLen); pHead->vgId = htonl(pVgroup->vgId); - (void)tSerializeSAlterVnodeConfigReq((char *)pReq + sizeof(SMsgHead), contLen, &alterReq); + if (tSerializeSAlterVnodeConfigReq((char *)pReq + sizeof(SMsgHead), contLen, &alterReq) < 0) { + taosMemoryFree(pReq); + mError("vgId:%d, failed to serialize alter vnode config req,since %s", pVgroup->vgId, terrstr()); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } *pContLen = contLen; return pReq; } @@ -514,7 +526,12 @@ static void *mndBuildAlterVnodeReplicaReq(SMnode *pMnode, SDbObj *pDb, SVgObj *p return NULL; } - (void)tSerializeSAlterVnodeReplicaReq(pReq, contLen, &alterReq); + if (tSerializeSAlterVnodeReplicaReq(pReq, contLen, &alterReq) < 0) { + mError("vgId:%d, failed to serialize alter vnode req,since %s", alterReq.vgId, terrstr()); + taosMemoryFree(pReq); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } *pContLen = contLen; return pReq; } @@ -587,7 +604,12 @@ static void *mndBuildCheckLearnCatchupReq(SMnode *pMnode, SDbObj *pDb, SVgObj *p return NULL; } - (void)tSerializeSAlterVnodeReplicaReq(pReq, contLen, &req); + if (tSerializeSAlterVnodeReplicaReq(pReq, contLen, &req) < 0) { + mError("vgId:%d, failed to serialize alter vnode req,since %s", req.vgId, terrstr()); + taosMemoryFree(pReq); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } *pContLen = contLen; return pReq; } @@ -611,7 +633,12 @@ static void *mndBuildDisableVnodeWriteReq(SMnode *pMnode, SDbObj *pDb, int32_t v return NULL; } - (void)tSerializeSDisableVnodeWriteReq(pReq, contLen, &disableReq); + if (tSerializeSDisableVnodeWriteReq(pReq, contLen, &disableReq) < 0) { + mError("vgId:%d, failed to serialize disable vnode write req,since %s", vgId, terrstr()); + taosMemoryFree(pReq); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } *pContLen = contLen; return pReq; } @@ -639,7 +666,12 @@ static void *mndBuildAlterVnodeHashRangeReq(SMnode *pMnode, int32_t srcVgId, SVg return NULL; } - (void)tSerializeSAlterVnodeHashRangeReq(pReq, contLen, &alterReq); + if (tSerializeSAlterVnodeHashRangeReq(pReq, contLen, &alterReq) < 0) { + mError("vgId:%d, failed to serialize alter vnode hashrange req,since %s", srcVgId, terrstr()); + taosMemoryFree(pReq); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } *pContLen = contLen; return pReq; } @@ -664,7 +696,12 @@ void *mndBuildDropVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgOb return NULL; } - (void)tSerializeSDropVnodeReq(pReq, contLen, &dropReq); + if (tSerializeSDropVnodeReq(pReq, contLen, &dropReq) < 0) { + mError("vgId:%d, failed to serialize drop vnode req,since %s", dropReq.vgId, terrstr()); + taosMemoryFree(pReq); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } *pContLen = contLen; return pReq; } @@ -907,7 +944,9 @@ SEpSet mndGetVgroupEpset(SMnode *pMnode, const SVgObj *pVgroup) { epset.inUse = epset.numOfEps; } - (void)addEpIntoEpSet(&epset, pDnode->fqdn, pDnode->port); + if (addEpIntoEpSet(&epset, pDnode->fqdn, pDnode->port) != 0) { + mWarn("vgId:%d, failed to add ep:%s:%d into epset", pVgroup->vgId, pDnode->fqdn, pDnode->port); + } mndReleaseDnode(pMnode, pDnode); } epsetSort(&epset); @@ -930,7 +969,9 @@ SEpSet mndGetVgroupEpsetById(SMnode *pMnode, int32_t vgId) { epset.inUse = epset.numOfEps; } - (void)addEpIntoEpSet(&epset, pDnode->fqdn, pDnode->port); + if (addEpIntoEpSet(&epset, pDnode->fqdn, pDnode->port) != 0) { + mWarn("vgId:%d, failed to add ep:%s:%d into epset", pVgroup->vgId, pDnode->fqdn, pDnode->port); + } mndReleaseDnode(pMnode, pDnode); } @@ -945,6 +986,7 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p SVgObj *pVgroup = NULL; int32_t cols = 0; int64_t curMs = taosGetTimestampMs(); + int32_t code = 0; SDbObj *pDb = NULL; if (strlen(pShow->db) > 0) { @@ -965,26 +1007,46 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p cols = 0; SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->vgId, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->vgId, false); + if (code != 0) { + mError("vgId:%d, failed to set vgId, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } SName name = {0}; char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; - (void)tNameFromString(&name, pVgroup->dbName, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&name, pVgroup->dbName, T_NAME_ACCT | T_NAME_DB); + if (code != 0) { + mError("vgId:%d, failed to set dbName, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } (void)tNameGetDbName(&name, varDataVal(db)); varDataSetLen(db, strlen(varDataVal(db))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)db, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)db, false); + if (code != 0) { + mError("vgId:%d, failed to set dbName, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->numOfTables, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->numOfTables, false); + if (code != 0) { + mError("vgId:%d, failed to set numOfTables, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } // default 3 replica, add 1 replica if move vnode for (int32_t i = 0; i < 4; ++i) { pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); if (i < pVgroup->replica) { int16_t dnodeId = (int16_t)pVgroup->vnodeGid[i].dnodeId; - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&dnodeId, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&dnodeId, false); + if (code != 0) { + mError("vgId:%d, failed to set dnodeId, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } bool exist = false; bool online = false; @@ -1038,7 +1100,11 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p STR_WITH_MAXSIZE_TO_VARSTR(buf1, role, pShow->pMeta->pSchemas[cols].bytes); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)buf1, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)buf1, false); + if (code != 0) { + mError("vgId:%d, failed to set role, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } } else { colDataSetNULL(pColInfo, numOfRows); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); @@ -1048,21 +1114,25 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); int32_t cacheUsage = (int32_t)pVgroup->cacheUsage; - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&cacheUsage, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&cacheUsage, false); + if (code != 0) { + mError("vgId:%d, failed to set cacheUsage, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->numOfCachedTables, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->numOfCachedTables, false); + if (code != 0) { + mError("vgId:%d, failed to set numOfCachedTables, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->isTsma, false); - - // pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - // if (pDb == NULL || pDb->compactStartTime <= 0) { - // colDataSetNULL(pColInfo, numOfRows); - // } else { - // (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDb->compactStartTime, false); - // } - + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->isTsma, false); + if (code != 0) { + mError("vgId:%d, failed to set isTsma, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } numOfRows++; sdbRelease(pSdb, pVgroup); } @@ -1147,6 +1217,7 @@ static int32_t mndRetrieveVnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB SVgObj *pVgroup = NULL; int32_t cols = 0; int64_t curMs = taosGetTimestampMs(); + int32_t code = 0; while (numOfRows < rows - TSDB_MAX_REPLICA) { pShow->pIter = sdbFetch(pSdb, SDB_VGROUP, pShow->pIter, (void **)&pVgroup); @@ -1158,10 +1229,17 @@ static int32_t mndRetrieveVnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB cols = 0; pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pGid->dnodeId, false); - + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pGid->dnodeId, false); + if (code != 0) { + mError("vgId:%d, failed to set dnodeId, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->vgId, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pVgroup->vgId, false); + if (code != 0) { + mError("vgId:%d, failed to set vgId, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } // db_name const char *dbname = mndGetDbStr(pVgroup->dbName); @@ -1172,7 +1250,11 @@ static int32_t mndRetrieveVnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB STR_WITH_MAXSIZE_TO_VARSTR(b1, "NULL", TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE); } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)b1, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)b1, false); + if (code != 0) { + mError("vgId:%d, failed to set dbName, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } // dnode is online? SDnodeObj *pDnode = mndAcquireDnode(pMnode, pGid->dnodeId); @@ -1186,18 +1268,34 @@ static int32_t mndRetrieveVnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB ESyncState syncState = (isDnodeOnline) ? pGid->syncState : TAOS_SYNC_STATE_OFFLINE; STR_TO_VARSTR(buf, syncStr(syncState)); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)buf, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)buf, false); + if (code != 0) { + mError("vgId:%d, failed to set syncState, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } int64_t roleTimeMs = (isDnodeOnline) ? pGid->roleTimeMs : 0; pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false); + if (code != 0) { + mError("vgId:%d, failed to set roleTimeMs, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } int64_t startTimeMs = (isDnodeOnline) ? pGid->startTimeMs : 0; pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&startTimeMs, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&startTimeMs, false); + if (code != 0) { + mError("vgId:%d, failed to set startTimeMs, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pGid->syncRestore, false); + code = colDataSetVal(pColInfo, numOfRows, (const char *)&pGid->syncRestore, false); + if (code != 0) { + mError("vgId:%d, failed to set syncRestore, since %s", pVgroup->vgId, tstrerror(code)); + return code; + } numOfRows++; sdbRelease(pSdb, pDnode); @@ -1270,8 +1368,10 @@ static int32_t mndAddVnodeToVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgro sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); - + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", pVgroup->vgId, tstrerror(code), __LINE__); + } TAOS_RETURN(code); } @@ -1332,7 +1432,10 @@ _OVER: sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", pVgroup->vgId, tstrerror(code), __LINE__); + } TAOS_RETURN(code); } @@ -1568,6 +1671,10 @@ int32_t mndAddNewVgPrepareAction(SMnode *pMnode, STrans *pTrans, SVgObj *pVg) { TAOS_CHECK_GOTO(mndTransAppendPrepareLog(pTrans, pRaw), NULL, _err); (void)sdbSetRawStatus(pRaw, SDB_STATUS_CREATING); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", pVg->vgId, tstrerror(code), __LINE__); + TAOS_RETURN(code); + } pRaw = NULL; TAOS_RETURN(code); @@ -1824,7 +1931,11 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, sdbFreeRaw(pRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", newVg.vgId, tstrerror(code), __LINE__); + return code; + } } TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg, &del, true)); @@ -1850,7 +1961,6 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, sdbFreeRaw(pRaw); return -1; } - (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); } if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg, &del, true) != 0) return -1; @@ -1880,7 +1990,11 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, sdbFreeRaw(pRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", newVg.vgId, tstrerror(code), __LINE__); + return code; + } } for (int32_t i = 0; i < newVg.replica; ++i) { @@ -1930,7 +2044,11 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, sdbFreeRaw(pRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", newVg.vgId, tstrerror(code), __LINE__); + return code; + } } mInfo("vgId:%d, vgroup info after move, replica:%d", newVg.vgId, newVg.replica); @@ -2005,7 +2123,11 @@ static int32_t mndAddIncVgroupReplicaToTrans(SMnode *pMnode, STrans *pTrans, SDb sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", pVgroup->vgId, tstrerror(code), __LINE__); + TAOS_RETURN(code); + } // learner for (int32_t i = 0; i < pVgroup->replica - 1; ++i) { @@ -2057,7 +2179,11 @@ static int32_t mndAddDecVgroupReplicaFromTrans(SMnode *pMnode, STrans *pTrans, S sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", pVgroup->vgId, tstrerror(code), __LINE__); + TAOS_RETURN(code); + } TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, &delGid, true)); for (int32_t i = 0; i < pVgroup->replica; ++i) { @@ -2171,7 +2297,11 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, sdbFreeRaw(pRaw); goto _OVER; } - (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", newVg.vgId, tstrerror(code), __LINE__); + goto _OVER; + } } mInfo("vgId:%d, vgroup info after redistribute, replica:%d", newVg.vgId, newVg.replica); @@ -2452,7 +2582,11 @@ static void *mndBuildSForceBecomeFollowerReq(SMnode *pMnode, SVgObj *pVgroup, in pHead->contLen = htonl(contLen); pHead->vgId = htonl(pVgroup->vgId); - (void)tSerializeSForceBecomeFollowerReq((char *)pReq + sizeof(SMsgHead), contLen, &balanceReq); + if (tSerializeSForceBecomeFollowerReq((char *)pReq + sizeof(SMsgHead), contLen, &balanceReq) < 0) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFree(pReq); + return NULL; + } *pContLen = contLen; return pReq; } @@ -2693,7 +2827,11 @@ int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status since %s at line:%d", pNewVgroup->vgId, tstrerror(code), __LINE__); + TAOS_RETURN(code); + } } TAOS_RETURN(code); @@ -2776,7 +2914,12 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status to ready, error:%s, line:%d", newVgroup.vgId, tstrerror(code), + __LINE__); + TAOS_RETURN(code); + } } else if (newVgroup.replica == 3 && pNewDb->cfg.replications == 1) { mInfo("db:%s, vgId:%d, will remove 2 vnodes, vn:0 dnode:%d vn:1 dnode:%d vn:2 dnode:%d", pVgroup->dbName, pVgroup->vgId, pVgroup->vnodeGid[0].dnodeId, pVgroup->vnodeGid[1].dnodeId, pVgroup->vnodeGid[2].dnodeId); @@ -2801,7 +2944,12 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status to ready, error:%s, line:%d", newVgroup.vgId, tstrerror(code), + __LINE__); + TAOS_RETURN(code); + } SVnodeGid del2 = {0}; TAOS_CHECK_RETURN(mndRemoveVnodeFromVgroupWithoutSave(pMnode, pTrans, &newVgroup, pArray, &del2)); @@ -2823,7 +2971,12 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status to ready, error:%s, line:%d", newVgroup.vgId, tstrerror(code), + __LINE__); + TAOS_RETURN(code); + } } else { return -1; } @@ -2841,7 +2994,12 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status to ready, error:%s, line:%d", newVgroup.vgId, tstrerror(code), + __LINE__); + TAOS_RETURN(code); + } } TAOS_RETURN(code); @@ -2917,7 +3075,11 @@ int32_t mndBuildRestoreAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj sdbFreeRaw(pVgRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status to ready, error:%s, line:%d", newVgroup.vgId, tstrerror(code), __LINE__); + TAOS_RETURN(code); + } TAOS_RETURN(code); } @@ -2938,7 +3100,11 @@ static int32_t mndAddVgStatusAction(STrans *pTrans, SVgObj *pVg, ESdbStatus vgSt goto _err; } if ((code = appendActionCb(pTrans, pRaw)) != 0) goto _err; - (void)sdbSetRawStatus(pRaw, vgStatus); + code = sdbSetRawStatus(pRaw, vgStatus); + if (code != 0) { + mError("vgId:%d, failed to set raw status to ready, error:%s, line:%d", pVg->vgId, tstrerror(code), __LINE__); + goto _err; + } pRaw = NULL; TAOS_RETURN(code); _err: @@ -2956,7 +3122,11 @@ static int32_t mndAddDbStatusAction(STrans *pTrans, SDbObj *pDb, ESdbStatus dbSt goto _err; } if ((code = appendActionCb(pTrans, pRaw)) != 0) goto _err; - (void)sdbSetRawStatus(pRaw, dbStatus); + code = sdbSetRawStatus(pRaw, dbStatus); + if (code != 0) { + mError("db:%s, failed to set raw status to ready, error:%s, line:%d", pDb->name, tstrerror(code), __LINE__); + goto _err; + } pRaw = NULL; TAOS_RETURN(code); _err: @@ -3165,7 +3335,11 @@ static int32_t mndSetBalanceVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SD sdbFreeRaw(pRaw); TAOS_RETURN(code); } - (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); + code = sdbSetRawStatus(pRaw, SDB_STATUS_READY); + if (code != 0) { + mError("vgId:%d, failed to set raw status to ready, error:%s, line:%d", newVg.vgId, tstrerror(code), __LINE__); + TAOS_RETURN(code); + } } mInfo("vgId:%d, vgroup info after balance, replica:%d", newVg.vgId, newVg.replica); @@ -3391,7 +3565,11 @@ static void *mndBuildCompactVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgrou pHead->contLen = htonl(contLen); pHead->vgId = htonl(pVgroup->vgId); - (void)tSerializeSCompactVnodeReq((char *)pReq + sizeof(SMsgHead), contLen, &compactReq); + if (tSerializeSCompactVnodeReq((char *)pReq + sizeof(SMsgHead), contLen, &compactReq) < 0) { + taosMemoryFree(pReq); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } *pContLen = contLen; return pReq; }