taosdata/TDengine | Build 3798 | source/dnode/mnode/impl/src/mndSubscribe.c | Coveralls

45

static int32_t mndSetSubCommitLogs(STrans *pTrans, SMqSubscribeObj *pSub) {

×

46

  if (pTrans == NULL || pSub == NULL) {

×

47

    return TSDB_CODE_INVALID_PARA;

×

49

  int32_t  code = 0;

×

50

  SSdbRaw *pCommitRaw = mndSubActionEncode(pSub);

×

51

  MND_TMQ_NULL_CHECK(pCommitRaw);

×

52

  code = mndTransAppendCommitlog(pTrans, pCommitRaw);

×

53

  if (code != 0) {

×

54

    sdbFreeRaw(pCommitRaw);

×

55

    goto END;

×

57

  code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);

×

59

END:

×

60

  return code;

×

63

int32_t mndInitSubscribe(SMnode *pMnode) {

×

64

  SSdbTable table = {

×

74

  if (pMnode == NULL) {

×

75

    return TSDB_CODE_INVALID_PARA;

×

77

  mndSetMsgHandle(pMnode, TDMT_VND_TMQ_SUBSCRIBE_RSP, mndTransProcessRsp);

×

78

  mndSetMsgHandle(pMnode, TDMT_VND_TMQ_DELETE_SUB_RSP, mndTransProcessRsp);

×

79

  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_TIMER, mndProcessRebalanceReq);

×

80

  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_DROP_CGROUP, mndProcessDropCgroupReq);

×

81

  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_DROP_CGROUP_RSP, mndTransProcessRsp);

×

83

  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_SUBSCRIPTIONS, mndRetrieveSubscribe);

×

84

  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_TOPICS, mndCancelGetNextSubscribe);

×

86

  return sdbSetTable(pMnode->pSdb, table);

×

89

static int32_t mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *subKey, SMqSubscribeObj** pSub) {

×

90

  if(pMnode == NULL || pTopic == NULL || subKey == NULL || pSub == NULL) {

×

91

    return TSDB_CODE_INVALID_PARA;

×

93

  int32_t code = 0;

×

94

  MND_TMQ_RETURN_CHECK(tNewSubscribeObj(subKey, pSub));

×

95

  (*pSub)->dbUid = pTopic->dbUid;

×

96

  (*pSub)->stbUid = pTopic->stbUid;

×

97

  (*pSub)->subType = pTopic->subType;

×

98

  (*pSub)->withMeta = pTopic->withMeta;

×

100

  MND_TMQ_RETURN_CHECK(mndSchedInitSubEp(pMnode, pTopic, *pSub));

×

101

  return code;

×

103

END:

×

104

  tDeleteSubscribeObj(*pSub);

×

105

  taosMemoryFree(*pSub);

×

106

  return code;

×

109

static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg,

×

111

  if (pSub == NULL || pRebVg == NULL || pBuf == NULL || pLen == NULL) {

×

112

    return TSDB_CODE_INVALID_PARA;

×

114

  SMqRebVgReq req = {0};

×

115

  int32_t     code = 0;

×

116

  SEncoder encoder = {0};

×

118

  req.oldConsumerId = pRebVg->oldConsumerId;

×

119

  req.newConsumerId = pRebVg->newConsumerId;

×

120

  req.vgId = pRebVg->pVgEp->vgId;

×

121

  if (pPlan) {

×

122

    pPlan->execNode.epSet = pRebVg->pVgEp->epSet;

×

123

    pPlan->execNode.nodeId = pRebVg->pVgEp->vgId;

×

124

    int32_t msgLen = 0;

×

125

    MND_TMQ_RETURN_CHECK(qSubPlanToString(pPlan, &req.qmsg, &msgLen));

×

127

    req.qmsg = taosStrdup("");

×

128

    MND_TMQ_NULL_CHECK(req.qmsg);

×

130

  req.subType = pSub->subType;

×

131

  req.withMeta = pSub->withMeta;

×

132

  req.suid = pSub->stbUid;

×

133

  tstrncpy(req.subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);

×

135

  int32_t tlen = 0;

×

136

  tEncodeSize(tEncodeSMqRebVgReq, &req, tlen, code);

×

137

  if (code < 0) {

×

138

    goto END;

×

141

  tlen += sizeof(SMsgHead);

×

142

  void *buf = taosMemoryMalloc(tlen);

×

143

  MND_TMQ_NULL_CHECK(buf);

×

144

  SMsgHead *pMsgHead = (SMsgHead *)buf;

×

145

  pMsgHead->contLen = htonl(tlen);

×

146

  pMsgHead->vgId = htonl(pRebVg->pVgEp->vgId);

×

148

  tEncoderInit(&encoder, POINTER_SHIFT(buf, sizeof(SMsgHead)), tlen);

×

149

  MND_TMQ_RETURN_CHECK(tEncodeSMqRebVgReq(&encoder, &req));

×

150

  *pBuf = buf;

×

151

  *pLen = tlen;

×

153

END:

×

154

  tEncoderClear(&encoder);

×

155

  taosMemoryFree(req.qmsg);

×

156

  return code;

×

159

static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub,

×

161

  if (pMnode == NULL || pTrans == NULL || pSub == NULL || pRebVg == NULL) {

×

162

    return TSDB_CODE_INVALID_PARA;

×

164

  int32_t code = 0;

×

165

  void   *buf  = NULL;

×

167

  if (pRebVg->oldConsumerId == pRebVg->newConsumerId) {

×

168

    if (pRebVg->oldConsumerId == -1) return 0;  // drop stream, no consumer, while split vnode,all consumerId is -1

×

169

    code = TSDB_CODE_MND_INVALID_SUB_OPTION;

×

170

    goto END;

×

173

  int32_t tlen = 0;

×

174

  MND_TMQ_RETURN_CHECK(mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan));

×

175

  int32_t vgId = pRebVg->pVgEp->vgId;

×

176

  SVgObj *pVgObj = mndAcquireVgroup(pMnode, vgId);

×

177

  if (pVgObj == NULL) {

×

178

    code = TSDB_CODE_MND_VGROUP_NOT_EXIST;

×

179

    goto END;

×

182

  STransAction action = {0};

×

183

  action.epSet = mndGetVgroupEpset(pMnode, pVgObj);

×

184

  action.pCont = buf;

×

185

  action.contLen = tlen;

×

186

  action.msgType = TDMT_VND_TMQ_SUBSCRIBE;

×

188

  mndReleaseVgroup(pMnode, pVgObj);

×

189

  MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));

×

190

  return code;

×

192

END:

×

193

  taosMemoryFree(buf);

×

194

  return code;

×

197

static void mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, bool fullName) {

×

198

  if (key == NULL || topic == NULL || cgroup == NULL) {

×

199

    return;

×

201

  int32_t i = 0;

×

202

  while (key[i] != TMQ_SEPARATOR_CHAR) {

×

203

    i++;

×

205

  (void)memcpy(cgroup, key, i);

×

206

  cgroup[i] = 0;

×

207

  if (fullName) {

×

208

    tstrncpy(topic, &key[i + 1], TSDB_TOPIC_FNAME_LEN);

×

210

    while (key[i] != '.') {

×

211

      i++;

×

213

    tstrncpy(topic, &key[i + 1], TSDB_CGROUP_LEN);

×

217

static int32_t mndGetOrCreateRebSub(SHashObj *pHash, const char *key, SMqRebInfo **pReb) {

×

218

  if (pHash == NULL || key == NULL) {

×

219

    return TSDB_CODE_INVALID_PARA;

×

221

  int32_t code = 0;

×

222

  SMqRebInfo* pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);

×

223

  if (pRebInfo == NULL) {

×

224

    pRebInfo = tNewSMqRebSubscribe(key);

×

225

    if (pRebInfo == NULL) {

×

226

      code = terrno;

×

227

      goto END;

×

229

    code = taosHashPut(pHash, key, strlen(key) + 1, pRebInfo, sizeof(SMqRebInfo));

×

230

    taosMemoryFreeClear(pRebInfo);

×

231

    if (code != 0) {

×

232

      goto END;

×

234

    pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);

×

235

    MND_TMQ_NULL_CHECK(pRebInfo);

×

237

  if (pReb){

×

238

    *pReb = pRebInfo;

×

241

END:

×

242

  return code;

×

245

static int32_t pushVgDataToHash(SArray *vgs, SHashObj *pHash, int64_t consumerId, char *key) {

×

246

  if (vgs == NULL || pHash == NULL || key == NULL) {

×

247

    return TSDB_CODE_INVALID_PARA;

×

249

  int32_t         code = 0;

×

250

  SMqVgEp       **pVgEp = (SMqVgEp **)taosArrayPop(vgs);

×

251

  MND_TMQ_NULL_CHECK(pVgEp);

×

252

  SMqRebOutputVg outputVg = {consumerId, -1, *pVgEp};

×

253

  MND_TMQ_RETURN_CHECK(taosHashPut(pHash, &(*pVgEp)->vgId, sizeof(int32_t), &outputVg, sizeof(SMqRebOutputVg)));

×

254

  mInfo("[rebalance] sub:%s mq rebalance remove vgId:%d from consumer:0x%" PRIx64, key, (*pVgEp)->vgId, consumerId);

×

255

END:

×

256

  return code;

×

259

static int32_t processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, const SMqRebInputObj *pInput) {

×

260

  if (pHash == NULL || pOutput == NULL || pInput == NULL) {

×

261

    return TSDB_CODE_INVALID_PARA;

×

263

  int32_t code = 0;

×

264

  int32_t numOfRemoved = taosArrayGetSize(pInput->pRebInfo->removedConsumers);

×

265

  int32_t actualRemoved = 0;

×

266

  for (int32_t i = 0; i < numOfRemoved; i++) {

×

267

    int64_t*      consumerId = (int64_t *)taosArrayGet(pInput->pRebInfo->removedConsumers, i);

×

268

    MND_TMQ_NULL_CHECK(consumerId);

×

269

    SMqConsumerEp *pConsumerEp = taosHashGet(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t));

×

270

    if (pConsumerEp == NULL) {

×

271

      continue;

×

274

    int32_t consumerVgNum = taosArrayGetSize(pConsumerEp->vgs);

×

275

    for (int32_t j = 0; j < consumerVgNum; j++) {

×

276

      MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, *consumerId, pOutput->pSub->key));

×

279

    taosArrayDestroy(pConsumerEp->vgs);

×

280

    MND_TMQ_RETURN_CHECK(taosHashRemove(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t)));

×

281

    MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->removedConsumers, consumerId));

×

282

    actualRemoved++;

×

285

  if (numOfRemoved != actualRemoved) {

×

286

    mError("[rebalance] sub:%s mq rebalance removedNum:%d not matched with actual:%d", pOutput->pSub->key, numOfRemoved,

×

289

    mInfo("[rebalance] sub:%s removed %d consumers", pOutput->pSub->key, numOfRemoved);

×

291

END:

×

292

  return code;

×

295

static int32_t processNewConsumers(SMqRebOutputObj *pOutput, const SMqRebInputObj *pInput) {

×

296

  if (pOutput == NULL || pInput == NULL) {

×

297

    return TSDB_CODE_INVALID_PARA;

×

299

  int32_t code = 0;

×

300

  int32_t numOfNewConsumers = taosArrayGetSize(pInput->pRebInfo->newConsumers);

×

302

  for (int32_t i = 0; i < numOfNewConsumers; i++) {

×

303

    int64_t* consumerId = (int64_t *)taosArrayGet(pInput->pRebInfo->newConsumers, i);

×

304

    MND_TMQ_NULL_CHECK(consumerId);

×

305

    SMqConsumerEp newConsumerEp = {0};

×

306

    newConsumerEp.consumerId = *consumerId;

×

307

    newConsumerEp.vgs = taosArrayInit(0, sizeof(void *));

×

308

    MND_TMQ_NULL_CHECK(newConsumerEp.vgs);

×

309

    MND_TMQ_RETURN_CHECK(taosHashPut(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t), &newConsumerEp, sizeof(SMqConsumerEp)));

×

310

    MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->newConsumers, consumerId));

×

311

    mInfo("[rebalance] sub:%s mq rebalance add new consumer:0x%" PRIx64, pOutput->pSub->key, *consumerId);

×

313

END:

×

314

  return code;

×

317

static int32_t processUnassignedVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash) {

×

318

  if (pOutput == NULL || pHash == NULL) {

×

319

    return TSDB_CODE_INVALID_PARA;

×

321

  int32_t code = 0;

×

322

  int32_t numOfVgroups = taosArrayGetSize(pOutput->pSub->unassignedVgs);

×

323

  for (int32_t i = 0; i < numOfVgroups; i++) {

×

324

    MND_TMQ_RETURN_CHECK(pushVgDataToHash(pOutput->pSub->unassignedVgs, pHash, -1, pOutput->pSub->key));

×

326

END:

×

327

  return code;

×

330

static int32_t processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt,

×

332

  if (pOutput == NULL || pHash == NULL) {

×

333

    return TSDB_CODE_INVALID_PARA;

×

335

  int32_t code = 0;

×

336

  int32_t cnt = 0;

×

337

  void   *pIter = NULL;

×

339

  while (1) {

×

340

    pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);

×

341

    if (pIter == NULL) {

×

342

      break;

×

345

    SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;

×

346

    int32_t        consumerVgNum = taosArrayGetSize(pConsumerEp->vgs);

×

348

    MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->modifyConsumers, &pConsumerEp->consumerId));

×

349

    if (consumerVgNum > minVgCnt) {

×

350

      if (cnt < remainderVgCnt) {

×

351

        while (taosArrayGetSize(pConsumerEp->vgs) > minVgCnt + 1) {  // pop until equal minVg + 1

×

352

          MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key));

×

354

        cnt++;

×

356

        while (taosArrayGetSize(pConsumerEp->vgs) > minVgCnt) {

×

357

          MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key));

×

362

END:

×

363

  return code;

×

366

static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) {

×

367

  if (pMnode == NULL || pOutput == NULL) {

×

368

    return TSDB_CODE_INVALID_PARA;

×

370

  int32_t code = 0;

×

371

  int32_t totalVgNum = 0;

×

372

  SVgObj *pVgroup = NULL;

×

373

  SMqVgEp *pVgEp = NULL;

×

374

  void   *pIter = NULL;

×

375

  SArray *newVgs = taosArrayInit(0, POINTER_BYTES);

×

376

  MND_TMQ_NULL_CHECK(newVgs);

×

378

    pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

×

379

    if (pIter == NULL) {

×

380

      break;

×

383

    if (!mndVgroupInDb(pVgroup, pOutput->pSub->dbUid)) {

×

384

      sdbRelease(pMnode->pSdb, pVgroup);

×

385

      continue;

×

388

    totalVgNum++;

×

389

    pVgEp = taosMemoryMalloc(sizeof(SMqVgEp));

×

390

    MND_TMQ_NULL_CHECK(pVgEp);

×

391

    pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup);

×

392

    pVgEp->vgId = pVgroup->vgId;

×

393

    MND_TMQ_NULL_CHECK(taosArrayPush(newVgs, &pVgEp));

×

394

    pVgEp = NULL;

×

395

    sdbRelease(pMnode->pSdb, pVgroup);

×

398

  pIter = NULL;

×

399

  while (1) {

×

400

    pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);

×

401

    if (pIter == NULL) break;

×

402

    SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;

×

403

    int32_t j = 0;

×

404

    while (j < taosArrayGetSize(pConsumerEp->vgs)) {

×

405

      SMqVgEp *pVgEpTmp = taosArrayGetP(pConsumerEp->vgs, j);

×

406

      MND_TMQ_NULL_CHECK(pVgEpTmp);

×

407

      bool     find = false;

×

408

      for (int32_t k = 0; k < taosArrayGetSize(newVgs); k++) {

×

409

        SMqVgEp *pnewVgEp = taosArrayGetP(newVgs, k);

×

410

        MND_TMQ_NULL_CHECK(pnewVgEp);

×

411

        if (pVgEpTmp->vgId == pnewVgEp->vgId) {

×

412

          tDeleteSMqVgEp(pnewVgEp);

×

413

          taosArrayRemove(newVgs, k);

×

414

          find = true;

×

415

          break;

×

418

      if (!find) {

×

419

        mInfo("[rebalance] processRemoveAddVgs old vgId:%d", pVgEpTmp->vgId);

×

420

        tDeleteSMqVgEp(pVgEpTmp);

×

421

        taosArrayRemove(pConsumerEp->vgs, j);

×

422

        continue;

×

424

      j++;

×

428

  if (taosArrayGetSize(pOutput->pSub->unassignedVgs) == 0 && taosArrayGetSize(newVgs) != 0) {

×

429

    MND_TMQ_NULL_CHECK(taosArrayAddAll(pOutput->pSub->unassignedVgs, newVgs));

×

430

    mInfo("[rebalance] processRemoveAddVgs add new vg num:%d", (int)taosArrayGetSize(newVgs));

×

431

    taosArrayDestroy(newVgs);

×

433

    taosArrayDestroyP(newVgs, (FDelete)tDeleteSMqVgEp);

×

435

  return totalVgNum;

×

437

END:

×

438

  sdbRelease(pMnode->pSdb, pVgroup);

×

439

  taosMemoryFree(pVgEp);

×

440

  taosArrayDestroyP(newVgs, (FDelete)tDeleteSMqVgEp);

×

441

  return code;

×

444

static int32_t processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {

×

445

  if (pMnode == NULL || pInput == NULL || pOutput == NULL) {

×

446

    return TSDB_CODE_INVALID_PARA;

×

448

  SMqSubscribeObj *pSub = NULL;

×

449

  int32_t          code = mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key, &pSub);  // put all offset rows

×

450

  if( code != 0){

×

451

    return 0;

×

453

  taosRLockLatch(&pSub->lock);

×

454

  if (pOutput->pSub->offsetRows == NULL) {

×

455

    pOutput->pSub->offsetRows = taosArrayInit(4, sizeof(OffsetRows));

×

456

    if(pOutput->pSub->offsetRows == NULL) {

×

457

      taosRUnLockLatch(&pSub->lock);

×

458

      code = terrno;

×

459

      goto END;

×

462

  void *pIter = NULL;

×

463

  while (1) {

×

464

    pIter = taosHashIterate(pSub->consumerHash, pIter);

×

465

    if (pIter == NULL) break;

×

466

    SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;

×

467

    SMqConsumerEp *pConsumerEpNew = taosHashGet(pOutput->pSub->consumerHash, &pConsumerEp->consumerId, sizeof(int64_t));

×

469

    for (int j = 0; j < taosArrayGetSize(pConsumerEp->offsetRows); j++) {

×

470

      OffsetRows *d1 = taosArrayGet(pConsumerEp->offsetRows, j);

×

471

      MND_TMQ_NULL_CHECK(d1);

×

472

      bool        jump = false;

×

473

      for (int i = 0; pConsumerEpNew && i < taosArrayGetSize(pConsumerEpNew->vgs); i++) {

×

474

        SMqVgEp *pVgEp = taosArrayGetP(pConsumerEpNew->vgs, i);

×

475

        MND_TMQ_NULL_CHECK(pVgEp);

×

476

        if (pVgEp->vgId == d1->vgId) {

×

477

          jump = true;

×

478

          mInfo("pSub->offsetRows jump, because consumer id:0x%" PRIx64 " and vgId:%d not change",

×

480

          break;

×

483

      if (jump) continue;

×

484

      bool find = false;

×

485

      for (int i = 0; i < taosArrayGetSize(pOutput->pSub->offsetRows); i++) {

×

486

        OffsetRows *d2 = taosArrayGet(pOutput->pSub->offsetRows, i);

×

487

        MND_TMQ_NULL_CHECK(d2);

×

488

        if (d1->vgId == d2->vgId) {

×

489

          d2->rows += d1->rows;

×

490

          d2->offset = d1->offset;

×

491

          d2->ever = d1->ever;

×

492

          find = true;

×

493

          mInfo("pSub->offsetRows add vgId:%d, after:%" PRId64 ", before:%" PRId64, d2->vgId, d2->rows, d1->rows);

×

494

          break;

×

497

      if (!find) {

×

498

        MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->pSub->offsetRows, d1));

×

502

  taosRUnLockLatch(&pSub->lock);

×

503

  mndReleaseSubscribe(pMnode, pSub);

×

505

END:

×

506

  return code;

×

509

static void printRebalanceLog(SMqRebOutputObj *pOutput) {

×

510

  if (pOutput == NULL) return;

×

511

  mInfo("sub:%s mq rebalance calculation completed, re-balanced vg", pOutput->pSub->key);

×

512

  for (int32_t i = 0; i < taosArrayGetSize(pOutput->rebVgs); i++) {

×

513

    SMqRebOutputVg *pOutputRebVg = taosArrayGet(pOutput->rebVgs, i);

×

514

    if (pOutputRebVg == NULL) continue;

×

515

    mInfo("sub:%s mq rebalance vgId:%d, moved from consumer:0x%" PRIx64 ", to consumer:0x%" PRIx64, pOutput->pSub->key,

×

519

  void *pIter = NULL;

×

520

  while (1) {

×

521

    pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);

×

522

    if (pIter == NULL) break;

×

523

    SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;

×

524

    int32_t        sz = taosArrayGetSize(pConsumerEp->vgs);

×

525

    mInfo("sub:%s mq rebalance final cfg: consumer:0x%" PRIx64 " has %d vg", pOutput->pSub->key,

×

527

    for (int32_t i = 0; i < sz; i++) {

×

528

      SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, i);

×

529

      if (pVgEp == NULL) continue;

×

530

      mInfo("sub:%s mq rebalance final cfg: vg %d to consumer:0x%" PRIx64, pOutput->pSub->key, pVgEp->vgId,

×

536

static void calcVgroupsCnt(const SMqRebInputObj *pInput, int32_t totalVgNum, const char *pSubKey, int32_t *minVgCnt,

×

538

  if (pInput == NULL || pSubKey == NULL || minVgCnt == NULL || remainderVgCnt == NULL) {

×

539

    return;

×

541

  int32_t numOfRemoved = taosArrayGetSize(pInput->pRebInfo->removedConsumers);

×

542

  int32_t numOfAdded = taosArrayGetSize(pInput->pRebInfo->newConsumers);

×

543

  int32_t numOfFinal = pInput->oldConsumerNum + numOfAdded - numOfRemoved;

×

546

  if (numOfFinal != 0) {

×

547

    *minVgCnt = totalVgNum / numOfFinal;

×

548

    *remainderVgCnt = totalVgNum % numOfFinal;

×

550

    mInfo("[rebalance] sub:%s no consumer subscribe this topic", pSubKey);

×

552

  mInfo(

×

557

static int32_t assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt) {

×

558

  if (pOutput == NULL || pHash == NULL) {

×

559

    return TSDB_CODE_INVALID_PARA;

×

561

  SMqRebOutputVg *pRebVg = NULL;

×

562

  void           *pAssignIter = NULL;

×

563

  void           *pIter = NULL;

×

564

  int32_t         code = 0;

×

566

  while (1) {

×

567

    pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);

×

568

    if (pIter == NULL) {

×

569

      break;

×

571

    SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;

×

572

    while (taosArrayGetSize(pConsumerEp->vgs) < minVgCnt) {

×

573

      pAssignIter = taosHashIterate(pHash, pAssignIter);

×

574

      if (pAssignIter == NULL) {

×

575

        mError("[rebalance] sub:%s assign iter is NULL, never should reach here", pOutput->pSub->key);

×

576

        break;

×

579

      pRebVg = (SMqRebOutputVg *)pAssignIter;

×

580

      pRebVg->newConsumerId = pConsumerEp->consumerId;

×

581

      MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp));

×

582

      mInfo("[rebalance] mq rebalance: add vgId:%d to consumer:0x%" PRIx64 " for average", pRebVg->pVgEp->vgId,

×

587

  while (1) {

×

588

    pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);

×

589

    if (pIter == NULL) {

×

590

      break;

×

592

    SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;

×

593

    if (taosArrayGetSize(pConsumerEp->vgs) == minVgCnt) {

×

594

      pAssignIter = taosHashIterate(pHash, pAssignIter);

×

595

      if (pAssignIter == NULL) {

×

596

        mInfo("[rebalance] sub:%s assign iter is used up", pOutput->pSub->key);

×

597

        break;

×

600

      pRebVg = (SMqRebOutputVg *)pAssignIter;

×

601

      pRebVg->newConsumerId = pConsumerEp->consumerId;

×

602

      MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp));

×

603

      mInfo("[rebalance] mq rebalance: add vgId:%d to consumer:0x%" PRIx64 " for average + 1", pRebVg->pVgEp->vgId,

×

608

  taosHashCancelIterate(pOutput->pSub->consumerHash, pIter);

×

609

  if (pAssignIter != NULL) {

×

610

    mError("[rebalance]sub:%s assign iter is not NULL, never should reach here", pOutput->pSub->key);

×

611

    code = TSDB_CODE_PAR_INTERNAL_ERROR;

×

612

    goto END;

×

614

  while (1) {

×

615

    pAssignIter = taosHashIterate(pHash, pAssignIter);

×

616

    if (pAssignIter == NULL) {

×

617

      break;

×

620

    SMqRebOutputVg *pRebOutput = (SMqRebOutputVg *)pAssignIter;

×

621

    MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->rebVgs, pRebOutput));

×

622

    if (taosHashGetSize(pOutput->pSub->consumerHash) == 0) {            // if all consumer is removed

×

623

      MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->pSub->unassignedVgs, &pRebOutput->pVgEp));  // put all vg into unassigned

×

627

END:

×

628

  return code;

×

631

static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {

×

632

  if (pMnode == NULL || pInput == NULL || pOutput == NULL) {

×

633

    return TSDB_CODE_INVALID_PARA;

×

635

  int32_t     totalVgNum = processRemoveAddVgs(pMnode, pOutput);

×

636

  if (totalVgNum < 0){

×

637

    return totalVgNum;

×

639

  const char *pSubKey = pOutput->pSub->key;

×

640

  int32_t     minVgCnt = 0;

×

641

  int32_t     remainderVgCnt = 0;

×

642

  int32_t     code = 0;

×

643

  SHashObj   *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);

×

644

  MND_TMQ_NULL_CHECK(pHash);

×

645

  MND_TMQ_RETURN_CHECK(processRemovedConsumers(pOutput, pHash, pInput));

×

646

  MND_TMQ_RETURN_CHECK(processUnassignedVgroups(pOutput, pHash));

×

647

  calcVgroupsCnt(pInput, totalVgNum, pSubKey, &minVgCnt, &remainderVgCnt);

×

648

  MND_TMQ_RETURN_CHECK(processModifiedConsumers(pOutput, pHash, minVgCnt, remainderVgCnt));

×

649

  MND_TMQ_RETURN_CHECK(processNewConsumers(pOutput, pInput));

×

650

  MND_TMQ_RETURN_CHECK(assignVgroups(pOutput, pHash, minVgCnt));

×

651

  MND_TMQ_RETURN_CHECK(processSubOffsetRows(pMnode, pInput, pOutput));

×

652

  printRebalanceLog(pOutput);

×

653

  taosHashCleanup(pHash);

×

655

END:

×

656

  return code;

×

659

static int32_t presistConsumerByType(STrans *pTrans, SArray *consumers, int8_t type, char *cgroup, char *topic) {

×

660

  if (pTrans == NULL || consumers == NULL || cgroup == NULL) {

×

661

    return TSDB_CODE_INVALID_PARA;

×

663

  int32_t         code = 0;

×

664

  SMqConsumerObj *pConsumerNew = NULL;

×

665

  int32_t         consumerNum = taosArrayGetSize(consumers);

×

666

  for (int32_t i = 0; i < consumerNum; i++) {

×

667

    int64_t* consumerId = (int64_t *)taosArrayGet(consumers, i);

×

668

    MND_TMQ_NULL_CHECK(consumerId);

×

669

    MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(*consumerId, cgroup, type, topic, NULL, &pConsumerNew));

×

670

    MND_TMQ_RETURN_CHECK(mndSetConsumerCommitLogs(pTrans, pConsumerNew));

×

671

    tDeleteSMqConsumerObj(pConsumerNew);

×

673

  pConsumerNew = NULL;

×

675

END:

×

676

  tDeleteSMqConsumerObj(pConsumerNew);

×

677

  return code;

×

680

static int32_t mndPresistConsumer(STrans *pTrans, const SMqRebOutputObj *pOutput, char *cgroup, char *topic) {

×

681

  if (pTrans == NULL || pOutput == NULL || cgroup == NULL || topic == NULL) {

×

682

    return TSDB_CODE_INVALID_PARA;

×

684

  int32_t code = 0;

×

685

  MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->modifyConsumers, CONSUMER_UPDATE_REB, cgroup, NULL));

×

686

  MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->newConsumers, CONSUMER_ADD_REB, cgroup, topic));

×

687

  MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->removedConsumers, CONSUMER_REMOVE_REB, cgroup, topic));

×

688

END:

×

689

  return code;

×

692

static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOutputObj *pOutput) {

×

693

  if (pMnode == NULL || pMsg == NULL || pOutput == NULL) {

×

694

    return TSDB_CODE_INVALID_PARA;

×

696

  struct SSubplan *pPlan = NULL;

×

697

  int32_t          code = 0;

×

698

  STrans          *pTrans = NULL;

×

700

  if (strcmp(pOutput->pSub->qmsg, "") != 0) {

×

701

    MND_TMQ_RETURN_CHECK(qStringToSubplan(pOutput->pSub->qmsg, &pPlan));

×

704

  char topic[TSDB_TOPIC_FNAME_LEN] = {0};

×

705

  char cgroup[TSDB_CGROUP_LEN] = {0};

×

706

  mndSplitSubscribeKey(pOutput->pSub->key, topic, cgroup, true);

×

708

  pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pMsg, "tmq-reb");

×

709

  if (pTrans == NULL) {

×

710

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

711

    if (terrno != 0) code = terrno;

×

712

    goto END;

×

715

  mndTransSetDbName(pTrans, pOutput->pSub->dbName, pOutput->pSub->key);

×

716

  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));

×

719

  const SArray *rebVgs = pOutput->rebVgs;

×

720

  int32_t       vgNum = taosArrayGetSize(rebVgs);

×

721

  for (int32_t i = 0; i < vgNum; i++) {

×

722

    SMqRebOutputVg *pRebVg = taosArrayGet(rebVgs, i);

×

723

    MND_TMQ_NULL_CHECK(pRebVg);

×

724

    MND_TMQ_RETURN_CHECK(mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg, pPlan));

×

728

  MND_TMQ_RETURN_CHECK(mndSetSubCommitLogs(pTrans, pOutput->pSub));

×

731

  MND_TMQ_RETURN_CHECK(mndPresistConsumer(pTrans, pOutput, cgroup, topic));

×

734

  mndTransSetCb(pTrans, TRANS_START_FUNC_MQ_REB, TRANS_STOP_FUNC_MQ_REB, NULL, 0);

×

737

  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));

×

739

END:

×

740

  nodesDestroyNode((SNode *)pPlan);

×

741

  mndTransDrop(pTrans);

×

742

  TAOS_RETURN(code);

×

745

static void freeRebalanceItem(void *param) {

×

746

  if (param == NULL) return;

×

747

  SMqRebInfo *pInfo = param;

×

748

  taosArrayDestroy(pInfo->newConsumers);

×

749

  taosArrayDestroy(pInfo->removedConsumers);

×

753

static int32_t buildRebInfo(SHashObj *rebSubHash, SArray *topicList, int8_t type, char *group, int64_t consumerId) {

×

754

  if (rebSubHash == NULL || topicList == NULL || group == NULL) {

×

755

    return TSDB_CODE_INVALID_PARA;

×

757

  int32_t code = 0;

×

758

  int32_t topicNum = taosArrayGetSize(topicList);

×

759

  for (int32_t i = 0; i < topicNum; i++) {

×

760

    char *removedTopic = taosArrayGetP(topicList, i);

×

761

    MND_TMQ_NULL_CHECK(removedTopic);

×

762

    char  key[TSDB_SUBSCRIBE_KEY_LEN] = {0};

×

763

    (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", group, TMQ_SEPARATOR, removedTopic);

×

764

    SMqRebInfo *pRebSub = NULL;

×

765

    MND_TMQ_RETURN_CHECK(mndGetOrCreateRebSub(rebSubHash, key, &pRebSub));

×

766

    if (type == 0)

×

767

      MND_TMQ_NULL_CHECK(taosArrayPush(pRebSub->removedConsumers, &consumerId));

×

768

    else if (type == 1)

×

769

      MND_TMQ_NULL_CHECK(taosArrayPush(pRebSub->newConsumers, &consumerId));

×

772

END:

×

773

  return code;

×

776

static void checkForVgroupSplit(SMnode *pMnode, SMqConsumerObj *pConsumer, SHashObj *rebSubHash) {

×

777

  if (pMnode == NULL || pConsumer == NULL || rebSubHash == NULL) {

×

778

    return;

×

780

  int32_t newTopicNum = taosArrayGetSize(pConsumer->currentTopics);

×

781

  for (int32_t i = 0; i < newTopicNum; i++) {

×

782

    char            *topic = taosArrayGetP(pConsumer->currentTopics, i);

×

783

    if (topic == NULL){

×

784

      continue;

×

786

    SMqSubscribeObj *pSub = NULL;

×

787

    char  key[TSDB_SUBSCRIBE_KEY_LEN] = {0};

×

788

    (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, topic);

×

789

    int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);

×

790

    if (code != 0) {

×

791

      continue;

×

793

    taosRLockLatch(&pSub->lock);

×

796

    SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t));

×

797

    if (pConsumerEp == NULL){

×

798

      taosRUnLockLatch(&pSub->lock);

×

799

      mndReleaseSubscribe(pMnode, pSub);

×

800

      continue;

×

802

    int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs);

×

803

    for (int32_t j = 0; j < vgNum; j++) {

×

804

      SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);

×

805

      if (pVgEp == NULL) {

×

806

        continue;

×

808

      SVgObj  *pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId);

×

809

      if (!pVgroup) {

×

810

        code = mndGetOrCreateRebSub(rebSubHash, key, NULL);

×

811

        if (code != 0){

×

812

          mError("failed to mndGetOrCreateRebSub vgroup:%d, error:%s", pVgEp->vgId, tstrerror(code))

×

814

          mInfo("vnode splitted, vgId:%d rebalance will be triggered", pVgEp->vgId);

×

817

      mndReleaseVgroup(pMnode, pVgroup);

×

819

    taosRUnLockLatch(&pSub->lock);

×

820

    mndReleaseSubscribe(pMnode, pSub);

×

824

static int32_t mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) {

×

825

  if (pMsg == NULL || rebSubHash == NULL) {

×

826

    return TSDB_CODE_INVALID_PARA;

×

828

  SMnode         *pMnode = pMsg->info.node;

×

829

  SSdb           *pSdb = pMnode->pSdb;

×

830

  SMqConsumerObj *pConsumer = NULL;

×

831

  void           *pIter = NULL;

×

832

  int32_t         code = 0;

×

835

  while (1) {

×

836

    pIter = sdbFetch(pSdb, SDB_CONSUMER, pIter, (void **)&pConsumer);

×

837

    if (pIter == NULL) {

×

838

      break;

×

841

    int32_t hbStatus = atomic_add_fetch_32(&pConsumer->hbStatus, 1);

×

842

    int32_t pollStatus = atomic_add_fetch_32(&pConsumer->pollStatus, 1);

×

843

    int32_t status = atomic_load_32(&pConsumer->status);

×

845

    mDebug("[rebalance] check for consumer:0x%" PRIx64 " status:%d(%s), sub-time:%" PRId64 ", createTime:%" PRId64

×

850

    if (status == MQ_CONSUMER_STATUS_READY) {

×

851

      if (taosArrayGetSize(pConsumer->currentTopics) == 0) {  // unsubscribe or close

×

852

        MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info));

×

853

      } else if (hbStatus * tsMqRebalanceInterval * 1000 >= pConsumer->sessionTimeoutMs ||

×

854

                 pollStatus * tsMqRebalanceInterval * 1000 >= pConsumer->maxPollIntervalMs) {

×

855

        taosRLockLatch(&pConsumer->lock);

×

856

        MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->currentTopics, 0, pConsumer->cgroup, pConsumer->consumerId));

×

857

        taosRUnLockLatch(&pConsumer->lock);

×

859

        checkForVgroupSplit(pMnode, pConsumer, rebSubHash);

×

861

    } else if (status == MQ_CONSUMER_STATUS_REBALANCE) {

×

862

      taosRLockLatch(&pConsumer->lock);

×

863

      MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->rebNewTopics, 1, pConsumer->cgroup, pConsumer->consumerId));

×

864

      MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->rebRemovedTopics, 0, pConsumer->cgroup, pConsumer->consumerId));

×

865

      taosRUnLockLatch(&pConsumer->lock);

×

867

      MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info));

×

870

    mndReleaseConsumer(pMnode, pConsumer);

×

872

END:

×

873

  return code;

×

876

bool mndRebTryStart() {

×

877

  int32_t old = atomic_val_compare_exchange_32(&mqRebInExecCnt, 0, 1);

×

878

  if (old > 0) mInfo("[rebalance] counter old val:%d", old) return old == 0;

×

881

void mndRebCntInc() {

×

882

  int32_t val = atomic_add_fetch_32(&mqRebInExecCnt, 1);

×

883

  if (val > 0) mInfo("[rebalance] cnt inc, value:%d", val)

×

884

×

886

void mndRebCntDec() {

×

887

  int32_t val = atomic_sub_fetch_32(&mqRebInExecCnt, 1);

×

888

  if (val > 0) mInfo("[rebalance] cnt sub, value:%d", val)

×

889

×

891

static void clearRebOutput(SMqRebOutputObj *rebOutput) {

×

892

  if (rebOutput == NULL) {

×

893

    return;

×

895

  taosArrayDestroy(rebOutput->newConsumers);

×

896

  taosArrayDestroy(rebOutput->modifyConsumers);

×

897

  taosArrayDestroy(rebOutput->removedConsumers);

×

898

  taosArrayDestroy(rebOutput->rebVgs);

×

899

  tDeleteSubscribeObj(rebOutput->pSub);

×

900

  taosMemoryFree(rebOutput->pSub);

×

903

static int32_t initRebOutput(SMqRebOutputObj *rebOutput) {

×

904

  if (rebOutput == NULL) {

×

905

    return TSDB_CODE_INVALID_PARA;

×

907

  int32_t code = 0;

×

908

  rebOutput->newConsumers = taosArrayInit(0, sizeof(int64_t));

×

909

  MND_TMQ_NULL_CHECK(rebOutput->newConsumers);

×

910

  rebOutput->removedConsumers = taosArrayInit(0, sizeof(int64_t));

×

911

  MND_TMQ_NULL_CHECK(rebOutput->removedConsumers);

×

912

  rebOutput->modifyConsumers = taosArrayInit(0, sizeof(int64_t));

×

913

  MND_TMQ_NULL_CHECK(rebOutput->modifyConsumers);

×

914

  rebOutput->rebVgs = taosArrayInit(0, sizeof(SMqRebOutputVg));

×

915

  MND_TMQ_NULL_CHECK(rebOutput->rebVgs);

×

916

  return code;

×

918

END:

×

919

  clearRebOutput(rebOutput);

×

920

  return code;

×

924

static int32_t checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) {

×

925

  if (pMnode == NULL || pSub == NULL) {

×

926

    return TSDB_CODE_INVALID_PARA;

×

928

  int32_t code = 0;

×

929

  void   *pIter = NULL;

×

930

  while (1) {

×

931

    pIter = taosHashIterate(pSub->consumerHash, pIter);

×

932

    if (pIter == NULL) {

×

933

      break;

×

936

    SMqConsumerEp  *pConsumerEp = (SMqConsumerEp *)pIter;

×

937

    SMqConsumerObj *pConsumer = NULL;

×

938

    code = mndAcquireConsumer(pMnode, pConsumerEp->consumerId, &pConsumer);

×

939

    if (code == 0) {

×

940

      mndReleaseConsumer(pMnode, pConsumer);

×

941

      continue;

×

943

    mError("consumer:0x%" PRIx64 " not exists in sdb for exception", pConsumerEp->consumerId);

×

944

    MND_TMQ_NULL_CHECK(taosArrayAddAll(pSub->unassignedVgs, pConsumerEp->vgs));

×

946

    taosArrayDestroy(pConsumerEp->vgs);

×

947

    MND_TMQ_RETURN_CHECK(taosHashRemove(pSub->consumerHash, &pConsumerEp->consumerId, sizeof(int64_t)));

×

949

END:

×

950

  return code;

×

953

static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOutputObj *rebOutput) {

×

954

  if (pMnode == NULL || rebInput == NULL || rebOutput == NULL) {

×

955

    return TSDB_CODE_INVALID_PARA;

×

957

  const char      *key = rebInput->pRebInfo->key;

×

958

  SMqSubscribeObj *pSub = NULL;

×

959

  int32_t          code = mndAcquireSubscribeByKey(pMnode, key, &pSub);

×

961

  if (code != 0) {

×

963

    char topic[TSDB_TOPIC_FNAME_LEN] = {0};

×

964

    char cgroup[TSDB_CGROUP_LEN] = {0};

×

965

    mndSplitSubscribeKey(key, topic, cgroup, true);

×

966

    SMqTopicObj *pTopic = NULL;

×

967

    MND_TMQ_RETURN_CHECK(mndAcquireTopic(pMnode, topic, &pTopic));

×

968

    taosRLockLatch(&pTopic->lock);

×

970

    rebInput->oldConsumerNum = 0;

×

971

    code = mndCreateSubscription(pMnode, pTopic, key, &rebOutput->pSub);

×

972

    if (code != 0) {

×

973

      mError("[rebalance] mq rebalance %s failed create sub since %s, ignore", key, tstrerror(code));

×

974

      taosRUnLockLatch(&pTopic->lock);

×

975

      mndReleaseTopic(pMnode, pTopic);

×

976

      return code;

×

979

    (void)memcpy(rebOutput->pSub->dbName, pTopic->db, TSDB_DB_FNAME_LEN);

×

980

    taosRUnLockLatch(&pTopic->lock);

×

981

    mndReleaseTopic(pMnode, pTopic);

×

983

    mInfo("[rebalance] sub topic:%s has no consumers sub yet", key);

×

985

    taosRLockLatch(&pSub->lock);

×

986

    code = tCloneSubscribeObj(pSub, &rebOutput->pSub);

×

987

    if(code != 0){

×

988

      taosRUnLockLatch(&pSub->lock);

×

989

      goto END;

×

991

    code = checkConsumer(pMnode, rebOutput->pSub);

×

992

    if(code != 0){

×

993

      taosRUnLockLatch(&pSub->lock);

×

994

      goto END;

×

996

    rebInput->oldConsumerNum = taosHashGetSize(rebOutput->pSub->consumerHash);

×

997

    taosRUnLockLatch(&pSub->lock);

×

999

    mInfo("[rebalance] sub topic:%s has %d consumers sub till now", key, rebInput->oldConsumerNum);

×

1000

    mndReleaseSubscribe(pMnode, pSub);

×

1003

END:

×

1004

  return code;

×

1007

static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) {

×

1008

  if (pMsg == NULL) {

×

1009

    return TSDB_CODE_INVALID_PARA;

×

1011

  int     code = 0;

×

1012

  void   *pIter = NULL;

×

1013

  SMnode *pMnode = pMsg->info.node;

×

1014

  mDebug("[rebalance] start to process mq timer");

×

1015

  if (!mndRebTryStart()) {

×

1016

    mInfo("[rebalance] mq rebalance already in progress, do nothing");

×

1017

    return code;

×

1020

  SHashObj *rebSubHash = taosHashInit(64, MurmurHash3_32, true, HASH_NO_LOCK);

×

1021

  MND_TMQ_NULL_CHECK(rebSubHash);

×

1023

  taosHashSetFreeFp(rebSubHash, freeRebalanceItem);

×

1025

  MND_TMQ_RETURN_CHECK(mndCheckConsumer(pMsg, rebSubHash));

×

1026

  if (taosHashGetSize(rebSubHash) > 0) {

×

1027

    mInfo("[rebalance] mq rebalance start, total required re-balanced trans:%d", taosHashGetSize(rebSubHash))

×

1030

  while (1) {

×

1031

    pIter = taosHashIterate(rebSubHash, pIter);

×

1032

    if (pIter == NULL) {

×

1033

      break;

×

1036

    SMqRebInputObj  rebInput = {0};

×

1037

    SMqRebOutputObj rebOutput = {0};

×

1038

    MND_TMQ_RETURN_CHECK(initRebOutput(&rebOutput));

×

1039

    rebInput.pRebInfo = (SMqRebInfo *)pIter;

×

1040

    code = buildRebOutput(pMnode, &rebInput, &rebOutput);

×

1041

    if (code != 0) {

×

1042

      mError("mq rebalance buildRebOutput, msg:%s", tstrerror(code))

×

1045

    if (code == 0){

×

1046

      code = mndDoRebalance(pMnode, &rebInput, &rebOutput);

×

1047

      if (code != 0) {

×

1048

        mError("mq rebalance do rebalance error, msg:%s", tstrerror(code))

×

1052

    if (code == 0){

×

1053

      code = mndPersistRebResult(pMnode, pMsg, &rebOutput);

×

1054

      if (code != 0) {

×

1055

        mError("mq rebalance persist output error, possibly vnode splitted or dropped,msg:%s", tstrerror(code))

×

1059

    clearRebOutput(&rebOutput);

×

1062

  if (taosHashGetSize(rebSubHash) > 0) {

×

1063

    mInfo("[rebalance] mq rebalance completed successfully, wait trans finish")

×

1066

END:

×

1067

  taosHashCancelIterate(rebSubHash, pIter);

×

1068

  taosHashCleanup(rebSubHash);

×

1069

  mndRebCntDec();

×

1071

  TAOS_RETURN(code);

×

1074

static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STrans *pTrans) {

×

1075

  if (pMnode == NULL || pSub == NULL || pTrans == NULL) {

×

1076

    return TSDB_CODE_INVALID_PARA;

×

1078

  void   *pIter = NULL;

×

1079

  SVgObj *pVgObj = NULL;

×

1080

  int32_t code = 0;

×

1081

  while (1) {

×

1082

    pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void **)&pVgObj);

×

1083

    if (pIter == NULL) {

×

1084

      break;

×

1087

    if (!mndVgroupInDb(pVgObj, pSub->dbUid)) {

×

1088

      sdbRelease(pMnode->pSdb, pVgObj);

×

1089

      continue;

×

1091

    SMqVDeleteReq *pReq = taosMemoryCalloc(1, sizeof(SMqVDeleteReq));

×

1092

    MND_TMQ_NULL_CHECK(pReq);

×

1093

    pReq->head.vgId = htonl(pVgObj->vgId);

×

1094

    pReq->vgId = pVgObj->vgId;

×

1095

    pReq->consumerId = -1;

×

1096

    (void)memcpy(pReq->subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);

×

1098

    STransAction action = {0};

×

1099

    action.epSet = mndGetVgroupEpset(pMnode, pVgObj);

×

1100

    action.pCont = pReq;

×

1101

    action.contLen = sizeof(SMqVDeleteReq);

×

1102

    action.msgType = TDMT_VND_TMQ_DELETE_SUB;

×

1103

    action.acceptableCode = TSDB_CODE_MND_VGROUP_NOT_EXIST;

×

1105

    sdbRelease(pMnode->pSdb, pVgObj);

×

1106

    MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));

×

1109

END:

×

1110

  sdbRelease(pMnode->pSdb, pVgObj);

×

1111

  sdbCancelFetch(pMnode->pSdb, pIter);

×

1112

  return code;

×

1115

static int32_t mndCheckConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgroup, char *topic, bool deleteConsumer) {

×

1116

  if (pMnode == NULL || pTrans == NULL || cgroup == NULL || topic == NULL) {

×

1117

    return TSDB_CODE_INVALID_PARA;

×

1119

  void           *pIter = NULL;

×

1120

  SMqConsumerObj *pConsumer = NULL;

×

1121

  SMqConsumerObj *pConsumerNew = NULL;

×

1122

  int             code = 0;

×

1124

    pIter = sdbFetch(pMnode->pSdb, SDB_CONSUMER, pIter, (void **)&pConsumer);

×

1125

    if (pIter == NULL) {

×

1126

      break;

×

1129

    if (strcmp(cgroup, pConsumer->cgroup) != 0) {

×

1130

      sdbRelease(pMnode->pSdb, pConsumer);

×

1131

      continue;

×

1134

    if (deleteConsumer) {

×

1135

      MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL, &pConsumerNew));

×

1136

      MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumerNew));

×

1137

      tDeleteSMqConsumerObj(pConsumerNew);

×

1138

      pConsumerNew = NULL;

×

1140

      bool found = checkTopic(pConsumer->assignedTopics, topic);

×

1141

      if (found){

×

1142

        mError("topic:%s, failed to drop since subscribed by consumer:0x%" PRIx64 ", in consumer group %s",

×

1144

        code = TSDB_CODE_MND_CGROUP_USED;

×

1145

        goto END;

×

1150

    sdbRelease(pMnode->pSdb, pConsumer);

×

1153

END:

×

1154

  tDeleteSMqConsumerObj(pConsumerNew);

×

1155

  sdbRelease(pMnode->pSdb, pConsumer);

×

1156

  sdbCancelFetch(pMnode->pSdb, pIter);

×

1157

  return code;

×

1160

static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) {

×

1161

  if (pMsg == NULL) {

×

1162

    return TSDB_CODE_INVALID_PARA;

×

1164

  SMnode         *pMnode = pMsg->info.node;

×

1165

  SMDropCgroupReq dropReq = {0};

×

1166

  STrans         *pTrans = NULL;

×

1167

  int32_t         code = TSDB_CODE_ACTION_IN_PROGRESS;

×

1168

  SMqSubscribeObj *pSub = NULL;

×

1170

  MND_TMQ_RETURN_CHECK(tDeserializeSMDropCgroupReq(pMsg->pCont, pMsg->contLen, &dropReq));

×

1171

  char  key[TSDB_SUBSCRIBE_KEY_LEN] = {0};

×

1172

  (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", dropReq.cgroup, TMQ_SEPARATOR, dropReq.topic);

×

1173

  code = mndAcquireSubscribeByKey(pMnode, key, &pSub);

×

1174

  if (code != 0) {

×

1175

    if (dropReq.igNotExists) {

×

1176

      mInfo("cgroup:%s on topic:%s, not exist, ignore not exist is set", dropReq.cgroup, dropReq.topic);

×

1177

      return 0;

×

1179

      code = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;

×

1180

      mError("topic:%s, cgroup:%s, failed to drop since %s", dropReq.topic, dropReq.cgroup, tstrerror(code));

×

1181

      return code;

×

1185

  taosWLockLatch(&pSub->lock);

×

1186

  if (!dropReq.force && taosHashGetSize(pSub->consumerHash) != 0) {

×

1187

    code = TSDB_CODE_MND_CGROUP_USED;

×

1188

    mError("cgroup:%s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, tstrerror(code));

×

1189

    goto END;

×

1192

  pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pMsg, "drop-cgroup");

×

1193

  MND_TMQ_NULL_CHECK(pTrans);

×

1194

  mInfo("trans:%d, used to drop cgroup:%s on topic %s", pTrans->id, dropReq.cgroup, dropReq.topic);

×

1195

  mndTransSetDbName(pTrans, pSub->dbName, NULL);

×

1196

  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));

×

1197

  MND_TMQ_RETURN_CHECK(sendDeleteSubToVnode(pMnode, pSub, pTrans));

×

1198

  MND_TMQ_RETURN_CHECK(mndCheckConsumerByGroup(pMnode, pTrans, dropReq.cgroup, dropReq.topic, dropReq.force));

×

1199

  MND_TMQ_RETURN_CHECK(mndSetDropSubCommitLogs(pMnode, pTrans, pSub));

×

1200

  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));

×

1202

END:

×

1203

  taosWUnLockLatch(&pSub->lock);

×

1204

  mndReleaseSubscribe(pMnode, pSub);

×

1205

  mndTransDrop(pTrans);

×

1207

  if (code != 0) {

×

1208

    mError("cgroup %s on topic:%s, failed to drop", dropReq.cgroup, dropReq.topic);

×

1209

    TAOS_RETURN(code);

×

1211

  TAOS_RETURN(TSDB_CODE_ACTION_IN_PROGRESS);

×

1214

void mndCleanupSubscribe(SMnode *pMnode) {}

×

1216

static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) {

×

1217

  if (pSub == NULL) {

×

1218

    return NULL;

×

1220

  int32_t code = 0;

×

1221

  int32_t lino = 0;

×

1222

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1223

  void   *buf = NULL;

×

1224

  int32_t tlen = tEncodeSubscribeObj(NULL, pSub);

×

1225

  if (tlen <= 0) goto SUB_ENCODE_OVER;

×

1226

  int32_t size = sizeof(int32_t) + tlen + MND_SUBSCRIBE_RESERVE_SIZE;

×

1228

  SSdbRaw *pRaw = sdbAllocRaw(SDB_SUBSCRIBE, MND_SUBSCRIBE_VER_NUMBER, size);

×

1229

  if (pRaw == NULL) goto SUB_ENCODE_OVER;

×

1231

  buf = taosMemoryMalloc(tlen);

×

1232

  if (buf == NULL) goto SUB_ENCODE_OVER;

×

1234

  void *abuf = buf;

×

1235

  if (tEncodeSubscribeObj(&abuf, pSub) < 0){

×

1236

    goto SUB_ENCODE_OVER;

×

1239

  int32_t dataPos = 0;

×

1240

  SDB_SET_INT32(pRaw, dataPos, tlen, SUB_ENCODE_OVER);

×

1241

  SDB_SET_BINARY(pRaw, dataPos, buf, tlen, SUB_ENCODE_OVER);

×

1242

  SDB_SET_RESERVE(pRaw, dataPos, MND_SUBSCRIBE_RESERVE_SIZE, SUB_ENCODE_OVER);

×

1243

  SDB_SET_DATALEN(pRaw, dataPos, SUB_ENCODE_OVER);

×

1245

  terrno = TSDB_CODE_SUCCESS;

×

1247

SUB_ENCODE_OVER:

×

1248

  taosMemoryFreeClear(buf);

×

1249

  if (terrno != TSDB_CODE_SUCCESS) {

×

1250

    mError("subscribe:%s, failed to encode to raw:%p since %s", pSub->key, pRaw, terrstr());

×

1251

    sdbFreeRaw(pRaw);

×

1252

    return NULL;

×

1255

  mTrace("subscribe:%s, encode to raw:%p, row:%p", pSub->key, pRaw, pSub);

×

1256

  return pRaw;

×

1259

static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw) {

×

1260

  if (pRaw == NULL) {

×

1261

    return NULL;

×

1263

  int32_t code = 0;

×

1264

  int32_t lino = 0;

×

1265

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1266

  SSdbRow         *pRow = NULL;

×

1267

  SMqSubscribeObj *pSub = NULL;

×

1268

  void            *buf = NULL;

×

1270

  int8_t sver = 0;

×

1271

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

×

1273

  if (sver > MND_SUBSCRIBE_VER_NUMBER || sver < 1) {

×

1274

    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;

×

1275

    goto SUB_DECODE_OVER;

×

1278

  pRow = sdbAllocRow(sizeof(SMqSubscribeObj));

×

1279

  if (pRow == NULL) goto SUB_DECODE_OVER;

×

1281

  pSub = sdbGetRowObj(pRow);

×

1282

  if (pSub == NULL) goto SUB_DECODE_OVER;

×

1284

  int32_t dataPos = 0;

×

1286

  SDB_GET_INT32(pRaw, dataPos, &tlen, SUB_DECODE_OVER);

×

1287

  buf = taosMemoryMalloc(tlen);

×

1288

  if (buf == NULL) goto SUB_DECODE_OVER;

×

1289

  SDB_GET_BINARY(pRaw, dataPos, buf, tlen, SUB_DECODE_OVER);

×

1290

  SDB_GET_RESERVE(pRaw, dataPos, MND_SUBSCRIBE_RESERVE_SIZE, SUB_DECODE_OVER);

×

1292

  if (tDecodeSubscribeObj(buf, pSub, sver) == NULL) {

×

1293

    goto SUB_DECODE_OVER;

×

1297

  if (pSub->unassignedVgs != NULL) {

×

1298

    int32_t size = (int32_t)taosArrayGetSize(pSub->unassignedVgs);

×

1299

    for (int32_t i = 0; i < size; ++i) {

×

1300

      SMqVgEp *pMqVgEp = (SMqVgEp *)taosArrayGetP(pSub->unassignedVgs, i);

×

1301

      tmsgUpdateDnodeEpSet(&pMqVgEp->epSet);

×

1304

  if (pSub->consumerHash != NULL) {

×

1305

    void *pIter = taosHashIterate(pSub->consumerHash, NULL);

×

1306

    while (pIter) {

×

1307

      SMqConsumerEp *pConsumerEp = pIter;

×

1308

      int32_t        size = (int32_t)taosArrayGetSize(pConsumerEp->vgs);

×

1309

      for (int32_t i = 0; i < size; ++i) {

×

1310

        SMqVgEp *pMqVgEp = (SMqVgEp *)taosArrayGetP(pConsumerEp->vgs, i);

×

1311

        tmsgUpdateDnodeEpSet(&pMqVgEp->epSet);

×

1313

      pIter = taosHashIterate(pSub->consumerHash, pIter);

×

1317

  terrno = TSDB_CODE_SUCCESS;

×

1319

SUB_DECODE_OVER:

×

1320

  taosMemoryFreeClear(buf);

×

1321

  if (terrno != TSDB_CODE_SUCCESS) {

×

1322

    mError("subscribe:%s, failed to decode from raw:%p since %s", pSub == NULL ? "null" : pSub->key, pRaw, terrstr());

×

1323

    taosMemoryFreeClear(pRow);

×

1324

    return NULL;

×

1327

  mTrace("subscribe:%s, decode from raw:%p, row:%p", pSub->key, pRaw, pSub);

×

1328

  return pRow;

×

1331

static int32_t mndSubActionInsert(SSdb *pSdb, SMqSubscribeObj *pSub) {

×

1332

  mTrace("subscribe:%s, perform insert action", pSub != NULL ? pSub->key : "null");

×

1333

  return 0;

×

1336

static int32_t mndSubActionDelete(SSdb *pSdb, SMqSubscribeObj *pSub) {

×

1337

  mTrace("subscribe:%s, perform delete action", pSub != NULL ? pSub->key : "null");

×

1338

  tDeleteSubscribeObj(pSub);

×

1339

  return 0;

×

1342

static int32_t mndSubActionUpdate(SSdb *pSdb, SMqSubscribeObj *pOldSub, SMqSubscribeObj *pNewSub) {

×

1343

  if (pOldSub == NULL || pNewSub == NULL) return -1;

×

1344

  mTrace("subscribe:%s, perform update action", pOldSub->key);

×

1345

  taosWLockLatch(&pOldSub->lock);

×

1347

  SHashObj *tmp = pOldSub->consumerHash;

×

1348

  pOldSub->consumerHash = pNewSub->consumerHash;

×

1349

  pNewSub->consumerHash = tmp;

×

1351

  SArray *tmp1 = pOldSub->unassignedVgs;

×

1352

  pOldSub->unassignedVgs = pNewSub->unassignedVgs;

×

1353

  pNewSub->unassignedVgs = tmp1;

×

1355

  SArray *tmp2 = pOldSub->offsetRows;

×

1356

  pOldSub->offsetRows = pNewSub->offsetRows;

×

1357

  pNewSub->offsetRows = tmp2;

×

1359

  taosWUnLockLatch(&pOldSub->lock);

×

1360

  return 0;

×

1363

int32_t mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeObj** pSub) {

×

1364

  if (pMnode == NULL || key == NULL || pSub == NULL){

×

1365

    return TSDB_CODE_INVALID_PARA;

×

1367

  SSdb            *pSdb = pMnode->pSdb;

×

1368

  *pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key);

×

1369

  if (*pSub == NULL) {

×

1370

    return TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;

×

1372

  return 0;

×

1375

int32_t mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName) {

×

1376

  if (pMnode == NULL || topicName == NULL) return 0;

×

1377

  int32_t num = 0;

×

1378

  SSdb   *pSdb = pMnode->pSdb;

×

1380

  void            *pIter = NULL;

×

1381

  SMqSubscribeObj *pSub = NULL;

×

1382

  while (1) {

×

1383

    pIter = sdbFetch(pSdb, SDB_SUBSCRIBE, pIter, (void **)&pSub);

×

1384

    if (pIter == NULL) break;

×

1386

    char topic[TSDB_TOPIC_FNAME_LEN] = {0};

×

1387

    char cgroup[TSDB_CGROUP_LEN] = {0};

×

1388

    mndSplitSubscribeKey(pSub->key, topic, cgroup, true);

×

1389

    if (strcmp(topic, topicName) != 0) {

×

1390

      sdbRelease(pSdb, pSub);

×

1391

      continue;

×

1394

    num++;

×

1395

    sdbRelease(pSdb, pSub);

×

1398

  return num;

×

1401

void mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub) {

×

1402

  if (pMnode == NULL || pSub == NULL) return;

×

1403

  SSdb *pSdb = pMnode->pSdb;

×

1404

  sdbRelease(pSdb, pSub);

×

1407

int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub) {

×

1408

  if (pMnode == NULL || pTrans == NULL || pSub == NULL) return TSDB_CODE_INVALID_PARA;

×

1409

  int32_t  code = 0;

×

1410

  SSdbRaw *pCommitRaw = mndSubActionEncode(pSub);

×

1411

  MND_TMQ_NULL_CHECK(pCommitRaw);

×

1412

  code = mndTransAppendCommitlog(pTrans, pCommitRaw);

×

1413

  if (code != 0){

×

1414

    sdbFreeRaw(pCommitRaw);

×

1415

    goto END;

×

1417

  code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);

×

1418

END:

×

1419

  return code;

×

1422

int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName, bool force) {

×

1423

  if (pMnode == NULL || pTrans == NULL || topicName == NULL) return TSDB_CODE_INVALID_PARA;

×

1424

  SSdb            *pSdb = pMnode->pSdb;

×

1425

  int32_t          code = 0;

×

1426

  void            *pIter = NULL;

×

1427

  SMqSubscribeObj *pSub = NULL;

×

1428

  while (1) {

×

1429

    sdbRelease(pSdb, pSub);

×

1430

    pIter = sdbFetch(pSdb, SDB_SUBSCRIBE, pIter, (void **)&pSub);

×

1431

    if (pIter == NULL) break;

×

1433

    char topic[TSDB_TOPIC_FNAME_LEN] = {0};

×

1434

    char cgroup[TSDB_CGROUP_LEN] = {0};

×

1435

    mndSplitSubscribeKey(pSub->key, topic, cgroup, true);

×

1436

    if (strcmp(topic, topicName) != 0) {

×

1437

      continue;

×

1441

    if (!force && taosHashGetSize(pSub->consumerHash) != 0) {

×

1442

      code = TSDB_CODE_MND_IN_REBALANCE;

×

1443

      goto END;

×

1446

    MND_TMQ_RETURN_CHECK(sendDeleteSubToVnode(pMnode, pSub, pTrans));

×

1447

    MND_TMQ_RETURN_CHECK(mndSetDropSubCommitLogs(pMnode, pTrans, pSub));

×

1450

END:

×

1451

  sdbRelease(pSdb, pSub);

×

1452

  sdbCancelFetch(pSdb, pIter);

×

1454

  TAOS_RETURN(code);

×

1457

static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t consumerId, const char* user, const char* fqdn,

×

1459

  if (pBlock == NULL || numOfRows == NULL || topic == NULL || cgroup == NULL){

×

1460

    return TSDB_CODE_INVALID_PARA;

×

1462

  int32_t code = 0;

×

1463

  int32_t sz = taosArrayGetSize(vgs);

×

1464

  for (int32_t j = 0; j < sz; j++) {

×

1465

    SMqVgEp *pVgEp = taosArrayGetP(vgs, j);

×

1466

    MND_TMQ_NULL_CHECK(pVgEp);

×

1468

    SColumnInfoData *pColInfo = NULL;

×

1469

    int32_t          cols = 0;

×

1471

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

×

1472

    MND_TMQ_NULL_CHECK(pColInfo);

×

1473

    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)topic, false));

×

1475

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

×

1476

    MND_TMQ_NULL_CHECK(pColInfo);

×

1477

    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)cgroup, false));

×

1480

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

×

1481

    MND_TMQ_NULL_CHECK(pColInfo);

×

1482

    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)&pVgEp->vgId, false));

×

1485

    char consumerIdHex[TSDB_CONSUMER_ID_LEN] = {0};

×

1486

    (void)snprintf(varDataVal(consumerIdHex), TSDB_CONSUMER_ID_LEN - VARSTR_HEADER_SIZE, "0x%" PRIx64, consumerId);

×

1487

    varDataSetLen(consumerIdHex, strlen(varDataVal(consumerIdHex)));

×

1489

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

×

1490

    MND_TMQ_NULL_CHECK(pColInfo);

×

1491

    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)consumerIdHex, consumerId == -1));

×

1493

    char userStr[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0};

×

1494

    if (user) STR_TO_VARSTR(userStr, user);

×

1495

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

×

1496

    MND_TMQ_NULL_CHECK(pColInfo);

×

1497

    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, userStr, user == NULL));

×

1499

    char fqdnStr[TSDB_FQDN_LEN + VARSTR_HEADER_SIZE] = {0};

×

1500

    if (fqdn) STR_TO_VARSTR(fqdnStr, fqdn);

×

1501

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

×

1502

    MND_TMQ_NULL_CHECK(pColInfo);

×

1503

    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, fqdnStr, fqdn == NULL));

×

1505

    mInfo("mnd show subscriptions: topic %s, consumer:0x%" PRIx64 " cgroup %s vgid %d", varDataVal(topic), consumerId,

×

1509

    OffsetRows *data = NULL;

×

1510

    for (int i = 0; i < taosArrayGetSize(offsetRows); i++) {

×

1511

      OffsetRows *tmp = taosArrayGet(offsetRows, i);

×

1512

      MND_TMQ_NULL_CHECK(tmp);

×

1513

      if (tmp->vgId != pVgEp->vgId) {

×

1514

        mInfo("mnd show subscriptions: do not find vgId:%d, %d in offsetRows", tmp->vgId, pVgEp->vgId);

×

1515

        continue;

×

1517

      data = tmp;

×

1519

    if (data) {

×

1521

      char buf[TSDB_OFFSET_LEN * 2 + VARSTR_HEADER_SIZE] = {0};

×

1522

      (void)tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset);

×

1523

      (void)snprintf(varDataVal(buf) + strlen(varDataVal(buf)),

×

1524

                     sizeof(buf) - VARSTR_HEADER_SIZE - strlen(varDataVal(buf)), "/%" PRId64, data->ever);

×

1525

      varDataSetLen(buf, strlen(varDataVal(buf)));

×

1526

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

×

1527

      MND_TMQ_NULL_CHECK(pColInfo);

×

1528

      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)buf, false));

×

1529

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

×

1530

      MND_TMQ_NULL_CHECK(pColInfo);

×

1531

      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)&data->rows, false));

×

1533

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

×

1534

      MND_TMQ_NULL_CHECK(pColInfo);

×

1535

      colDataSetNULL(pColInfo, *numOfRows);

×

1536

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

×

1537

      MND_TMQ_NULL_CHECK(pColInfo);

×

1538

      colDataSetNULL(pColInfo, *numOfRows);

×

1539

      mInfo("mnd show subscriptions: do not find vgId:%d in offsetRows", pVgEp->vgId);

×

1541

    (*numOfRows)++;

×

1543

  return 0;

×

1544

END:

×

1545

  return code;

×

1548

int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {

×

1549

  if (pReq == NULL || pShow == NULL || pBlock == NULL){

×

1550

    return TSDB_CODE_INVALID_PARA;

×

1552

  SMnode          *pMnode = pReq->info.node;

×

1553

  SSdb            *pSdb = pMnode->pSdb;

×

1554

  int32_t          numOfRows = 0;

×

1555

  SMqSubscribeObj *pSub = NULL;

×

1556

  int32_t          code = 0;

×

1558

  mInfo("mnd show subscriptions begin");

×

1560

  while (numOfRows < rowsCapacity) {

×

1561

    pShow->pIter = sdbFetch(pSdb, SDB_SUBSCRIBE, pShow->pIter, (void **)&pSub);

×

1562

    if (pShow->pIter == NULL) {

×

1563

      break;

×

1566

    taosRLockLatch(&pSub->lock);

×

1568

    if (numOfRows + pSub->vgNum > rowsCapacity) {

×

1569

      MND_TMQ_RETURN_CHECK(blockDataEnsureCapacity(pBlock, numOfRows + pSub->vgNum))  ;

×

1573

    char topic[TSDB_TOPIC_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};

×

1574

    char cgroup[TSDB_CGROUP_LEN + VARSTR_HEADER_SIZE] = {0};

×

1575

    mndSplitSubscribeKey(pSub->key, varDataVal(topic), varDataVal(cgroup), false);

×

1576

    varDataSetLen(topic, strlen(varDataVal(topic)));

×

1577

    varDataSetLen(cgroup, strlen(varDataVal(cgroup)));

×

1579

    SMqConsumerEp *pConsumerEp = NULL;

×

1580

    void          *pIter = NULL;

×

1582

    while (1) {

×

1583

      pIter = taosHashIterate(pSub->consumerHash, pIter);

×

1584

      if (pIter == NULL) break;

×

1585

      pConsumerEp = (SMqConsumerEp *)pIter;

×

1587

      char          *user = NULL;

×

1588

      char          *fqdn = NULL;

×

1589

      SMqConsumerObj *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &pConsumerEp->consumerId);

×

1590

      if (pConsumer != NULL) {

×

1591

        user = pConsumer->user;

×

1592

        fqdn = pConsumer->fqdn;

×

1593

        sdbRelease(pSdb, pConsumer);

×

1595

      MND_TMQ_RETURN_CHECK(buildResult(pBlock, &numOfRows, pConsumerEp->consumerId, user, fqdn, topic, cgroup, pConsumerEp->vgs,

×

1599

    MND_TMQ_RETURN_CHECK(buildResult(pBlock, &numOfRows, -1, NULL, NULL, topic, cgroup, pSub->unassignedVgs, pSub->offsetRows));

×

1601

    pBlock->info.rows = numOfRows;

×

1603

    taosRUnLockLatch(&pSub->lock);

×

1604

    sdbRelease(pSdb, pSub);

×

1607

  mInfo("mnd end show subscriptions");

×

1609

  pShow->numOfRows += numOfRows;

×

1610

  return numOfRows;

×

1612

END:

×

1613

  taosRUnLockLatch(&pSub->lock);

×

1614

  sdbRelease(pSdb, pSub);

×

1616

  return code;

×

1619

void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter) {

×

1620

  if (pMnode == NULL) {

×

1621

    return;

×

1623

  SSdb *pSdb = pMnode->pSdb;

×

1624

  sdbCancelFetchByType(pSdb, pIter, SDB_SUBSCRIBE);

×

taosdata / TDengine / #3798

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

taosdata / TDengine / #3798

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

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