taosdata / TDengine / #3621

coverage: 2.037% (-61.5%) from 63.573%
#3621

push

travis-ci

web-flow 
Merge pull request #29874 from taosdata/merge/mainto3.0

merge: from main to 3.0 branch

4357 of 287032 branches covered (1.52%)

Branch coverage included in aggregate %.

0 of 174 new or added lines in 18 files covered. (0.0%)

213359 existing lines in 469 files now uncovered.

7260 of 283369 relevant lines covered (2.56%)

23737.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0
/source/dnode/mnode/impl/src/mndQnode.c
1 
/*
2 
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3 
 *
4 
 * This program is free software: you can use, redistribute, and/or modify
5 
 * it under the terms of the GNU Affero General Public License, version 3
6 
 * or later ("AGPL"), as published by the Free Software Foundation.
7 
 *
8 
 * This program is distributed in the hope that it will be useful, but WITHOUT
9 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 
 * FITNESS FOR A PARTICULAR PURPOSE.
11 
 *
12 
 * You should have received a copy of the GNU Affero General Public License
13 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 
 */
15 









16



#define _DEFAULT_SOURCE










17



#include "audit.h"










18



#include "mndDnode.h"










19



#include "mndPrivilege.h"










20



#include "mndQnode.h"










21



#include "mndShow.h"










22



#include "mndTrans.h"










23



#include "mndUser.h"










24












25



#define QNODE_VER_NUMBER   1










26



#define QNODE_RESERVE_SIZE 64










27












28



static SSdbRaw *mndQnodeActionEncode(SQnodeObj *pObj);










29



static SSdbRow *mndQnodeActionDecode(SSdbRaw *pRaw);










30



static int32_t  mndQnodeActionInsert(SSdb *pSdb, SQnodeObj *pObj);










31



static int32_t  mndQnodeActionUpdate(SSdb *pSdb, SQnodeObj *pOld, SQnodeObj *pNew);










32



static int32_t  mndQnodeActionDelete(SSdb *pSdb, SQnodeObj *pObj);










33



static int32_t  mndProcessCreateQnodeReq(SRpcMsg *pReq);










34



static int32_t  mndProcessDropQnodeReq(SRpcMsg *pReq);










35



static int32_t  mndProcessQnodeListReq(SRpcMsg *pReq);










36



static int32_t  mndRetrieveQnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);










37



static void     mndCancelGetNextQnode(SMnode *pMnode, void *pIter);










38













UNCOV

39



int32_t mndInitQnode(SMnode *pMnode) {




×








UNCOV

40



  SSdbTable table = {




×







41



      .sdbType = SDB_QNODE,










42



      .keyType = SDB_KEY_INT32,










43



      .encodeFp = (SdbEncodeFp)mndQnodeActionEncode,










44



      .decodeFp = (SdbDecodeFp)mndQnodeActionDecode,










45



      .insertFp = (SdbInsertFp)mndQnodeActionInsert,










46



      .updateFp = (SdbUpdateFp)mndQnodeActionUpdate,










47



      .deleteFp = (SdbDeleteFp)mndQnodeActionDelete,










48



  };










49













UNCOV

50



  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_QNODE, mndProcessCreateQnodeReq);




×








UNCOV

51



  mndSetMsgHandle(pMnode, TDMT_MND_DROP_QNODE, mndProcessDropQnodeReq);




×








UNCOV

52



  mndSetMsgHandle(pMnode, TDMT_DND_CREATE_QNODE_RSP, mndTransProcessRsp);




×








UNCOV

53



  mndSetMsgHandle(pMnode, TDMT_DND_DROP_QNODE_RSP, mndTransProcessRsp);




×








UNCOV

54



  mndSetMsgHandle(pMnode, TDMT_MND_QNODE_LIST, mndProcessQnodeListReq);




×







55













UNCOV

56



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_QNODE, mndRetrieveQnodes);




×








UNCOV

57



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_QNODE, mndCancelGetNextQnode);




×







58













UNCOV

59



  return sdbSetTable(pMnode->pSdb, table);




×







60



}










61













UNCOV

62



void mndCleanupQnode(SMnode *pMnode) {}




×







63













UNCOV

64



SQnodeObj *mndAcquireQnode(SMnode *pMnode, int32_t qnodeId) {




×








UNCOV

65



  SQnodeObj *pObj = sdbAcquire(pMnode->pSdb, SDB_QNODE, &qnodeId);




×








UNCOV

66



  if (pObj == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {





×








UNCOV

67



    terrno = TSDB_CODE_MND_QNODE_NOT_EXIST;




×







68



  }











UNCOV

69



  return pObj;




×







70



}










71













UNCOV

72



void mndReleaseQnode(SMnode *pMnode, SQnodeObj *pObj) {




×








UNCOV

73



  SSdb *pSdb = pMnode->pSdb;




×








UNCOV

74



  sdbRelease(pSdb, pObj);




×








UNCOV

75



}




×







76













UNCOV

77



static SSdbRaw *mndQnodeActionEncode(SQnodeObj *pObj) {




×








UNCOV

78



  int32_t code = 0;




×








UNCOV

79



  int32_t lino = 0;




×








UNCOV

80



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×







81













UNCOV

82



  SSdbRaw *pRaw = sdbAllocRaw(SDB_QNODE, QNODE_VER_NUMBER, sizeof(SQnodeObj) + QNODE_RESERVE_SIZE);




×








UNCOV

83



  if (pRaw == NULL) goto _OVER;





×







84













UNCOV

85



  int32_t dataPos = 0;




×








UNCOV

86



  SDB_SET_INT32(pRaw, dataPos, pObj->id, _OVER)





×








UNCOV

87



  SDB_SET_INT64(pRaw, dataPos, pObj->createdTime, _OVER)





×








UNCOV

88



  SDB_SET_INT64(pRaw, dataPos, pObj->updateTime, _OVER)





×








UNCOV

89



  SDB_SET_RESERVE(pRaw, dataPos, QNODE_RESERVE_SIZE, _OVER)





×







90













UNCOV

91



  terrno = 0;




×







92













UNCOV

93



_OVER:




×








UNCOV

94



  if (terrno != 0) {





×







95



    mError("qnode:%d, failed to encode to raw:%p since %s", pObj->id, pRaw, terrstr());





×







96



    sdbFreeRaw(pRaw);




×







97



    return NULL;




×







98



  }










99













UNCOV

100



  mTrace("qnode:%d, encode to raw:%p, row:%p", pObj->id, pRaw, pObj);





×








UNCOV

101



  return pRaw;




×







102



}










103













UNCOV

104



static SSdbRow *mndQnodeActionDecode(SSdbRaw *pRaw) {




×








UNCOV

105



  int32_t code = 0;




×








UNCOV

106



  int32_t lino = 0;




×








UNCOV

107



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

108



  SSdbRow   *pRow = NULL;




×








UNCOV

109



  SQnodeObj *pObj = NULL;




×







110













UNCOV

111



  int8_t sver = 0;




×








UNCOV

112



  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;





×







113













UNCOV

114



  if (sver != QNODE_VER_NUMBER) {





×







115



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







116



    goto _OVER;




×







117



  }










118













UNCOV

119



  pRow = sdbAllocRow(sizeof(SQnodeObj));




×








UNCOV

120



  if (pRow == NULL) goto _OVER;





×







121













UNCOV

122



  pObj = sdbGetRowObj(pRow);




×








UNCOV

123



  if (pObj == NULL) goto _OVER;





×







124













UNCOV

125



  int32_t dataPos = 0;




×








UNCOV

126



  SDB_GET_INT32(pRaw, dataPos, &pObj->id, _OVER)





×








UNCOV

127



  SDB_GET_INT64(pRaw, dataPos, &pObj->createdTime, _OVER)





×








UNCOV

128



  SDB_GET_INT64(pRaw, dataPos, &pObj->updateTime, _OVER)





×








UNCOV

129



  SDB_GET_RESERVE(pRaw, dataPos, QNODE_RESERVE_SIZE, _OVER)





×







130













UNCOV

131



  terrno = 0;




×







132













UNCOV

133



_OVER:




×








UNCOV

134



  if (terrno != 0) {





×







135



    mError("qnode:%d, failed to decode from raw:%p since %s", pObj == NULL ? 0 : pObj->id, pRaw, terrstr());





×







136



    taosMemoryFreeClear(pRow);





×







137



    return NULL;




×







138



  }










139













UNCOV

140



  mTrace("qnode:%d, decode from raw:%p, row:%p", pObj->id, pRaw, pObj);





×








UNCOV

141



  return pRow;




×







142



}










143













UNCOV

144



static int32_t mndQnodeActionInsert(SSdb *pSdb, SQnodeObj *pObj) {




×








UNCOV

145



  int32_t code = 0;




×








UNCOV

146



  mTrace("qnode:%d, perform insert action, row:%p", pObj->id, pObj);





×








UNCOV

147



  pObj->pDnode = sdbAcquire(pSdb, SDB_DNODE, &pObj->id);




×








UNCOV

148



  if (pObj->pDnode == NULL) {





×







149



    code = TSDB_CODE_MND_DNODE_NOT_EXIST;




×







150



    mError("qnode:%d, failed to perform insert action since %s", pObj->id, terrstr());





×







151



    TAOS_RETURN(code);




×







152



  }










153













UNCOV

154



  TAOS_RETURN(code);




×







155



}










156













UNCOV

157



static int32_t mndQnodeActionDelete(SSdb *pSdb, SQnodeObj *pObj) {




×








UNCOV

158



  mTrace("qnode:%d, perform delete action, row:%p", pObj->id, pObj);





×








UNCOV

159



  if (pObj->pDnode != NULL) {





×








UNCOV

160



    sdbRelease(pSdb, pObj->pDnode);




×








UNCOV

161



    pObj->pDnode = NULL;




×







162



  }










163













UNCOV

164



  return 0;




×







165



}










166













UNCOV

167



static int32_t mndQnodeActionUpdate(SSdb *pSdb, SQnodeObj *pOld, SQnodeObj *pNew) {




×








UNCOV

168



  mTrace("qnode:%d, perform update action, old row:%p new row:%p", pOld->id, pOld, pNew);





×








UNCOV

169



  pOld->updateTime = pNew->updateTime;




×








UNCOV

170



  return 0;




×







171



}










172













UNCOV

173



static int32_t mndSetCreateQnodeRedoLogs(STrans *pTrans, SQnodeObj *pObj) {




×








UNCOV

174



  int32_t  code = 0;




×








UNCOV

175



  SSdbRaw *pRedoRaw = mndQnodeActionEncode(pObj);




×








UNCOV

176



  if (pRedoRaw == NULL) {





×







177



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







178



    if (terrno != 0) code = terrno;





×







179



    TAOS_RETURN(code);




×







180



  }











UNCOV

181



  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw));





×








UNCOV

182



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING));





×








UNCOV

183



  TAOS_RETURN(code);




×







184



}










185













UNCOV

186



static int32_t mndSetCreateQnodeUndoLogs(STrans *pTrans, SQnodeObj *pObj) {




×








UNCOV

187



  int32_t  code = 0;




×








UNCOV

188



  SSdbRaw *pUndoRaw = mndQnodeActionEncode(pObj);




×








UNCOV

189



  if (pUndoRaw == NULL) {





×







190



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







191



    if (terrno != 0) code = terrno;





×







192



    TAOS_RETURN(code);




×







193



  }











UNCOV

194



  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pUndoRaw));





×








UNCOV

195



  TAOS_CHECK_RETURN(sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED));





×








UNCOV

196



  TAOS_RETURN(code);




×







197



}










198













UNCOV

199



int32_t mndSetCreateQnodeCommitLogs(STrans *pTrans, SQnodeObj *pObj) {




×








UNCOV

200



  int32_t  code = 0;




×








UNCOV

201



  SSdbRaw *pCommitRaw = mndQnodeActionEncode(pObj);




×








UNCOV

202



  if (pCommitRaw == NULL) {





×







203



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







204



    if (terrno != 0) code = terrno;





×







205



    TAOS_RETURN(code);




×







206



  }











UNCOV

207



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));





×








UNCOV

208



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));





×








UNCOV

209



  TAOS_RETURN(code);




×







210



}










211












212



bool mndQnodeInDnode(SQnodeObj *pQnode, int32_t dnodeId) { return pQnode->pDnode->id == dnodeId; }




×







213













UNCOV

214



int32_t mndSetCreateQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQnodeObj *pObj) {




×








UNCOV

215



  int32_t          code = 0;




×








UNCOV

216



  SDCreateQnodeReq createReq = {0};




×








UNCOV

217



  createReq.dnodeId = pDnode->id;




×







218













UNCOV

219



  int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, &createReq);




×








UNCOV

220



  void   *pReq = taosMemoryMalloc(contLen);





×








UNCOV

221



  if (pReq == NULL) {





×







222



    terrno = TSDB_CODE_OUT_OF_MEMORY;




×







223



    return -1;




×







224



  }











UNCOV

225



  code = tSerializeSCreateDropMQSNodeReq(pReq, contLen, &createReq);




×








UNCOV

226



  if (code < 0) {





×







227



    mError("qnode:%d, failed to serialize create drop qnode request since %s", createReq.dnodeId, terrstr());





×







228



  }











UNCOV

229



  STransAction action = {0};




×








UNCOV

230



  action.epSet = mndGetDnodeEpset(pDnode);




×








UNCOV

231



  action.pCont = pReq;




×








UNCOV

232



  action.contLen = contLen;




×








UNCOV

233



  action.msgType = TDMT_DND_CREATE_QNODE;




×








UNCOV

234



  action.acceptableCode = TSDB_CODE_QNODE_ALREADY_DEPLOYED;




×







235













UNCOV

236



  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {





×







237



    taosMemoryFree(pReq);





×







238



    TAOS_RETURN(code);




×







239



  }










240













UNCOV

241



  TAOS_RETURN(code);




×







242



}










243













UNCOV

244



static int32_t mndSetCreateQnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, SQnodeObj *pObj) {




×








UNCOV

245



  int32_t        code = 0;




×








UNCOV

246



  SDDropQnodeReq dropReq = {0};




×








UNCOV

247



  dropReq.dnodeId = pDnode->id;




×







248













UNCOV

249



  int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, &dropReq);




×








UNCOV

250



  void   *pReq = taosMemoryMalloc(contLen);





×








UNCOV

251



  if (pReq == NULL) {





×







252



    code = terrno;




×







253



    TAOS_RETURN(code);




×







254



  }











UNCOV

255



  code = tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq);




×








UNCOV

256



  if (code < 0) {





×







257



    mError("qnode:%d, failed to serialize create drop qnode request since %s", dropReq.dnodeId, terrstr());





×







258



  }










259













UNCOV

260



  STransAction action = {0};




×








UNCOV

261



  action.epSet = mndGetDnodeEpset(pDnode);




×








UNCOV

262



  action.pCont = pReq;




×








UNCOV

263



  action.contLen = contLen;




×








UNCOV

264



  action.msgType = TDMT_DND_DROP_QNODE;




×








UNCOV

265



  action.acceptableCode = TSDB_CODE_QNODE_NOT_DEPLOYED;




×







266













UNCOV

267



  if ((code = mndTransAppendUndoAction(pTrans, &action)) != 0) {





×







268



    taosMemoryFree(pReq);





×







269



    TAOS_RETURN(code);




×







270



  }










271













UNCOV

272



  TAOS_RETURN(code);




×







273



}










274













UNCOV

275



static int32_t mndCreateQnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMCreateQnodeReq *pCreate) {




×








UNCOV

276



  int32_t code = -1;




×







277













UNCOV

278



  SQnodeObj qnodeObj = {0};




×








UNCOV

279



  qnodeObj.id = pDnode->id;




×








UNCOV

280



  qnodeObj.createdTime = taosGetTimestampMs();




×








UNCOV

281



  qnodeObj.updateTime = qnodeObj.createdTime;




×







282













UNCOV

283



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pReq, "create-qnode");




×








UNCOV

284



  if (pTrans == NULL) {





×







285



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







286



    if (terrno != 0) code = terrno;





×







287



    goto _OVER;




×







288



  }











UNCOV

289



  mndTransSetSerial(pTrans);




×







290













UNCOV

291



  mInfo("trans:%d, used to create qnode:%d", pTrans->id, pCreate->dnodeId);





×








UNCOV

292



  TAOS_CHECK_GOTO(mndSetCreateQnodeRedoLogs(pTrans, &qnodeObj), NULL, _OVER);





×








UNCOV

293



  TAOS_CHECK_GOTO(mndSetCreateQnodeUndoLogs(pTrans, &qnodeObj), NULL, _OVER);





×








UNCOV

294



  TAOS_CHECK_GOTO(mndSetCreateQnodeCommitLogs(pTrans, &qnodeObj), NULL, _OVER);





×








UNCOV

295



  TAOS_CHECK_GOTO(mndSetCreateQnodeRedoActions(pTrans, pDnode, &qnodeObj), NULL, _OVER);





×








UNCOV

296



  TAOS_CHECK_GOTO(mndSetCreateQnodeUndoActions(pTrans, pDnode, &qnodeObj), NULL, _OVER);





×








UNCOV

297



  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);





×







298













UNCOV

299



  code = 0;




×







300













UNCOV

301



_OVER:




×








UNCOV

302



  mndTransDrop(pTrans);




×








UNCOV

303



  TAOS_RETURN(code);




×







304



}










305













UNCOV

306



static int32_t mndProcessCreateQnodeReq(SRpcMsg *pReq) {




×








UNCOV

307



  SMnode          *pMnode = pReq->info.node;




×








UNCOV

308



  int32_t          code = -1;




×








UNCOV

309



  SQnodeObj       *pObj = NULL;




×








UNCOV

310



  SDnodeObj       *pDnode = NULL;




×








UNCOV

311



  SMCreateQnodeReq createReq = {0};




×







312













UNCOV

313



  TAOS_CHECK_GOTO(tDeserializeSCreateDropMQSNodeReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER);





×







314













UNCOV

315



  mInfo("qnode:%d, start to create", createReq.dnodeId);





×








UNCOV

316



  TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_QNODE), NULL, _OVER);





×







317













UNCOV

318



  pObj = mndAcquireQnode(pMnode, createReq.dnodeId);




×








UNCOV

319



  if (pObj != NULL) {





×








UNCOV

320



    code = TSDB_CODE_MND_QNODE_ALREADY_EXIST;




×








UNCOV

321



    goto _OVER;




×








UNCOV

322



  } else if (terrno != TSDB_CODE_MND_QNODE_NOT_EXIST) {





×







323



    goto _OVER;




×







324



  }










325













UNCOV

326



  pDnode = mndAcquireDnode(pMnode, createReq.dnodeId);




×








UNCOV

327



  if (pDnode == NULL) {





×







328



    code = TSDB_CODE_MND_DNODE_NOT_EXIST;




×







329



    goto _OVER;




×







330



  }










331













UNCOV

332



  code = mndCreateQnode(pMnode, pReq, pDnode, &createReq);




×








UNCOV

333



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;





×







334













UNCOV

335



  char obj[33] = {0};




×








UNCOV

336



  (void)tsnprintf(obj, sizeof(obj), "%d", createReq.dnodeId);




×







337













UNCOV

338



  auditRecord(pReq, pMnode->clusterId, "createQnode", "", obj, createReq.sql, createReq.sqlLen);




×








UNCOV

339



_OVER:




×








UNCOV

340



  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {





×








UNCOV

341



    mError("qnode:%d, failed to create since %s", createReq.dnodeId, terrstr());





×







342



  }










343













UNCOV

344



  mndReleaseQnode(pMnode, pObj);




×








UNCOV

345



  mndReleaseDnode(pMnode, pDnode);




×








UNCOV

346



  tFreeSMCreateQnodeReq(&createReq);




×








UNCOV

347



  TAOS_RETURN(code);




×







348



}










349













UNCOV

350



static int32_t mndSetDropQnodeRedoLogs(STrans *pTrans, SQnodeObj *pObj) {




×








UNCOV

351



  int32_t  code = 0;




×








UNCOV

352



  SSdbRaw *pRedoRaw = mndQnodeActionEncode(pObj);




×








UNCOV

353



  if (pRedoRaw == NULL) {





×







354



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







355



    if (terrno != 0) code = terrno;





×







356



    TAOS_RETURN(code);




×







357



  }











UNCOV

358



  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw));





×








UNCOV

359



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));





×








UNCOV

360



  TAOS_RETURN(code);




×







361



}










362













UNCOV

363



static int32_t mndSetDropQnodeCommitLogs(STrans *pTrans, SQnodeObj *pObj) {




×








UNCOV

364



  int32_t  code = 0;




×








UNCOV

365



  SSdbRaw *pCommitRaw = mndQnodeActionEncode(pObj);




×








UNCOV

366



  if (pCommitRaw == NULL) {





×







367



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







368



    if (terrno != 0) code = terrno;





×







369



    TAOS_RETURN(code);




×







370



  }











UNCOV

371



  if (mndTransAppendCommitlog(pTrans, pCommitRaw))




×







372



    ;











UNCOV

373



  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED))




×







374



    ;











UNCOV

375



  TAOS_RETURN(code);




×







376



}










377













UNCOV

378



static int32_t mndSetDropQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQnodeObj *pObj) {




×








UNCOV

379



  int32_t        code = 0;




×








UNCOV

380



  SDDropQnodeReq dropReq = {0};




×








UNCOV

381



  dropReq.dnodeId = pDnode->id;




×







382













UNCOV

383



  int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, &dropReq);




×








UNCOV

384



  void   *pReq = taosMemoryMalloc(contLen);





×








UNCOV

385



  if (pReq == NULL) {





×







386



    code = terrno;




×







387



    TAOS_RETURN(code);




×







388



  }











UNCOV

389



  code = tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq);




×








UNCOV

390



  if (code < 0) {





×







391



    mError("qnode:%d, failed to serialize create drop qnode request since %s", dropReq.dnodeId, terrstr());





×







392



  }










393













UNCOV

394



  STransAction action = {0};




×








UNCOV

395



  action.epSet = mndGetDnodeEpset(pDnode);




×








UNCOV

396



  action.pCont = pReq;




×








UNCOV

397



  action.contLen = contLen;




×








UNCOV

398



  action.msgType = TDMT_DND_DROP_QNODE;




×








UNCOV

399



  action.acceptableCode = TSDB_CODE_QNODE_NOT_DEPLOYED;




×







400













UNCOV

401



  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {





×







402



    taosMemoryFree(pReq);





×







403



    TAOS_RETURN(code);




×







404



  }










405













UNCOV

406



  TAOS_RETURN(code);




×







407



}










408













UNCOV

409



int32_t mndSetDropQnodeInfoToTrans(SMnode *pMnode, STrans *pTrans, SQnodeObj *pObj, bool force) {




×








UNCOV

410



  if (pObj == NULL) return 0;





×








UNCOV

411



  TAOS_CHECK_RETURN(mndSetDropQnodeRedoLogs(pTrans, pObj));





×








UNCOV

412



  TAOS_CHECK_RETURN(mndSetDropQnodeCommitLogs(pTrans, pObj));





×








UNCOV

413



  if (!force) {





×








UNCOV

414



    TAOS_CHECK_RETURN(mndSetDropQnodeRedoActions(pTrans, pObj->pDnode, pObj));





×







415



  }











UNCOV

416



  return 0;




×







417



}










418













UNCOV

419



static int32_t mndDropQnode(SMnode *pMnode, SRpcMsg *pReq, SQnodeObj *pObj) {




×








UNCOV

420



  int32_t code = -1;




×







421













UNCOV

422



  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pReq, "drop-qnode");




×








UNCOV

423



  if (pTrans == NULL) {





×







424



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







425



    if (terrno != 0) code = terrno;





×







426



    goto _OVER;




×







427



  }











UNCOV

428



  mndTransSetSerial(pTrans);




×







429













UNCOV

430



  mInfo("trans:%d, used to drop qnode:%d", pTrans->id, pObj->id);





×








UNCOV

431



  TAOS_CHECK_GOTO(mndSetDropQnodeInfoToTrans(pMnode, pTrans, pObj, false), NULL, _OVER);





×








UNCOV

432



  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);





×







433













UNCOV

434



  code = 0;




×







435













UNCOV

436



_OVER:




×








UNCOV

437



  mndTransDrop(pTrans);




×








UNCOV

438



  TAOS_RETURN(code);




×







439



}










440













UNCOV

441



static int32_t mndProcessDropQnodeReq(SRpcMsg *pReq) {




×








UNCOV

442



  SMnode        *pMnode = pReq->info.node;




×








UNCOV

443



  int32_t        code = -1;




×








UNCOV

444



  SQnodeObj     *pObj = NULL;




×








UNCOV

445



  SMDropQnodeReq dropReq = {0};




×







446













UNCOV

447



  TAOS_CHECK_GOTO(tDeserializeSCreateDropMQSNodeReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER);





×







448













UNCOV

449



  mInfo("qnode:%d, start to drop", dropReq.dnodeId);





×








UNCOV

450



  TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_QNODE), NULL, _OVER);





×







451













UNCOV

452



  if (dropReq.dnodeId <= 0) {





×







453



    code = TSDB_CODE_INVALID_MSG;




×







454



    goto _OVER;




×







455



  }










456













UNCOV

457



  pObj = mndAcquireQnode(pMnode, dropReq.dnodeId);




×








UNCOV

458



  if (pObj == NULL) {





×








UNCOV

459



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

460



    if (terrno != 0) code = terrno;





×








UNCOV

461



    goto _OVER;




×







462



  }










463













UNCOV

464



  code = mndDropQnode(pMnode, pReq, pObj);




×








UNCOV

465



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;





×







466













UNCOV

467



  char obj[33] = {0};




×








UNCOV

468



  (void)tsnprintf(obj, sizeof(obj), "%d", dropReq.dnodeId);




×







469













UNCOV

470



  auditRecord(pReq, pMnode->clusterId, "dropQnode", "", obj, dropReq.sql, dropReq.sqlLen);




×







471













UNCOV

472



_OVER:




×








UNCOV

473



  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {





×








UNCOV

474



    mError("qnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr());





×







475



  }










476













UNCOV

477



  mndReleaseQnode(pMnode, pObj);




×








UNCOV

478



  tFreeSDDropQnodeReq(&dropReq);




×








UNCOV

479



  TAOS_RETURN(code);




×







480



}










481













UNCOV

482



int32_t mndCreateQnodeList(SMnode *pMnode, SArray **pList, int32_t limit) {




×








UNCOV

483



  int32_t    code = 0;




×








UNCOV

484



  SSdb      *pSdb = pMnode->pSdb;




×








UNCOV

485



  void      *pIter = NULL;




×








UNCOV

486



  SQnodeObj *pObj = NULL;




×








UNCOV

487



  int32_t    numOfRows = 0;




×







488













UNCOV

489



  SArray *qnodeList = taosArrayInit(5, sizeof(SQueryNodeLoad));




×








UNCOV

490



  if (NULL == qnodeList) {





×







491



    mError("failed to alloc epSet while process qnode list req");





×







492



    code = terrno;




×







493



    TAOS_RETURN(code);




×







494



  }










495













UNCOV

496



  while (1) {




×








UNCOV

497



    pIter = sdbFetch(pSdb, SDB_QNODE, pIter, (void **)&pObj);




×








UNCOV

498



    if (pIter == NULL) break;





×







499













UNCOV

500



    SQueryNodeLoad nodeLoad = {0};




×








UNCOV

501



    nodeLoad.addr.nodeId = QNODE_HANDLE;




×








UNCOV

502



    nodeLoad.addr.epSet.numOfEps = 1;




×








UNCOV

503



    tstrncpy(nodeLoad.addr.epSet.eps[0].fqdn, pObj->pDnode->fqdn, TSDB_FQDN_LEN);




×








UNCOV

504



    nodeLoad.addr.epSet.eps[0].port = pObj->pDnode->port;




×








UNCOV

505



    nodeLoad.load = QNODE_LOAD_VALUE(pObj);





×







506













UNCOV

507



    if (taosArrayPush(qnodeList, &nodeLoad) == NULL) {





×







508



      sdbRelease(pSdb, pObj);




×







509



      sdbCancelFetch(pSdb, pIter);




×







510



      if (terrno != 0) code = terrno;





×







511



      return code;




×







512



    }










513













UNCOV

514



    numOfRows++;




×








UNCOV

515



    sdbRelease(pSdb, pObj);




×







516













UNCOV

517



    if (limit > 0 && numOfRows >= limit) {





×







518



      sdbCancelFetch(pSdb, pIter);




×







519



      break;




×







520



    }










521



  }










522













UNCOV

523



  *pList = qnodeList;




×







524













UNCOV

525



  return TSDB_CODE_SUCCESS;




×







526



}










527













UNCOV

528



static int32_t mndProcessQnodeListReq(SRpcMsg *pReq) {




×








UNCOV

529



  int32_t       code = -1;




×








UNCOV

530



  SMnode       *pMnode = pReq->info.node;




×








UNCOV

531



  SQnodeListReq qlistReq = {0};




×








UNCOV

532



  SQnodeListRsp qlistRsp = {0};




×







533













UNCOV

534



  TAOS_CHECK_GOTO(tDeserializeSQnodeListReq(pReq->pCont, pReq->contLen, &qlistReq), NULL, _OVER);





×







535













UNCOV

536



  TAOS_CHECK_GOTO(mndCreateQnodeList(pMnode, &qlistRsp.qnodeList, qlistReq.rowNum), NULL, _OVER);





×







537













UNCOV

538



  int32_t rspLen = tSerializeSQnodeListRsp(NULL, 0, &qlistRsp);




×








UNCOV

539



  void   *pRsp = rpcMallocCont(rspLen);




×








UNCOV

540



  if (pRsp == NULL) {





×







541



    code = terrno;




×







542



    goto _OVER;




×







543



  }










544













UNCOV

545



  code = tSerializeSQnodeListRsp(pRsp, rspLen, &qlistRsp);




×








UNCOV

546



  if (code < 0) {





×







547



    mError("failed to serialize qnode list response since %s", terrstr());





×







548



  }










549













UNCOV

550



  pReq->info.rspLen = rspLen;




×








UNCOV

551



  pReq->info.rsp = pRsp;




×








UNCOV

552



  code = 0;




×







553













UNCOV

554



_OVER:




×








UNCOV

555



  tFreeSQnodeListRsp(&qlistRsp);




×








UNCOV

556



  TAOS_RETURN(code);




×







557



}










558













UNCOV

559



static int32_t mndRetrieveQnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {




×








UNCOV

560



  SMnode    *pMnode = pReq->info.node;




×








UNCOV

561



  SSdb      *pSdb = pMnode->pSdb;




×








UNCOV

562



  int32_t    numOfRows = 0;




×








UNCOV

563



  int32_t    cols = 0;




×








UNCOV

564



  SQnodeObj *pObj = NULL;




×







565



  char      *pWrite;










566













UNCOV

567



  while (numOfRows < rows) {





×








UNCOV

568



    pShow->pIter = sdbFetch(pSdb, SDB_QNODE, pShow->pIter, (void **)&pObj);




×








UNCOV

569



    if (pShow->pIter == NULL) break;





×







570













UNCOV

571



    cols = 0;




×








UNCOV

572



    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




×








UNCOV

573



    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false), pSdb, pObj);





×







574













UNCOV

575



    char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0};




×








UNCOV

576



    STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->pMeta->pSchemas[cols].bytes);




×








UNCOV

577



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




×








UNCOV

578



    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)ep, false), pSdb, pObj);





×







579













UNCOV

580



    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);




×








UNCOV

581



    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false), pSdb,





×







582



                                   pObj);










583













UNCOV

584



    numOfRows++;




×








UNCOV

585



    sdbRelease(pSdb, pObj);




×







586



  }










587













UNCOV

588



  pShow->numOfRows += numOfRows;




×







589













UNCOV

590



  return numOfRows;




×







591



}










592












593



static void mndCancelGetNextQnode(SMnode *pMnode, void *pIter) {




×







594



  SSdb *pSdb = pMnode->pSdb;




×







595



  sdbCancelFetchByType(pSdb, pIter, SDB_QNODE);




×







596



}




×





















    

  • 

    •