taosdata / TDengine / #4829

coverage: 49.734% (-11.3%) from 61.071%
#4829

push

travis-ci

web-flow 
Merge pull request #33435 from taosdata/3.0

merge 3.0

123072 of 323930 branches covered (37.99%)

Branch coverage included in aggregate %.

7 of 25 new or added lines in 3 files covered. (28.0%)

35232 existing lines in 327 files now uncovered.

172062 of 269495 relevant lines covered (63.85%)

70709785.06 hits per line

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

3.23
/source/dnode/mnode/impl/src/mndBnode.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 "mndBnode.h"










18



#include "mndDnode.h"










19



#include "mndPrivilege.h"










20



#include "mndShow.h"










21



#include "mndTrans.h"










22



#include "mndUser.h"










23












24



#define BNODE_VER_NUMBER   1










25



#define BNODE_RESERVE_SIZE 64










26













UNCOV

27



static SSdbRaw *mndBnodeActionEncode(SBnodeObj *pObj) {




×








UNCOV

28



  int32_t code = 0;




×








UNCOV

29



  int32_t lino = 0;




×







30













UNCOV

31



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×







32













UNCOV

33



  SSdbRaw *pRaw = sdbAllocRaw(SDB_BNODE, BNODE_VER_NUMBER, sizeof(SBnodeObj) + BNODE_RESERVE_SIZE);




×








UNCOV

34



  if (pRaw == NULL) goto _OVER;





×







35













UNCOV

36



  int32_t dataPos = 0;




×








UNCOV

37



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





×








UNCOV

38



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





×








UNCOV

39



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





×








UNCOV

40



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





×








UNCOV

41



  SDB_SET_RESERVE(pRaw, dataPos, BNODE_RESERVE_SIZE, _OVER)





×







42













UNCOV

43



  terrno = 0;




×







44













UNCOV

45



_OVER:




×








UNCOV

46



  if (terrno != 0) {





×







47



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





×







48



    sdbFreeRaw(pRaw);




×







49



    return NULL;




×







50



  }










51













UNCOV

52



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





×








UNCOV

53



  return pRaw;




×







54



}










55













UNCOV

56



static SSdbRow *mndBnodeActionDecode(SSdbRaw *pRaw) {




×








UNCOV

57



  int32_t    code = 0;




×








UNCOV

58



  int32_t    lino = 0;




×








UNCOV

59



  SSdbRow   *pRow = NULL;




×








UNCOV

60



  SBnodeObj *pObj = NULL;




×








UNCOV

61



  int8_t     sver = 0;




×







62













UNCOV

63



  terrno = TSDB_CODE_OUT_OF_MEMORY;




×







64













UNCOV

65



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





×







66













UNCOV

67



  if (sver != BNODE_VER_NUMBER) {





×







68



    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;




×







69



    goto _OVER;




×







70



  }










71













UNCOV

72



  pRow = sdbAllocRow(sizeof(SBnodeObj));




×








UNCOV

73



  if (pRow == NULL) goto _OVER;





×







74













UNCOV

75



  pObj = sdbGetRowObj(pRow);




×








UNCOV

76



  if (pObj == NULL) goto _OVER;





×







77













UNCOV

78



  int32_t dataPos = 0;




×








UNCOV

79



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





×








UNCOV

80



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





×








UNCOV

81



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





×








UNCOV

82



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





×








UNCOV

83



  SDB_GET_RESERVE(pRaw, dataPos, BNODE_RESERVE_SIZE, _OVER)





×







84













UNCOV

85



  terrno = 0;




×







86













UNCOV

87



_OVER:




×








UNCOV

88



  if (terrno != 0) {





×







89



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





×







90



    taosMemoryFreeClear(pRow);





×







91



    return NULL;




×







92



  }










93













UNCOV

94



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





×








UNCOV

95



  return pRow;




×







96



}










97













UNCOV

98



static int32_t mndBnodeActionInsert(SSdb *pSdb, SBnodeObj *pObj) {




×








UNCOV

99



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





×








UNCOV

100



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




×








UNCOV

101



  if (pObj->pDnode == NULL) {





×







102



    terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;




×







103



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





×







104



    return -1;




×







105



  }










106













UNCOV

107



  return 0;




×







108



}










109













UNCOV

110



static int32_t mndBnodeActionDelete(SSdb *pSdb, SBnodeObj *pObj) {




×








UNCOV

111



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





×








UNCOV

112



  if (pObj->pDnode != NULL) {





×








UNCOV

113



    sdbRelease(pSdb, pObj->pDnode);




×








UNCOV

114



    pObj->pDnode = NULL;




×







115



  }










116













UNCOV

117



  return 0;




×







118



}










119













UNCOV

120



static int32_t mndBnodeActionUpdate(SSdb *pSdb, SBnodeObj *pOld, SBnodeObj *pNew) {




×








UNCOV

121



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





×








UNCOV

122



  pOld->updateTime = pNew->updateTime;




×








UNCOV

123



  return 0;




×







124



}










125













UNCOV

126



static int32_t mndSetCreateBnodeRedoLogs(STrans *pTrans, SBnodeObj *pObj) {




×








UNCOV

127



  int32_t  code = 0;




×








UNCOV

128



  SSdbRaw *pRedoRaw = mndBnodeActionEncode(pObj);




×








UNCOV

129



  if (pRedoRaw == NULL) {





×







130



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







131



    if (terrno != 0) code = terrno;





×







132



    TAOS_RETURN(code);




×







133



  }











UNCOV

134



  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw));





×








UNCOV

135



  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING));





×








UNCOV

136



  TAOS_RETURN(code);




×







137



}










138













UNCOV

139



static int32_t mndSetCreateBnodeUndoLogs(STrans *pTrans, SBnodeObj *pObj) {




×








UNCOV

140



  int32_t  code = 0;




×








UNCOV

141



  SSdbRaw *pUndoRaw = mndBnodeActionEncode(pObj);




×








UNCOV

142



  if (pUndoRaw == NULL) {





×







143



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







144



    if (terrno != 0) code = terrno;





×







145



    TAOS_RETURN(code);




×







146



  }











UNCOV

147



  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pUndoRaw));





×








UNCOV

148



  TAOS_CHECK_RETURN(sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED));





×








UNCOV

149



  TAOS_RETURN(code);




×







150



}










151













UNCOV

152



static int32_t mndSetCreateBnodeCommitLogs(STrans *pTrans, SBnodeObj *pObj) {




×








UNCOV

153



  int32_t  code = 0;




×








UNCOV

154



  SSdbRaw *pCommitRaw = mndBnodeActionEncode(pObj);




×








UNCOV

155



  if (pCommitRaw == NULL) {





×







156



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







157



    if (terrno != 0) code = terrno;





×







158



    TAOS_RETURN(code);




×







159



  }











UNCOV

160



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));





×








UNCOV

161



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));





×








UNCOV

162



  TAOS_RETURN(code);




×







163



}










164













UNCOV

165



static int32_t mndSetCreateBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBnodeObj *pObj) {




×








UNCOV

166



  int32_t          code = 0;




×








UNCOV

167



  SDCreateBnodeReq createReq = {0};




×








UNCOV

168



  createReq.dnodeId = pDnode->id;




×








UNCOV

169



  createReq.bnodeProto = pObj->proto;




×







170













UNCOV

171



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




×








UNCOV

172



  void   *pReq = taosMemoryMalloc(contLen);





×








UNCOV

173



  if (pReq == NULL) {





×







174



    code = terrno;




×







175



    TAOS_RETURN(code);




×







176



  }











UNCOV

177



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




×








UNCOV

178



  if (code < 0) {





×







179



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





×







180












181



    taosMemoryFree(pReq);





×







182



    TAOS_RETURN(code);




×







183



  }










184













UNCOV

185



  STransAction action = {0};




×








UNCOV

186



  action.epSet = mndGetDnodeEpset(pDnode);




×








UNCOV

187



  action.pCont = pReq;




×








UNCOV

188



  action.contLen = contLen;




×








UNCOV

189



  action.msgType = TDMT_DND_CREATE_BNODE;




×








UNCOV

190



  action.acceptableCode = TSDB_CODE_BNODE_ALREADY_DEPLOYED;




×







191













UNCOV

192



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





×







193



    taosMemoryFree(pReq);





×







194



    TAOS_RETURN(code);




×







195



  }










196













UNCOV

197



  TAOS_RETURN(code);




×







198



}










199













UNCOV

200



static int32_t mndSetCreateBnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, SBnodeObj *pObj) {




×








UNCOV

201



  int32_t        code = 0;




×








UNCOV

202



  SDDropBnodeReq dropReq = {0};




×








UNCOV

203



  dropReq.dnodeId = pDnode->id;




×







204













UNCOV

205



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




×








UNCOV

206



  void   *pReq = taosMemoryMalloc(contLen);





×








UNCOV

207



  if (pReq == NULL) {





×







208



    code = terrno;




×







209



    TAOS_RETURN(code);




×







210



  }











UNCOV

211



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




×








UNCOV

212



  if (code < 0) {





×







213



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





×







214



  }










215













UNCOV

216



  STransAction action = {0};




×








UNCOV

217



  action.epSet = mndGetDnodeEpset(pDnode);




×








UNCOV

218



  action.pCont = pReq;




×








UNCOV

219



  action.contLen = contLen;




×








UNCOV

220



  action.msgType = TDMT_DND_DROP_BNODE;




×








UNCOV

221



  action.acceptableCode = TSDB_CODE_BNODE_NOT_DEPLOYED;




×







222













UNCOV

223



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





×







224



    taosMemoryFree(pReq);





×







225



    TAOS_RETURN(code);




×







226



  }










227













UNCOV

228



  TAOS_RETURN(code);




×







229



}










230













UNCOV

231



static int32_t mndCreateBnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMCreateBnodeReq *pCreate) {




×








UNCOV

232



  int32_t code = -1;




×







233













UNCOV

234



  SBnodeObj bnodeObj = {0};




×








UNCOV

235



  bnodeObj.id = pDnode->id;




×








UNCOV

236



  bnodeObj.proto = pCreate->bnodeProto;




×








UNCOV

237



  bnodeObj.createdTime = taosGetTimestampMs();




×








UNCOV

238



  bnodeObj.updateTime = bnodeObj.createdTime;




×







239













UNCOV

240



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




×








UNCOV

241



  if (pTrans == NULL) {





×







242



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







243



    if (terrno != 0) code = terrno;





×







244



    goto _OVER;




×







245



  }











UNCOV

246



  mndTransSetSerial(pTrans);




×







247













UNCOV

248



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





×







249













UNCOV

250



  TAOS_CHECK_GOTO(mndSetCreateBnodeRedoLogs(pTrans, &bnodeObj), NULL, _OVER);





×








UNCOV

251



  TAOS_CHECK_GOTO(mndSetCreateBnodeUndoLogs(pTrans, &bnodeObj), NULL, _OVER);





×








UNCOV

252



  TAOS_CHECK_GOTO(mndSetCreateBnodeCommitLogs(pTrans, &bnodeObj), NULL, _OVER);





×








UNCOV

253



  TAOS_CHECK_GOTO(mndSetCreateBnodeRedoActions(pTrans, pDnode, &bnodeObj), NULL, _OVER);





×








UNCOV

254



  TAOS_CHECK_GOTO(mndSetCreateBnodeUndoActions(pTrans, pDnode, &bnodeObj), NULL, _OVER);





×








UNCOV

255



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





×







256













UNCOV

257



  code = 0;




×







258













UNCOV

259



_OVER:




×








UNCOV

260



  mndTransDrop(pTrans);




×








UNCOV

261



  TAOS_RETURN(code);




×







262



}










263













UNCOV

264



static int32_t mndProcessCreateBnodeReq(SRpcMsg *pReq) {




×








UNCOV

265



  SMnode          *pMnode = pReq->info.node;




×








UNCOV

266



  int32_t          code = -1;




×








UNCOV

267



  SBnodeObj       *pObj = NULL;




×








UNCOV

268



  SDnodeObj       *pDnode = NULL;




×








UNCOV

269



  SMCreateBnodeReq createReq = {0};




×







270












271



  #ifdef LINUX










272













UNCOV

273



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





×







274













UNCOV

275



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





×








UNCOV

276



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





×







277













UNCOV

278



  pObj = mndAcquireBnode(pMnode, createReq.dnodeId);




×








UNCOV

279



  if (pObj != NULL) {





×







280



    code = terrno = TSDB_CODE_MND_BNODE_ALREADY_EXIST;




×







281



    goto _OVER;




×








UNCOV

282



  } else if (terrno != TSDB_CODE_MND_BNODE_NOT_EXIST) {





×







283



    code = terrno;




×







284



    goto _OVER;




×







285



  }










286













UNCOV

287



  pDnode = mndAcquireDnode(pMnode, createReq.dnodeId);




×








UNCOV

288



  if (pDnode == NULL) {





×








UNCOV

289



    code = TSDB_CODE_MND_DNODE_NOT_EXIST;




×








UNCOV

290



    goto _OVER;




×







291



  }










292













UNCOV

293



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




×








UNCOV

294



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;





×







295













UNCOV

296



_OVER:




×








UNCOV

297



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





×








UNCOV

298



    mError("bnode:%d, failed to create since %s", createReq.dnodeId, tstrerror(code));





×








UNCOV

299



    TAOS_RETURN(code);




×







300



  }










301












302



  //  mndReleaseBnode(pMnode, pObj);











UNCOV

303



  mndReleaseDnode(pMnode, pDnode);




×








UNCOV

304



  tFreeSMCreateBnodeReq(&createReq);




×







305












306



  #else










307












308



  code = TSDB_CODE_OPS_NOT_SUPPORT;










309












310



  #endif










311













UNCOV

312



  TAOS_RETURN(code);




×







313



}










314













UNCOV

315



static int32_t mndSetDropBnodeRedoLogs(STrans *pTrans, SBnodeObj *pObj) {




×








UNCOV

316



  int32_t code = 0, lino = 0;




×







317













UNCOV

318



  SSdbRaw *pRedoRaw = mndBnodeActionEncode(pObj);




×








UNCOV

319



  if (pRedoRaw == NULL) {





×







320



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







321



    if (terrno != 0) code = terrno;





×







322



    TAOS_RETURN(code);




×







323



  }











UNCOV

324



  TAOS_CHECK_GOTO(mndTransAppendGroupRedolog(pTrans, pRedoRaw, -1), &lino, _OVER);





×








UNCOV

325



  TAOS_CHECK_GOTO(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING), &lino, _OVER);





×







326













UNCOV

327



_OVER:




×








UNCOV

328



  if (code != 0) {





×







329



    mError("bnode:%d, failed to drop bnode at line:%d since %s", pObj->id, lino, tstrerror(code));





×







330



  }










331













UNCOV

332



  TAOS_RETURN(code);




×







333



}










334













UNCOV

335



static int32_t mndSetDropBnodeCommitLogs(STrans *pTrans, SBnodeObj *pObj) {




×








UNCOV

336



  int32_t  code = 0;




×








UNCOV

337



  SSdbRaw *pCommitRaw = mndBnodeActionEncode(pObj);




×








UNCOV

338



  if (pCommitRaw == NULL) {





×







339



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







340



    if (terrno != 0) code = terrno;





×







341



    TAOS_RETURN(code);




×







342



  }











UNCOV

343



  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));





×








UNCOV

344



  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));





×








UNCOV

345



  TAOS_RETURN(code);




×







346



}










347













UNCOV

348



static int32_t mndSetDropBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBnodeObj *pObj) {




×








UNCOV

349



  int32_t        code = 0;




×








UNCOV

350



  SDDropBnodeReq dropReq = {0};




×








UNCOV

351



  dropReq.dnodeId = pDnode->id;




×







352













UNCOV

353



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




×








UNCOV

354



  void   *pReq = taosMemoryMalloc(contLen);





×








UNCOV

355



  if (pReq == NULL) {





×







356



    code = terrno;




×







357



    TAOS_RETURN(code);




×







358



  }











UNCOV

359



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




×








UNCOV

360



  if (code < 0) {





×







361



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





×







362



  }










363













UNCOV

364



  STransAction action = {0};




×








UNCOV

365



  action.epSet = mndGetDnodeEpset(pDnode);




×








UNCOV

366



  action.pCont = pReq;




×








UNCOV

367



  action.contLen = contLen;




×








UNCOV

368



  action.msgType = TDMT_DND_DROP_BNODE;




×








UNCOV

369



  action.acceptableCode = TSDB_CODE_BNODE_NOT_DEPLOYED;




×







370













UNCOV

371



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





×








UNCOV

372



    taosMemoryFree(pReq);





×








UNCOV

373



    TAOS_RETURN(code);




×







374



  }










375













UNCOV

376



  TAOS_RETURN(code);




×







377



}










378













UNCOV

379



int32_t mndSetDropBnodeInfoToTrans(SMnode *pMnode, STrans *pTrans, SBnodeObj *pObj, bool force) {




×








UNCOV

380



  int32_t code = -1, lino = 0;




×







381













UNCOV

382



  if (pObj == NULL) return 0;





×








UNCOV

383



  TAOS_CHECK_GOTO(mndSetDropBnodeRedoLogs(pTrans, pObj), &lino, _OVER);





×








UNCOV

384



  TAOS_CHECK_GOTO(mndSetDropBnodeCommitLogs(pTrans, pObj), &lino, _OVER);





×








UNCOV

385



  if (!force) {





×








UNCOV

386



    TAOS_CHECK_GOTO(mndSetDropBnodeRedoActions(pTrans, pObj->pDnode, pObj), &lino, _OVER);





×







387



  }










388













UNCOV

389



_OVER:




×








UNCOV

390



  if (code != 0) {





×








UNCOV

391



    mError("bnode:%d, failed to drop bnode at line:%d since %s", pObj->id, lino, tstrerror(code));





×







392



  }










393













UNCOV

394



  return code;




×







395



}










396













UNCOV

397



static int32_t mndDropBnode(SMnode *pMnode, SRpcMsg *pReq, SBnodeObj *pObj) {




×








UNCOV

398



  int32_t code = -1;




×







399













UNCOV

400



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




×








UNCOV

401



  if (pTrans == NULL) {





×







402



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×







403



    if (terrno != 0) code = terrno;





×







404



    goto _OVER;




×







405



  }











UNCOV

406



  mndTransSetSerial(pTrans);




×







407













UNCOV

408



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





×








UNCOV

409



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





×








UNCOV

410



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





×







411













UNCOV

412



  code = 0;




×







413













UNCOV

414



_OVER:




×








UNCOV

415



  mndTransDrop(pTrans);




×








UNCOV

416



  TAOS_RETURN(code);




×







417



}










418













UNCOV

419



static int32_t mndProcessDropBnodeReq(SRpcMsg *pReq) {




×








UNCOV

420



  SMnode        *pMnode = pReq->info.node;




×








UNCOV

421



  int32_t        code = -1;




×








UNCOV

422



  SBnodeObj     *pObj = NULL;




×








UNCOV

423



  SDnodeObj     *pDnode = NULL;




×








UNCOV

424



  SMDropBnodeReq dropReq = {0};




×







425













UNCOV

426



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





×







427













UNCOV

428



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





×








UNCOV

429



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





×







430













UNCOV

431



  if (dropReq.dnodeId <= 0) {





×








UNCOV

432



    code = TSDB_CODE_INVALID_MSG;




×








UNCOV

433



    goto _OVER;




×







434



  }










435













UNCOV

436



  pDnode = mndAcquireDnode(pMnode, dropReq.dnodeId);




×








UNCOV

437



  if (pDnode == NULL) {





×








UNCOV

438



    code = TSDB_CODE_MND_DNODE_NOT_EXIST;




×








UNCOV

439



    goto _OVER;




×







440



  }










441













UNCOV

442



  if (!mndIsDnodeOnline(pDnode, taosGetTimestampMs())) {





×








UNCOV

443



    code = TSDB_CODE_DNODE_OFFLINE;




×








UNCOV

444



    goto _OVER;




×







445



  }










446













UNCOV

447



  pObj = mndAcquireBnode(pMnode, dropReq.dnodeId);




×








UNCOV

448



  if (pObj == NULL) {





×








UNCOV

449



    code = TSDB_CODE_MND_RETURN_VALUE_NULL;




×








UNCOV

450



    if (terrno != 0) code = terrno;





×








UNCOV

451



    goto _OVER;




×







452



  }










453












454



  // check deletable











UNCOV

455



  code = mndDropBnode(pMnode, pReq, pObj);




×








UNCOV

456



  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;





×







457













UNCOV

458



_OVER:




×








UNCOV

459



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





×








UNCOV

460



    mError("bnode:%d, failed to drop since %s", dropReq.dnodeId, tstrerror(code));





×







461



  }










462













UNCOV

463



  mndReleaseBnode(pMnode, pObj);




×








UNCOV

464



  mndReleaseDnode(pMnode, pDnode);




×








UNCOV

465



  tFreeSMDropBnodeReq(&dropReq);




×








UNCOV

466



  TAOS_RETURN(code);




×







467



}










468













UNCOV

469



static const char *mndBnodeProtoStr(int32_t proto) {




×








UNCOV

470



  switch (proto) {





×








UNCOV

471



    case TSDB_BNODE_OPT_PROTO_MQTT:




×








UNCOV

472



      return TSDB_BNODE_OPT_PROTO_STR_MQTT;




×







473



    default:




×







474



      break;




×







475



  }










476



  return "unknown";




×







477



}










478













UNCOV

479



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




×








UNCOV

480



  SMnode    *pMnode = pReq->info.node;




×








UNCOV

481



  SSdb      *pSdb = pMnode->pSdb;




×








UNCOV

482



  int32_t    numOfRows = 0;




×








UNCOV

483



  int32_t    cols = 0;




×








UNCOV

484



  SBnodeObj *pObj = NULL;




×








UNCOV

485



  char       buf[TSDB_EP_LEN + VARSTR_HEADER_SIZE];




×







486













UNCOV

487



  while (numOfRows < rows) {





×








UNCOV

488



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




×








UNCOV

489



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





×







490













UNCOV

491



    cols = 0;




×








UNCOV

492



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




×








UNCOV

493



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





×







494













UNCOV

495



    char mqtt_ep[TSDB_EP_LEN] = {0};




×








UNCOV

496



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




×







497













UNCOV

498



    TAOS_UNUSED(tsnprintf(mqtt_ep, TSDB_EP_LEN - 1, "%s:%hu", pObj->pDnode->fqdn, tsMqttPort));




×








UNCOV

499



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





×







500













UNCOV

501



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




×








UNCOV

502



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





×







503













UNCOV

504



    STR_TO_VARSTR(buf, mndBnodeProtoStr(pObj->proto));





×








UNCOV

505



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




×








UNCOV

506



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





×







507













UNCOV

508



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




×








UNCOV

509



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





×







510



                                   pObj);










511













UNCOV

512



    numOfRows++;




×








UNCOV

513



    sdbRelease(pSdb, pObj);




×







514



  }










515













UNCOV

516



  pShow->numOfRows += numOfRows;




×







517













UNCOV

518



  return numOfRows;




×







519



}










520












521



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




×







522



  SSdb *pSdb = pMnode->pSdb;




×







523



  sdbCancelFetchByType(pSdb, pIter, SDB_BNODE);




×







524



}




×







525












526



SEpSet mndAcquireEpFromBnode(SMnode *pMnode, const SBnodeObj *pBnode) {




×







527



  SEpSet epSet = {.numOfEps = 1, .inUse = 0};




×







528



  memcpy(epSet.eps[0].fqdn, pBnode->pDnode->fqdn, TSDB_FQDN_LEN);




×







529



  epSet.eps[0].port = pBnode->pDnode->port;




×







530



  return epSet;




×







531



}










532












533



SBnodeObj *mndAcquireBnode(SMnode *pMnode, int32_t dnodeId) {




561✔





534



  SBnodeObj *pObj = sdbAcquire(pMnode->pSdb, SDB_BNODE, &dnodeId);




561✔





535



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





561!





536



    terrno = TSDB_CODE_MND_BNODE_NOT_EXIST;




561✔





537



  }










538



  return pObj;




561✔





539



}










540












541



void mndReleaseBnode(SMnode *pMnode, SBnodeObj *pObj) {




561✔





542



  SSdb *pSdb = pMnode->pSdb;




561✔





543



  sdbRelease(pSdb, pObj);




561✔





544



}




561✔





545












546



int32_t mndInitBnode(SMnode *pMnode) {




122,179✔





547



  SSdbTable table = {




122,179✔





548



      .sdbType = SDB_BNODE,










549



      .keyType = SDB_KEY_INT32,










550



      .encodeFp = (SdbEncodeFp)mndBnodeActionEncode,










551



      .decodeFp = (SdbDecodeFp)mndBnodeActionDecode,










552



      .insertFp = (SdbInsertFp)mndBnodeActionInsert,










553



      .updateFp = (SdbUpdateFp)mndBnodeActionUpdate,










554



      .deleteFp = (SdbDeleteFp)mndBnodeActionDelete,










555



  };










556












557



  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_BNODE, mndProcessCreateBnodeReq);




122,179✔





558



  mndSetMsgHandle(pMnode, TDMT_MND_DROP_BNODE, mndProcessDropBnodeReq);




122,179✔





559



  mndSetMsgHandle(pMnode, TDMT_DND_CREATE_BNODE_RSP, mndTransProcessRsp);




122,179✔





560



  mndSetMsgHandle(pMnode, TDMT_DND_DROP_BNODE_RSP, mndTransProcessRsp);




122,179✔





561












562



  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_BNODE, mndRetrieveBnodes);




122,179✔





563



  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_BNODE, mndCancelGetNextBnode);




122,179✔





564












565



  return sdbSetTable(pMnode->pSdb, table);




122,179✔





566



}










567












568



void mndCleanupBnode(SMnode *pMnode) {}




122,109✔



















    

  • 

    •