taosdata/TDengine | Build 3621 | source/dnode/mnode/impl/src/mndDb.c | Coveralls

UNCOV

int32_t mndInitDb(SMnode *pMnode) {

×

UNCOV

64

  SSdbTable table = {

×

UNCOV

75

  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_DB, mndProcessCreateDbReq);

×

UNCOV

76

  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);

×

UNCOV

77

  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);

×

UNCOV

78

  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);

×

UNCOV

79

  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);

×

UNCOV

80

  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB, mndProcessTrimDbReq);

×

UNCOV

81

  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);

×

UNCOV

82

  mndSetMsgHandle(pMnode, TDMT_MND_S3MIGRATE_DB, mndProcessS3MigrateDbReq);

×

UNCOV

84

  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);

×

UNCOV

85

  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);

×

UNCOV

87

  return sdbSetTable(pMnode->pSdb, table);

×

UNCOV

90

void mndCleanupDb(SMnode *pMnode) {}

×

UNCOV

92

SSdbRaw *mndDbActionEncode(SDbObj *pDb) {

×

UNCOV

93

  int32_t code = 0;

×

UNCOV

94

  int32_t lino = 0;

×

UNCOV

95

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

UNCOV

97

  int32_t  size = sizeof(SDbObj) + pDb->cfg.numOfRetensions * sizeof(SRetention) + DB_RESERVE_SIZE;

×

UNCOV

98

  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, DB_VER_NUMBER, size);

×

UNCOV

99

  if (pRaw == NULL) goto _OVER;

×

UNCOV

101

  int32_t dataPos = 0;

×

UNCOV

102

  SDB_SET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)

×

UNCOV

103

  SDB_SET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)

×

UNCOV

104

  SDB_SET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)

×

UNCOV

105

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

×

UNCOV

106

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

×

UNCOV

107

  SDB_SET_INT64(pRaw, dataPos, pDb->uid, _OVER)

×

UNCOV

108

  SDB_SET_INT32(pRaw, dataPos, pDb->cfgVersion, _OVER)

×

UNCOV

109

  SDB_SET_INT32(pRaw, dataPos, pDb->vgVersion, _OVER)

×

UNCOV

110

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfVgroups, _OVER)

×

UNCOV

111

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfStables, _OVER)

×

UNCOV

112

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.buffer, _OVER)

×

UNCOV

113

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.pageSize, _OVER)

×

UNCOV

114

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.pages, _OVER)

×

UNCOV

115

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheLastSize, _OVER)

×

UNCOV

116

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile, _OVER)

×

UNCOV

117

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0, _OVER)

×

UNCOV

118

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1, _OVER)

×

UNCOV

119

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep2, _OVER)

×

UNCOV

120

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.minRows, _OVER)

×

UNCOV

121

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRows, _OVER)

×

UNCOV

122

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walFsyncPeriod, _OVER)

×

UNCOV

123

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel, _OVER)

×

UNCOV

124

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision, _OVER)

×

UNCOV

125

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression, _OVER)

×

UNCOV

126

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications, _OVER)

×

UNCOV

127

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.strict, _OVER)

×

UNCOV

128

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLast, _OVER)

×

UNCOV

129

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.hashMethod, _OVER)

×

UNCOV

130

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfRetensions, _OVER)

×

UNCOV

131

  for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {

×

UNCOV

132

    SRetention *pRetension = taosArrayGet(pDb->cfg.pRetensions, i);

×

UNCOV

133

    SDB_SET_INT64(pRaw, dataPos, pRetension->freq, _OVER)

×

UNCOV

134

    SDB_SET_INT64(pRaw, dataPos, pRetension->keep, _OVER)

×

UNCOV

135

    SDB_SET_INT8(pRaw, dataPos, pRetension->freqUnit, _OVER)

×

UNCOV

136

    SDB_SET_INT8(pRaw, dataPos, pRetension->keepUnit, _OVER)

×

UNCOV

138

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.schemaless, _OVER)

×

UNCOV

139

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walRetentionPeriod, _OVER)

×

UNCOV

140

  SDB_SET_INT64(pRaw, dataPos, pDb->cfg.walRetentionSize, _OVER)

×

UNCOV

141

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walRollPeriod, _OVER)

×

UNCOV

142

  SDB_SET_INT64(pRaw, dataPos, pDb->cfg.walSegmentSize, _OVER)

×

UNCOV

143

  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.sstTrigger, _OVER)

×

UNCOV

144

  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashPrefix, _OVER)

×

UNCOV

145

  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashSuffix, _OVER)

×

UNCOV

146

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.tsdbPageSize, _OVER)

×

UNCOV

147

  SDB_SET_INT64(pRaw, dataPos, pDb->compactStartTime, _OVER)

×

UNCOV

148

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.keepTimeOffset, _OVER)

×

UNCOV

149

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.s3ChunkSize, _OVER)

×

UNCOV

150

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.s3KeepLocal, _OVER)

×

UNCOV

151

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.s3Compact, _OVER)

×

UNCOV

152

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.withArbitrator, _OVER)

×

UNCOV

153

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.encryptAlgorithm, _OVER)

×

UNCOV

154

  SDB_SET_INT32(pRaw, dataPos, pDb->tsmaVersion, _OVER);

×

UNCOV

155

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compactTimeOffset, _OVER)

×

UNCOV

156

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactStartTime, _OVER)

×

UNCOV

157

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactEndTime, _OVER)

×

UNCOV

158

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactInterval, _OVER)

×

UNCOV

160

  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

×

UNCOV

161

  SDB_SET_DATALEN(pRaw, dataPos, _OVER)

×

UNCOV

163

  terrno = 0;

×

UNCOV

165

_OVER:

×

UNCOV

166

  if (terrno != 0) {

×

167

    mError("db:%s, failed to encode to raw:%p since %s", pDb->name, pRaw, terrstr());

×

168

    sdbFreeRaw(pRaw);

×

169

    return NULL;

×

UNCOV

172

  mTrace("db:%s, encode to raw:%p, row:%p", pDb->name, pRaw, pDb);

×

UNCOV

173

  return pRaw;

×

UNCOV

176

static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {

×

UNCOV

177

  int32_t code = 0;

×

UNCOV

178

  int32_t lino = 0;

×

UNCOV

179

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

UNCOV

180

  SSdbRow *pRow = NULL;

×

UNCOV

181

  SDbObj  *pDb = NULL;

×

UNCOV

183

  int8_t sver = 0;

×

UNCOV

184

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

×

UNCOV

186

  if (sver != DB_VER_NUMBER) {

×

187

    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;

×

188

    goto _OVER;

×

UNCOV

191

  pRow = sdbAllocRow(sizeof(SDbObj));

×

UNCOV

192

  if (pRow == NULL) goto _OVER;

×

UNCOV

194

  pDb = sdbGetRowObj(pRow);

×

UNCOV

195

  if (pDb == NULL) goto _OVER;

×

UNCOV

197

  int32_t dataPos = 0;

×

UNCOV

198

  SDB_GET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)

×

UNCOV

199

  SDB_GET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)

×

UNCOV

200

  SDB_GET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)

×

UNCOV

201

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

×

UNCOV

202

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

×

UNCOV

203

  SDB_GET_INT64(pRaw, dataPos, &pDb->uid, _OVER)

×

UNCOV

204

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfgVersion, _OVER)

×

UNCOV

205

  SDB_GET_INT32(pRaw, dataPos, &pDb->vgVersion, _OVER)

×

UNCOV

206

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfVgroups, _OVER)

×

UNCOV

207

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfStables, _OVER)

×

UNCOV

208

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.buffer, _OVER)

×

UNCOV

209

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.pageSize, _OVER)

×

UNCOV

210

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.pages, _OVER)

×

UNCOV

211

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.cacheLastSize, _OVER)

×

UNCOV

212

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysPerFile, _OVER)

×

UNCOV

213

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep0, _OVER)

×

UNCOV

214

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep1, _OVER)

×

UNCOV

215

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep2, _OVER)

×

UNCOV

216

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.minRows, _OVER)

×

UNCOV

217

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.maxRows, _OVER)

×

UNCOV

218

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walFsyncPeriod, _OVER)

×

UNCOV

219

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.walLevel, _OVER)

×

UNCOV

220

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.precision, _OVER)

×

UNCOV

221

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compression, _OVER)

×

UNCOV

222

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.replications, _OVER)

×

UNCOV

223

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.strict, _OVER)

×

UNCOV

224

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.cacheLast, _OVER)

×

UNCOV

225

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.hashMethod, _OVER)

×

UNCOV

226

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfRetensions, _OVER)

×

UNCOV

227

  if (pDb->cfg.numOfRetensions > 0) {

×

UNCOV

228

    pDb->cfg.pRetensions = taosArrayInit(pDb->cfg.numOfRetensions, sizeof(SRetention));

×

UNCOV

229

    if (pDb->cfg.pRetensions == NULL) goto _OVER;

×

UNCOV

230

    for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {

×

UNCOV

231

      SRetention retention = {0};

×

UNCOV

232

      SDB_GET_INT64(pRaw, dataPos, &retention.freq, _OVER)

×

UNCOV

233

      SDB_GET_INT64(pRaw, dataPos, &retention.keep, _OVER)

×

UNCOV

234

      SDB_GET_INT8(pRaw, dataPos, &retention.freqUnit, _OVER)

×

UNCOV

235

      SDB_GET_INT8(pRaw, dataPos, &retention.keepUnit, _OVER)

×

UNCOV

236

      if (taosArrayPush(pDb->cfg.pRetensions, &retention) == NULL) {

×

237

        goto _OVER;

×

UNCOV

241

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.schemaless, _OVER)

×

UNCOV

242

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walRetentionPeriod, _OVER)

×

UNCOV

243

  SDB_GET_INT64(pRaw, dataPos, &pDb->cfg.walRetentionSize, _OVER)

×

UNCOV

244

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walRollPeriod, _OVER)

×

UNCOV

245

  SDB_GET_INT64(pRaw, dataPos, &pDb->cfg.walSegmentSize, _OVER)

×

UNCOV

246

  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.sstTrigger, _OVER)

×

UNCOV

247

  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashPrefix, _OVER)

×

UNCOV

248

  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashSuffix, _OVER)

×

UNCOV

249

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.tsdbPageSize, _OVER)

×

UNCOV

250

  SDB_GET_INT64(pRaw, dataPos, &pDb->compactStartTime, _OVER)

×

UNCOV

251

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.keepTimeOffset, _OVER)

×

UNCOV

252

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.s3ChunkSize, _OVER)

×

UNCOV

253

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.s3KeepLocal, _OVER)

×

UNCOV

254

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.s3Compact, _OVER)

×

UNCOV

255

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.withArbitrator, _OVER)

×

UNCOV

256

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.encryptAlgorithm, _OVER)

×

UNCOV

257

  SDB_GET_INT32(pRaw, dataPos, &pDb->tsmaVersion, _OVER);

×

UNCOV

258

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compactTimeOffset, _OVER)

×

UNCOV

259

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactStartTime, _OVER)

×

UNCOV

260

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactEndTime, _OVER)

×

UNCOV

261

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactInterval, _OVER)

×

UNCOV

263

  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

×

UNCOV

264

  taosInitRWLatch(&pDb->lock);

×

UNCOV

266

  if (pDb->cfg.s3ChunkSize == 0) {

×

267

    pDb->cfg.s3ChunkSize = TSDB_DEFAULT_S3_CHUNK_SIZE;

×

269

    mInfo("db:%s, s3ChunkSize set from %d to default %d", pDb->name, pDb->cfg.s3ChunkSize, TSDB_DEFAULT_S3_CHUNK_SIZE);

×

UNCOV

272

  if (pDb->cfg.s3KeepLocal == 0) {

×

273

    pDb->cfg.s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL;

×

275

    mInfo("db:%s, s3KeepLocal set from %d to default %d", pDb->name, pDb->cfg.s3KeepLocal, TSDB_DEFAULT_S3_KEEP_LOCAL);

×

UNCOV

278

  if (pDb->cfg.tsdbPageSize != TSDB_MIN_TSDB_PAGESIZE) {

×

UNCOV

279

    mInfo("db:%s, tsdbPageSize set from %d to default %d", pDb->name, pDb->cfg.tsdbPageSize,

×

UNCOV

283

  if (pDb->cfg.sstTrigger != TSDB_MIN_STT_TRIGGER) {

×

UNCOV

284

    mInfo("db:%s, sstTrigger set from %d to default %d", pDb->name, pDb->cfg.sstTrigger, TSDB_DEFAULT_SST_TRIGGER);

×

UNCOV

287

  terrno = 0;

×

UNCOV

289

_OVER:

×

UNCOV

290

  if (terrno != 0) {

×

291

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

×

292

    taosMemoryFreeClear(pRow);

×

293

    return NULL;

×

UNCOV

296

  mTrace("db:%s, decode from raw:%p, row:%p", pDb->name, pRaw, pDb);

×

UNCOV

297

  return pRow;

×

UNCOV

300

static int32_t mndNewDbActionValidate(SMnode *pMnode, STrans *pTrans, SSdbRaw *pRaw) {

×

UNCOV

301

  SSdb    *pSdb = pMnode->pSdb;

×

UNCOV

302

  SSdbRow *pRow = NULL;

×

UNCOV

303

  SDbObj  *pNewDb = NULL;

×

UNCOV

304

  int      code = -1;

×

UNCOV

306

  pRow = mndDbActionDecode(pRaw);

×

UNCOV

307

  if (pRow == NULL) {

×

308

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

309

    if (terrno != 0) code = terrno;

×

310

    goto _OVER;

×

UNCOV

312

  pNewDb = sdbGetRowObj(pRow);

×

UNCOV

313

  if (pNewDb == NULL) {

×

314

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

315

    if (terrno != 0) code = terrno;

×

316

    goto _OVER;

×

UNCOV

319

  SDbObj *pOldDb = sdbAcquire(pMnode->pSdb, SDB_DB, pNewDb->name);

×

UNCOV

320

  if (pOldDb != NULL) {

×

321

    mError("trans:%d, db name already in use. name: %s", pTrans->id, pNewDb->name);

×

322

    sdbRelease(pMnode->pSdb, pOldDb);

×

323

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

324

    if (terrno != 0) code = terrno;

×

325

    goto _OVER;

×

UNCOV

328

  code = 0;

×

UNCOV

329

_OVER:

×

UNCOV

330

  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);

×

UNCOV

331

  taosMemoryFreeClear(pRow);

×

UNCOV

332

  return code;

×

UNCOV

335

static int32_t mndDbActionInsert(SSdb *pSdb, SDbObj *pDb) {

×

UNCOV

336

  mTrace("db:%s, perform insert action, row:%p", pDb->name, pDb);

×

UNCOV

337

  return 0;

×

UNCOV

340

static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) {

×

UNCOV

341

  mTrace("db:%s, perform delete action, row:%p", pDb->name, pDb);

×

UNCOV

342

  taosArrayDestroy(pDb->cfg.pRetensions);

×

UNCOV

343

  return 0;

×

UNCOV

346

static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {

×

UNCOV

347

  mTrace("db:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew);

×

UNCOV

348

  taosWLockLatch(&pOld->lock);

×

UNCOV

349

  pOld->updateTime = pNew->updateTime;

×

UNCOV

350

  pOld->cfgVersion = pNew->cfgVersion;

×

UNCOV

351

  pOld->vgVersion = pNew->vgVersion;

×

UNCOV

352

  pOld->cfg.numOfVgroups = pNew->cfg.numOfVgroups;

×

UNCOV

353

  pOld->cfg.buffer = pNew->cfg.buffer;

×

UNCOV

354

  pOld->cfg.pageSize = pNew->cfg.pageSize;

×

UNCOV

355

  pOld->cfg.pages = pNew->cfg.pages;

×

UNCOV

356

  pOld->cfg.cacheLastSize = pNew->cfg.cacheLastSize;

×

UNCOV

357

  pOld->cfg.daysPerFile = pNew->cfg.daysPerFile;

×

UNCOV

358

  pOld->cfg.daysToKeep0 = pNew->cfg.daysToKeep0;

×

UNCOV

359

  pOld->cfg.daysToKeep1 = pNew->cfg.daysToKeep1;

×

UNCOV

360

  pOld->cfg.daysToKeep2 = pNew->cfg.daysToKeep2;

×

UNCOV

361

  pOld->cfg.keepTimeOffset = pNew->cfg.keepTimeOffset;

×

UNCOV

362

  pOld->cfg.walFsyncPeriod = pNew->cfg.walFsyncPeriod;

×

UNCOV

363

  pOld->cfg.walLevel = pNew->cfg.walLevel;

×

UNCOV

364

  pOld->cfg.walRetentionPeriod = pNew->cfg.walRetentionPeriod;

×

UNCOV

365

  pOld->cfg.walRetentionSize = pNew->cfg.walRetentionSize;

×

UNCOV

366

  pOld->cfg.strict = pNew->cfg.strict;

×

UNCOV

367

  pOld->cfg.cacheLast = pNew->cfg.cacheLast;

×

UNCOV

368

  pOld->cfg.replications = pNew->cfg.replications;

×

UNCOV

369

  pOld->cfg.sstTrigger = pNew->cfg.sstTrigger;

×

UNCOV

370

  pOld->cfg.minRows = pNew->cfg.minRows;

×

UNCOV

371

  pOld->cfg.maxRows = pNew->cfg.maxRows;

×

UNCOV

372

  pOld->cfg.tsdbPageSize = pNew->cfg.tsdbPageSize;

×

UNCOV

373

  pOld->cfg.s3ChunkSize = pNew->cfg.s3ChunkSize;

×

UNCOV

374

  pOld->cfg.s3KeepLocal = pNew->cfg.s3KeepLocal;

×

UNCOV

375

  pOld->cfg.s3Compact = pNew->cfg.s3Compact;

×

UNCOV

376

  pOld->cfg.withArbitrator = pNew->cfg.withArbitrator;

×

UNCOV

377

  pOld->cfg.compactInterval = pNew->cfg.compactInterval;

×

UNCOV

378

  pOld->cfg.compactStartTime = pNew->cfg.compactStartTime;

×

UNCOV

379

  pOld->cfg.compactEndTime = pNew->cfg.compactEndTime;

×

UNCOV

380

  pOld->cfg.compactTimeOffset = pNew->cfg.compactTimeOffset;

×

UNCOV

381

  pOld->compactStartTime = pNew->compactStartTime;

×

UNCOV

382

  pOld->tsmaVersion = pNew->tsmaVersion;

×

UNCOV

383

  taosWUnLockLatch(&pOld->lock);

×

UNCOV

384

  return 0;

×

UNCOV

387

static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {

×

UNCOV

388

  SSdb *pSdb = pMnode->pSdb;

×

UNCOV

389

  return sdbGetTableVer(pSdb, SDB_VGROUP);

×

UNCOV

392

SDbObj *mndAcquireDb(SMnode *pMnode, const char *db) {

×

UNCOV

393

  SSdb   *pSdb = pMnode->pSdb;

×

UNCOV

394

  SDbObj *pDb = sdbAcquire(pSdb, SDB_DB, db);

×

UNCOV

395

  if (pDb == NULL) {

×

UNCOV

396

    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {

×

UNCOV

397

      terrno = TSDB_CODE_MND_DB_NOT_EXIST;

×

UNCOV

398

    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {

×

UNCOV

399

      terrno = TSDB_CODE_MND_DB_IN_CREATING;

×

UNCOV

400

    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {

×

UNCOV

401

      terrno = TSDB_CODE_MND_DB_IN_DROPPING;

×

403

      terrno = TSDB_CODE_APP_ERROR;

×

404

      mFatal("db:%s, failed to acquire db since %s", db, terrstr());

×

UNCOV

407

  return pDb;

×

UNCOV

410

void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {

×

UNCOV

411

  SSdb *pSdb = pMnode->pSdb;

×

UNCOV

412

  sdbRelease(pSdb, pDb);

×

UNCOV

413

×

UNCOV

415

bool mndDbIsExist(SMnode *pMnode, const char *db) {

×

UNCOV

416

  SDbObj *pDb = mndAcquireDb(pMnode, db);

×

UNCOV

417

  if (pDb == NULL) {

×

418

    return false;

×

UNCOV

420

    mndReleaseDb(pMnode, pDb);

×

UNCOV

421

    pDb = NULL;

×

UNCOV

422

    return true;

×

UNCOV

426

static int32_t mndCheckDbName(const char *dbName, SUserObj *pUser) {

×

UNCOV

427

  char *pos = strstr(dbName, TS_PATH_DELIMITER);

×

UNCOV

428

  if (pos == NULL) {

×

429

    return TSDB_CODE_MND_INVALID_DB;

×

UNCOV

433

  int32_t code = taosStr2int32(dbName, &acctId);

×

UNCOV

434

  if (code != 0) {

×

435

    return code;

×

UNCOV

438

  if (acctId != pUser->acctId) {

×

439

    return TSDB_CODE_MND_INVALID_DB_ACCT;

×

UNCOV

442

  return 0;

×

UNCOV

445

static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {

×

UNCOV

446

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

×

UNCOV

448

  if (pCfg->numOfVgroups < TSDB_MIN_VNODES_PER_DB || pCfg->numOfVgroups > TSDB_MAX_VNODES_PER_DB) return code;

×

UNCOV

449

  if (pCfg->numOfStables < TSDB_DB_STREAM_MODE_OFF || pCfg->numOfStables > TSDB_DB_STREAM_MODE_ON) return code;

×

UNCOV

450

  if (pCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;

×

UNCOV

451

  if (pCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;

×

UNCOV

452

  if (pCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;

×

UNCOV

453

  if (pCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;

×

UNCOV

454

  if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;

×

UNCOV

455

  if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;

×

UNCOV

456

  if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;

×

UNCOV

457

  if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;

×

UNCOV

458

  if (pCfg->daysToKeep0 < pCfg->daysPerFile) return code;

×

UNCOV

459

  if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return code;

×

UNCOV

460

  if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return code;

×

UNCOV

461

  if (pCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET) return code;

×

UNCOV

462

  if (pCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;

×

UNCOV

463

  if (pCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;

×

UNCOV

464

  if (pCfg->minRows > pCfg->maxRows) return code;

×

UNCOV

465

  if (pCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;

×

UNCOV

466

  if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;

×

UNCOV

467

  if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) return code;

×

UNCOV

468

  if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) return code;

×

UNCOV

469

  if (pCfg->replications < TSDB_MIN_DB_REPLICA || pCfg->replications > TSDB_MAX_DB_REPLICA) return code;

×

UNCOV

471

  if ((pCfg->replications == 2) ^ (pCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;

×

UNCOV

472

  if (pCfg->encryptAlgorithm < TSDB_MIN_ENCRYPT_ALGO || pCfg->encryptAlgorithm > TSDB_MAX_ENCRYPT_ALGO) return code;

×

UNCOV

478

  if (pCfg->strict < TSDB_DB_STRICT_OFF || pCfg->strict > TSDB_DB_STRICT_ON) return code;

×

UNCOV

479

  if (pCfg->schemaless < TSDB_DB_SCHEMALESS_OFF || pCfg->schemaless > TSDB_DB_SCHEMALESS_ON) return code;

×

UNCOV

480

  if (pCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;

×

UNCOV

481

  if (pCfg->hashMethod != 1) return code;

×

UNCOV

482

  if (pCfg->replications > mndGetDnodeSize(pMnode)) {

×

483

    code = TSDB_CODE_MND_NO_ENOUGH_DNODES;

×

484

    TAOS_RETURN(code);

×

UNCOV

486

  if (pCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;

×

UNCOV

487

  if (pCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;

×

UNCOV

488

  if (pCfg->walRollPeriod < TSDB_DB_MIN_WAL_ROLL_PERIOD) return code;

×

UNCOV

489

  if (pCfg->walSegmentSize < TSDB_DB_MIN_WAL_SEGMENT_SIZE) return code;

×

UNCOV

490

  if (pCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pCfg->sstTrigger > TSDB_MAX_STT_TRIGGER) return code;

×

UNCOV

491

  if (pCfg->hashPrefix < TSDB_MIN_HASH_PREFIX || pCfg->hashPrefix > TSDB_MAX_HASH_PREFIX) return code;

×

UNCOV

492

  if (pCfg->hashSuffix < TSDB_MIN_HASH_SUFFIX || pCfg->hashSuffix > TSDB_MAX_HASH_SUFFIX) return code;

×

UNCOV

493

  if ((pCfg->hashSuffix * pCfg->hashPrefix) < 0) return code;

×

UNCOV

494

  if ((pCfg->hashPrefix + pCfg->hashSuffix) >= (TSDB_TABLE_NAME_LEN - 1)) return code;

×

UNCOV

495

  if (pCfg->tsdbPageSize < TSDB_MIN_TSDB_PAGESIZE || pCfg->tsdbPageSize > TSDB_MAX_TSDB_PAGESIZE) return code;

×

UNCOV

496

  if (taosArrayGetSize(pCfg->pRetensions) != pCfg->numOfRetensions) return code;

×

UNCOV

498

  if (pCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return code;

×

UNCOV

499

  if (pCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return code;

×

UNCOV

500

  if (pCfg->s3Compact < TSDB_MIN_S3_COMPACT || pCfg->s3Compact > TSDB_MAX_S3_COMPACT) return code;

×

UNCOV

502

  if (pCfg->compactInterval != 0 &&

×

UNCOV

503

      (pCfg->compactInterval < TSDB_MIN_COMPACT_INTERVAL || pCfg->compactInterval > pCfg->daysToKeep2))

×

504

    return code;

×

UNCOV

505

  if (pCfg->compactStartTime != 0 &&

×

UNCOV

506

      (pCfg->compactStartTime < -pCfg->daysToKeep2 || pCfg->compactStartTime > -pCfg->daysPerFile))

×

507

    return code;

×

UNCOV

508

  if (pCfg->compactEndTime != 0 &&

×

UNCOV

509

      (pCfg->compactEndTime < -pCfg->daysToKeep2 || pCfg->compactEndTime > -pCfg->daysPerFile))

×

510

    return code;

×

UNCOV

511

  if (pCfg->compactStartTime != 0 && pCfg->compactEndTime != 0 && pCfg->compactStartTime >= pCfg->compactEndTime)

×

512

    return code;

×

UNCOV

513

  if (pCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET || pCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)

×

514

    return code;

×

UNCOV

516

  code = 0;

×

UNCOV

517

  TAOS_RETURN(code);

×

UNCOV

520

static int32_t mndCheckInChangeDbCfg(SMnode *pMnode, SDbCfg *pOldCfg, SDbCfg *pNewCfg) {

×

UNCOV

521

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

×

UNCOV

522

  if (pNewCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pNewCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;

×

UNCOV

523

  if (pNewCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pNewCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;

×

UNCOV

524

  if (pNewCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pNewCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;

×

UNCOV

525

  if (pNewCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pNewCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;

×

UNCOV

526

  if (pNewCfg->daysToKeep0 < TSDB_MIN_KEEP || pNewCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;

×

UNCOV

527

  if (pNewCfg->daysToKeep1 < TSDB_MIN_KEEP || pNewCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;

×

UNCOV

528

  if (pNewCfg->daysToKeep2 < TSDB_MIN_KEEP || pNewCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;

×

UNCOV

529

  if (pNewCfg->daysToKeep0 < pNewCfg->daysPerFile) return code;

×

UNCOV

530

  if (pNewCfg->daysToKeep0 > pNewCfg->daysToKeep1) return code;

×

UNCOV

531

  if (pNewCfg->daysToKeep1 > pNewCfg->daysToKeep2) return code;

×

UNCOV

532

  if (pNewCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pNewCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET)

×

533

    return code;

×

UNCOV

534

  if (pNewCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pNewCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;

×

UNCOV

535

  if (pNewCfg->walLevel < TSDB_MIN_WAL_LEVEL || pNewCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;

×

UNCOV

536

  if (pNewCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pNewCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;

×

UNCOV

537

  if (pNewCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pNewCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;

×

UNCOV

538

  if (pNewCfg->replications < TSDB_MIN_DB_REPLICA || pNewCfg->replications > TSDB_MAX_DB_REPLICA) return code;

×

UNCOV

540

  if ((pNewCfg->replications == 2) ^ (pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;

×

UNCOV

541

  if (pNewCfg->replications == 2 && pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR) {

×

UNCOV

542

    if (pOldCfg->replications != 1 && pOldCfg->replications != 2) {

×

UNCOV

543

      terrno = TSDB_CODE_OPS_NOT_SUPPORT;

×

UNCOV

544

      return code;

×

UNCOV

547

  if (pNewCfg->replications != 2 && pOldCfg->replications == 2) {

×

548

    terrno = TSDB_CODE_OPS_NOT_SUPPORT;

×

549

    return code;

×

UNCOV

555

  if (pNewCfg->walLevel == 0 && pOldCfg->replications > 1) {

×

556

    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;

×

557

    return code;

×

UNCOV

559

  if (pNewCfg->replications > 1 && pOldCfg->walLevel == 0) {

×

560

    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;

×

561

    return code;

×

UNCOV

564

  if (pNewCfg->sstTrigger != pOldCfg->sstTrigger &&

×

565

      (pNewCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pNewCfg->sstTrigger > TSDB_MAX_STT_TRIGGER))

×

566

    return code;

×

UNCOV

567

  if (pNewCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pNewCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;

×

UNCOV

568

  if (pNewCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pNewCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;

×

UNCOV

569

  if (pNewCfg->minRows > pNewCfg->maxRows) return code;

×

UNCOV

570

  if (pNewCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;

×

UNCOV

571

  if (pNewCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;

×

UNCOV

572

  if (pNewCfg->strict < TSDB_DB_STRICT_OFF || pNewCfg->strict > TSDB_DB_STRICT_ON) return code;

×

UNCOV

573

  if (pNewCfg->replications > mndGetDnodeSize(pMnode)) {

×

574

    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;

×

575

    return code;

×

UNCOV

577

  if (pNewCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pNewCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return code;

×

UNCOV

578

  if (pNewCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pNewCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return code;

×

UNCOV

579

  if (pNewCfg->s3Compact < TSDB_MIN_S3_COMPACT || pNewCfg->s3Compact > TSDB_MAX_S3_COMPACT) return code;

×

UNCOV

581

  if (pNewCfg->compactInterval != 0 &&

×

582

      (pNewCfg->compactInterval < TSDB_MIN_COMPACT_INTERVAL || pNewCfg->compactInterval > pNewCfg->daysToKeep2))

×

583

    return code;

×

UNCOV

584

  if (pNewCfg->compactStartTime != 0 &&

×

585

      (pNewCfg->compactStartTime < -pNewCfg->daysToKeep2 || pNewCfg->compactStartTime > -pNewCfg->daysPerFile))

×

586

    return code;

×

UNCOV

587

  if (pNewCfg->compactEndTime != 0 &&

×

588

      (pNewCfg->compactEndTime < -pNewCfg->daysToKeep2 || pNewCfg->compactEndTime > -pNewCfg->daysPerFile))

×

589

    return code;

×

UNCOV

590

  if (pNewCfg->compactStartTime != 0 && pNewCfg->compactEndTime != 0 &&

×

591

      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)

×

592

    return code;

×

UNCOV

593

  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||

×

UNCOV

594

      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)

×

595

    return code;

×

UNCOV

597

  code = 0;

×

UNCOV

598

  TAOS_RETURN(code);

×

UNCOV

601

static void mndSetDefaultDbCfg(SDbCfg *pCfg) {

×

UNCOV

602

  if (pCfg->numOfVgroups < 0) pCfg->numOfVgroups = TSDB_DEFAULT_VN_PER_DB;

×

UNCOV

603

  if (pCfg->numOfStables < 0) pCfg->numOfStables = TSDB_DEFAULT_DB_SINGLE_STABLE;

×

UNCOV

604

  if (pCfg->buffer < 0) pCfg->buffer = TSDB_DEFAULT_BUFFER_PER_VNODE;

×

UNCOV

605

  if (pCfg->pageSize < 0) pCfg->pageSize = TSDB_DEFAULT_PAGESIZE_PER_VNODE;

×

UNCOV

606

  if (pCfg->pages < 0) pCfg->pages = TSDB_DEFAULT_PAGES_PER_VNODE;

×

UNCOV

607

  if (pCfg->daysPerFile < 0) pCfg->daysPerFile = TSDB_DEFAULT_DURATION_PER_FILE;

×

UNCOV

608

  if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = TSDB_DEFAULT_KEEP;

×

UNCOV

609

  if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = pCfg->daysToKeep0;

×

UNCOV

610

  if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = pCfg->daysToKeep1;

×

UNCOV

611

  if (pCfg->keepTimeOffset < 0) pCfg->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;

×

UNCOV

612

  if (pCfg->minRows < 0) pCfg->minRows = TSDB_DEFAULT_MINROWS_FBLOCK;

×

UNCOV

613

  if (pCfg->maxRows < 0) pCfg->maxRows = TSDB_DEFAULT_MAXROWS_FBLOCK;

×

UNCOV

614

  if (pCfg->walFsyncPeriod < 0) pCfg->walFsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;

×

UNCOV

615

  if (pCfg->walLevel < 0) pCfg->walLevel = TSDB_DEFAULT_WAL_LEVEL;

×

UNCOV

616

  if (pCfg->precision < 0) pCfg->precision = TSDB_DEFAULT_PRECISION;

×

UNCOV

617

  if (pCfg->compression < 0) pCfg->compression = TSDB_DEFAULT_COMP_LEVEL;

×

UNCOV

618

  if (pCfg->replications < 0) pCfg->replications = TSDB_DEFAULT_DB_REPLICA;

×

UNCOV

619

  if (pCfg->strict < 0) pCfg->strict = TSDB_DEFAULT_DB_STRICT;

×

UNCOV

620

  if (pCfg->cacheLast < 0) pCfg->cacheLast = TSDB_DEFAULT_CACHE_MODEL;

×

UNCOV

621

  if (pCfg->cacheLastSize <= 0) pCfg->cacheLastSize = TSDB_DEFAULT_CACHE_SIZE;

×

UNCOV

622

  if (pCfg->numOfRetensions < 0) pCfg->numOfRetensions = 0;

×

UNCOV

623

  if (pCfg->schemaless < 0) pCfg->schemaless = TSDB_DB_SCHEMALESS_OFF;

×

UNCOV

624

  if (pCfg->walRetentionPeriod < 0 && pCfg->walRetentionPeriod != -1)

×

625

    pCfg->walRetentionPeriod = TSDB_REPS_DEF_DB_WAL_RET_PERIOD;

×

UNCOV

626

  if (pCfg->walRetentionSize < 0 && pCfg->walRetentionSize != -1)

×

627

    pCfg->walRetentionSize = TSDB_REPS_DEF_DB_WAL_RET_SIZE;

×

UNCOV

628

  if (pCfg->walRollPeriod < 0) pCfg->walRollPeriod = TSDB_REPS_DEF_DB_WAL_ROLL_PERIOD;

×

UNCOV

629

  if (pCfg->walSegmentSize < 0) pCfg->walSegmentSize = TSDB_DEFAULT_DB_WAL_SEGMENT_SIZE;

×

UNCOV

630

  if (pCfg->sstTrigger <= 0) pCfg->sstTrigger = TSDB_DEFAULT_SST_TRIGGER;

×

UNCOV

631

  if (pCfg->tsdbPageSize <= 0) pCfg->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE;

×

UNCOV

632

  if (pCfg->s3ChunkSize <= 0) pCfg->s3ChunkSize = TSDB_DEFAULT_S3_CHUNK_SIZE;

×

UNCOV

633

  if (pCfg->s3KeepLocal <= 0) pCfg->s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL;

×

UNCOV

634

  if (pCfg->s3Compact < 0) pCfg->s3Compact = TSDB_DEFAULT_S3_COMPACT;

×

UNCOV

635

  if (pCfg->withArbitrator < 0) pCfg->withArbitrator = TSDB_DEFAULT_DB_WITH_ARBITRATOR;

×

UNCOV

636

  if (pCfg->encryptAlgorithm < 0) pCfg->encryptAlgorithm = TSDB_DEFAULT_ENCRYPT_ALGO;

×

UNCOV

637

×

UNCOV

639

static int32_t mndSetCreateDbPrepareAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

×

UNCOV

640

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

UNCOV

641

  if (pDbRaw == NULL) return -1;

×

UNCOV

643

  if (mndTransAppendPrepareLog(pTrans, pDbRaw) != 0) return -1;

×

UNCOV

644

  if (sdbSetRawStatus(pDbRaw, SDB_STATUS_CREATING) != 0) return -1;

×

UNCOV

645

  return 0;

×

UNCOV

648

static int32_t mndSetNewVgPrepareActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

×

UNCOV

649

  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

×

UNCOV

650

    if (mndAddNewVgPrepareAction(pMnode, pTrans, (pVgroups + v)) != 0) return -1;

×

UNCOV

652

  return 0;

×

655

static int32_t mndSetCreateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

×

656

  int32_t  code = 0;

×

657

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

658

  if (pDbRaw == NULL) {

×

659

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

660

    if (terrno != 0) code = terrno;

×

661

    TAOS_RETURN(code);

×

663

  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pDbRaw));

×

664

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE));

×

666

  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

×

667

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

668

    if (pVgRaw == NULL) {

×

669

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

670

      if (terrno != 0) code = terrno;

×

671

      TAOS_RETURN(code);

×

673

    TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));

×

674

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE));

×

677

  if (pDb->cfg.withArbitrator) {

×

678

    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

×

679

      SVgObj   *pVgObj = pVgroups + v;

×

680

      SArbGroup arbGroup = {0};

×

681

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

682

      TAOS_CHECK_RETURN(mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup));

×

686

  TAOS_RETURN(code);

×

UNCOV

689

static int32_t mndSetCreateDbUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

×

UNCOV

690

  int32_t  code = 0;

×

UNCOV

691

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

UNCOV

692

  if (pDbRaw == NULL) {

×

693

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

694

    if (terrno != 0) code = terrno;

×

695

    TAOS_RETURN(code);

×

UNCOV

697

  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));

×

UNCOV

698

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));

×

UNCOV

700

  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

×

UNCOV

701

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

UNCOV

702

    if (pVgRaw == NULL) {

×

703

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

704

      if (terrno != 0) code = terrno;

×

705

      TAOS_RETURN(code);

×

UNCOV

707

    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));

×

UNCOV

708

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));

×

UNCOV

711

  if (pDb->cfg.withArbitrator) {

×

UNCOV

712

    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

×

UNCOV

713

      SVgObj   *pVgObj = pVgroups + v;

×

UNCOV

714

      SArbGroup arbGroup = {0};

×

UNCOV

715

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

UNCOV

716

      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));

×

UNCOV

720

  TAOS_RETURN(code);

×

UNCOV

723

static int32_t mndSetCreateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups,

×

UNCOV

725

  int32_t  code = 0;

×

UNCOV

726

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

UNCOV

727

  if (pDbRaw == NULL) {

×

728

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

729

    if (terrno != 0) code = terrno;

×

730

    TAOS_RETURN(code);

×

UNCOV

732

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));

×

UNCOV

733

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));

×

UNCOV

735

  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

×

UNCOV

736

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

UNCOV

737

    if (pVgRaw == NULL) {

×

738

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

739

      if (terrno != 0) code = terrno;

×

740

      TAOS_RETURN(code);

×

UNCOV

742

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));

×

UNCOV

743

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));

×

UNCOV

746

  if (pDb->cfg.withArbitrator) {

×

UNCOV

747

    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

×

UNCOV

748

      SVgObj   *pVgObj = pVgroups + v;

×

UNCOV

749

      SArbGroup arbGroup = {0};

×

UNCOV

750

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

UNCOV

751

      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));

×

UNCOV

755

  if (pUserDuped) {

×

UNCOV

756

    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);

×

UNCOV

757

    if (pUserRaw == NULL) {

×

758

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

759

      if (terrno != 0) code = terrno;

×

760

      TAOS_RETURN(code);

×

UNCOV

762

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));

×

UNCOV

763

    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));

×

UNCOV

766

  TAOS_RETURN(code);

×

UNCOV

769

static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

×

UNCOV

770

  int32_t code = 0;

×

UNCOV

771

  for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {

×

UNCOV

772

    SVgObj *pVgroup = pVgroups + vg;

×

UNCOV

774

    for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {

×

UNCOV

775

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

UNCOV

776

      TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid));

×

UNCOV

780

  TAOS_RETURN(code);

×

UNCOV

783

static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

×

UNCOV

784

  int32_t code = 0;

×

UNCOV

785

  for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {

×

UNCOV

786

    SVgObj *pVgroup = pVgroups + vg;

×

UNCOV

788

    for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {

×

UNCOV

789

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

UNCOV

790

      TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, false));

×

UNCOV

794

  TAOS_RETURN(code);

×

UNCOV

797

static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser, SArray *dnodeList) {

×

UNCOV

798

  int32_t  code = 0;

×

UNCOV

799

  SUserObj newUserObj = {0};

×

UNCOV

800

  SDbObj   dbObj = {0};

×

UNCOV

801

  (void)memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);

×

UNCOV

802

  (void)memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);

×

UNCOV

803

  dbObj.createdTime = taosGetTimestampMs();

×

UNCOV

804

  dbObj.updateTime = dbObj.createdTime;

×

UNCOV

805

  dbObj.uid = mndGenerateUid(dbObj.name, TSDB_DB_FNAME_LEN);

×

UNCOV

806

  dbObj.cfgVersion = 1;

×

UNCOV

807

  dbObj.vgVersion = 1;

×

UNCOV

808

  dbObj.tsmaVersion = 1;

×

UNCOV

809

  (void)memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);

×

UNCOV

810

  dbObj.cfg = (SDbCfg){

×

UNCOV

811

      .numOfVgroups = pCreate->numOfVgroups,

×

UNCOV

812

      .numOfStables = pCreate->numOfStables,

×

UNCOV

813

      .buffer = pCreate->buffer,

×

UNCOV

814

      .pageSize = pCreate->pageSize,

×

UNCOV

815

      .pages = pCreate->pages,

×

UNCOV

816

      .cacheLastSize = pCreate->cacheLastSize,

×

UNCOV

817

      .daysPerFile = pCreate->daysPerFile,

×

UNCOV

818

      .daysToKeep0 = pCreate->daysToKeep0,

×

UNCOV

819

      .daysToKeep1 = pCreate->daysToKeep1,

×

UNCOV

820

      .daysToKeep2 = pCreate->daysToKeep2,

×

UNCOV

821

      .keepTimeOffset = pCreate->keepTimeOffset,

×

UNCOV

822

      .minRows = pCreate->minRows,

×

UNCOV

823

      .maxRows = pCreate->maxRows,

×

UNCOV

824

      .walFsyncPeriod = pCreate->walFsyncPeriod,

×

UNCOV

825

      .walLevel = pCreate->walLevel,

×

UNCOV

826

      .precision = pCreate->precision,

×

UNCOV

827

      .compression = pCreate->compression,

×

UNCOV

828

      .replications = pCreate->replications,

×

UNCOV

829

      .strict = pCreate->strict,

×

UNCOV

830

      .cacheLast = pCreate->cacheLast,

×

UNCOV

832

      .schemaless = pCreate->schemaless,

×

UNCOV

833

      .walRetentionPeriod = pCreate->walRetentionPeriod,

×

UNCOV

834

      .walRetentionSize = pCreate->walRetentionSize,

×

UNCOV

835

      .walRollPeriod = pCreate->walRollPeriod,

×

UNCOV

836

      .walSegmentSize = pCreate->walSegmentSize,

×

UNCOV

837

      .sstTrigger = pCreate->sstTrigger,

×

UNCOV

838

      .hashPrefix = pCreate->hashPrefix,

×

UNCOV

839

      .hashSuffix = pCreate->hashSuffix,

×

UNCOV

840

      .s3ChunkSize = pCreate->s3ChunkSize,

×

UNCOV

841

      .s3KeepLocal = pCreate->s3KeepLocal,

×

UNCOV

842

      .s3Compact = pCreate->s3Compact,

×

UNCOV

843

      .tsdbPageSize = pCreate->tsdbPageSize,

×

UNCOV

844

      .withArbitrator = pCreate->withArbitrator,

×

UNCOV

845

      .encryptAlgorithm = pCreate->encryptAlgorithm,

×

UNCOV

846

      .compactInterval = pCreate->compactInterval,

×

UNCOV

847

      .compactStartTime = pCreate->compactStartTime,

×

UNCOV

848

      .compactEndTime = pCreate->compactEndTime,

×

UNCOV

849

      .compactTimeOffset = pCreate->compactTimeOffset,

×

UNCOV

852

  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;

×

UNCOV

853

  dbObj.cfg.pRetensions = pCreate->pRetensions;

×

UNCOV

855

  mndSetDefaultDbCfg(&dbObj.cfg);

×

UNCOV

857

  if ((code = mndCheckDbName(dbObj.name, pUser)) != 0) {

×

858

    mError("db:%s, failed to create, check db name failed, since %s", pCreate->db, terrstr());

×

859

    TAOS_RETURN(code);

×

UNCOV

862

  if ((code = mndCheckDbCfg(pMnode, &dbObj.cfg)) != 0) {

×

UNCOV

863

    mError("db:%s, failed to create, check db cfg failed, since %s", pCreate->db, terrstr());

×

UNCOV

864

    TAOS_RETURN(code);

×

UNCOV

867

  if (dbObj.cfg.hashPrefix > 0) {

×

UNCOV

868

    int32_t dbLen = strlen(dbObj.name) + 1;

×

UNCOV

869

    mInfo("db:%s, hashPrefix adjust from %d to %d", dbObj.name, dbObj.cfg.hashPrefix, dbObj.cfg.hashPrefix + dbLen);

×

UNCOV

870

    dbObj.cfg.hashPrefix += dbLen;

×

UNCOV

871

  } else if (dbObj.cfg.hashPrefix < 0) {

×

UNCOV

872

    int32_t dbLen = strlen(dbObj.name) + 1;

×

UNCOV

873

    mInfo("db:%s, hashPrefix adjust from %d to %d", dbObj.name, dbObj.cfg.hashPrefix, dbObj.cfg.hashPrefix - dbLen);

×

UNCOV

874

    dbObj.cfg.hashPrefix -= dbLen;

×

UNCOV

877

  SVgObj *pVgroups = NULL;

×

UNCOV

878

  if ((code = mndAllocVgroup(pMnode, &dbObj, &pVgroups, dnodeList)) != 0) {

×

UNCOV

879

    mError("db:%s, failed to create, alloc vgroup failed, since %s", pCreate->db, terrstr());

×

UNCOV

880

    TAOS_RETURN(code);

×

UNCOV

884

  SUserObj *pNewUserDuped = NULL;

×

UNCOV

885

  if (!pUser->superUser) {

×

UNCOV

886

    TAOS_CHECK_GOTO(mndUserDupObj(pUser, &newUserObj), NULL, _OVER);

×

UNCOV

887

    TAOS_CHECK_GOTO(taosHashPut(newUserObj.readDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),

×

UNCOV

889

    TAOS_CHECK_GOTO(taosHashPut(newUserObj.writeDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),

×

UNCOV

891

    pNewUserDuped = &newUserObj;

×

UNCOV

894

  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "create-db");

×

UNCOV

895

  if (pTrans == NULL) {

×

896

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

897

    if (terrno != 0) code = terrno;

×

898

    goto _OVER;

×

UNCOV

901

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

×

UNCOV

903

  mndTransSetDbName(pTrans, dbObj.name, NULL);

×

UNCOV

904

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

×

UNCOV

906

  mndTransSetOper(pTrans, MND_OPER_CREATE_DB);

×

UNCOV

907

  TAOS_CHECK_GOTO(mndSetCreateDbPrepareAction(pMnode, pTrans, &dbObj), NULL, _OVER);

×

UNCOV

908

  TAOS_CHECK_GOTO(mndSetCreateDbRedoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

×

UNCOV

909

  TAOS_CHECK_GOTO(mndSetNewVgPrepareActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

×

UNCOV

910

  TAOS_CHECK_GOTO(mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

×

UNCOV

911

  TAOS_CHECK_GOTO(mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups, pNewUserDuped), NULL, _OVER);

×

UNCOV

912

  TAOS_CHECK_GOTO(mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

×

UNCOV

913

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

×

UNCOV

915

_OVER:

×

UNCOV

916

  taosMemoryFree(pVgroups);

×

UNCOV

917

  mndUserFreeObj(&newUserObj);

×

UNCOV

918

  mndTransDrop(pTrans);

×

UNCOV

919

  TAOS_RETURN(code);

×

UNCOV

922

static int32_t mndCheckDbEncryptKey(SMnode *pMnode, SCreateDbReq *pReq) {

×

UNCOV

923

  int32_t    code = 0;

×

UNCOV

924

  SSdb      *pSdb = pMnode->pSdb;

×

UNCOV

925

  SDnodeObj *pDnode = NULL;

×

UNCOV

926

  void      *pIter = NULL;

×

UNCOV

929

  if (pReq->encryptAlgorithm == TSDB_ENCRYPT_ALGO_NONE) goto _exit;

×

930

  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB_ENCRYPTION), NULL, _exit);

×

931

  if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {

×

932

    code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;

×

933

    mError("db:%s, failed to check encryption key:%" PRIi8 " in mnode leader since it's not loaded", pReq->db,

×

935

    goto _exit;

×

938

  int64_t curMs = taosGetTimestampMs();

×

939

  while ((pIter = sdbFetch(pSdb, SDB_DNODE, pIter, (void **)&pDnode))) {

×

940

    bool online = false;

×

941

    if ((pDnode->encryptionKeyStat != tsEncryptionKeyStat || pDnode->encryptionKeyChksum != tsEncryptionKeyChksum) &&

×

942

        (online = mndIsDnodeOnline(pDnode, curMs))) {

×

943

      code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;

×

944

      mError("db:%s, failed to check encryption key:%" PRIi8

×

948

      sdbCancelFetch(pSdb, pIter);

×

949

      sdbRelease(pSdb, pDnode);

×

950

      break;

×

952

    sdbRelease(pSdb, pDnode);

×

960

_exit:

×

UNCOV

961

  TAOS_RETURN(code);

×

UNCOV

975

static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {

×

UNCOV

976

  SMnode      *pMnode = pReq->info.node;

×

UNCOV

977

  int32_t      code = -1;

×

UNCOV

978

  int32_t      lino = 0;

×

UNCOV

979

  SDbObj      *pDb = NULL;

×

UNCOV

980

  SUserObj    *pUser = NULL;

×

UNCOV

981

  SCreateDbReq createReq = {0};

×

UNCOV

982

  SArray      *dnodeList = NULL;

×

UNCOV

984

  dnodeList = taosArrayInit(mndGetDnodeSize(pMnode), sizeof(int32_t));

×

UNCOV

985

  TSDB_CHECK_NULL(dnodeList, code, lino, _OVER, TSDB_CODE_OUT_OF_MEMORY);

×

UNCOV

987

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

×

UNCOV

994

  mInfo("db:%s, start to create, vgroups:%d", createReq.db, createReq.numOfVgroups);

×

UNCOV

996

  pDb = mndAcquireDb(pMnode, createReq.db);

×

UNCOV

997

  if (pDb != NULL) {

×

UNCOV

998

    if (createReq.ignoreExist) {

×

UNCOV

999

      mInfo("db:%s, already exist, ignore exist is set", createReq.db);

×

UNCOV

1000

      code = 0;

×

UNCOV

1001

      goto _OVER;

×

UNCOV

1003

      code = TSDB_CODE_MND_DB_ALREADY_EXIST;

×

UNCOV

1004

      goto _OVER;

×

UNCOV

1007

    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {

×

UNCOV

1008

      code = terrno;

×

UNCOV

1009

      goto _OVER;

×

UNCOV

1010

    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {

×

1011

      goto _OVER;

×

UNCOV

1012

    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {

×

1015

      goto _OVER;

×

UNCOV

1019

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DB, NULL), &lino, _OVER);

×

UNCOV

1021

  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB), &lino, _OVER);

×

UNCOV

1023

  if (createReq.replications == 2) {

×

UNCOV

1024

    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), &lino, _OVER);

×

UNCOV

1027

  TAOS_CHECK_GOTO(mndCheckDbEncryptKey(pMnode, &createReq), &lino, _OVER);

×

UNCOV

1029

  TAOS_CHECK_GOTO(mndCheckDbDnodeList(pMnode, createReq.db, createReq.dnodeListStr, dnodeList), &lino, _OVER);

×

UNCOV

1031

  TAOS_CHECK_GOTO(mndAcquireUser(pMnode, pReq->info.conn.user, &pUser), &lino, _OVER);

×

UNCOV

1033

  TAOS_CHECK_GOTO(mndCreateDb(pMnode, pReq, &createReq, pUser, dnodeList), &lino, _OVER);

×

UNCOV

1034

  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

×

UNCOV

1036

  SName name = {0};

×

UNCOV

1037

  if (tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB) < 0)

×

1038

    mError("db:%s, failed to parse db name", createReq.db);

×

UNCOV

1040

  auditRecord(pReq, pMnode->clusterId, "createDB", name.dbname, "", createReq.sql, createReq.sqlLen);

×

UNCOV

1042

_OVER:

×

UNCOV

1043

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

×

UNCOV

1044

    mError("db:%s, failed to create at line:%d since %s", createReq.db, lino, tstrerror(code));

×

UNCOV

1047

  mndReleaseDb(pMnode, pDb);

×

UNCOV

1048

  mndReleaseUser(pMnode, pUser);

×

UNCOV

1049

  tFreeSCreateDbReq(&createReq);

×

UNCOV

1050

  taosArrayDestroy(dnodeList);

×

UNCOV

1052

  TAOS_RETURN(code);

×

UNCOV

1055

static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {

×

UNCOV

1056

  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;

×

UNCOV

1058

  if (pAlter->buffer > 0 && pAlter->buffer != pDb->cfg.buffer) {

×

1059

    pDb->cfg.buffer = pAlter->buffer;

×

1060

    code = 0;

×

UNCOV

1063

  if (pAlter->pages > 0 && pAlter->pages != pDb->cfg.pages) {

×

1064

    pDb->cfg.pages = pAlter->pages;

×

1065

    code = 0;

×

UNCOV

1068

  if (pAlter->pageSize > 0 && pAlter->pageSize != pDb->cfg.pageSize) {

×

1069

    pDb->cfg.pageSize = pAlter->pageSize;

×

1070

    code = 0;

×

UNCOV

1073

  if (pAlter->daysPerFile > 0 && pAlter->daysPerFile != pDb->cfg.daysPerFile) {

×

1074

    pDb->cfg.daysPerFile = pAlter->daysPerFile;

×

1075

    code = 0;

×

UNCOV

1078

  if (pAlter->daysToKeep0 > 0 && pAlter->daysToKeep0 != pDb->cfg.daysToKeep0) {

×

UNCOV

1079

    pDb->cfg.daysToKeep0 = pAlter->daysToKeep0;

×

UNCOV

1080

    code = 0;

×

UNCOV

1083

  if (pAlter->daysToKeep1 > 0 && pAlter->daysToKeep1 != pDb->cfg.daysToKeep1) {

×

UNCOV

1084

    pDb->cfg.daysToKeep1 = pAlter->daysToKeep1;

×

UNCOV

1085

    code = 0;

×

UNCOV

1088

  if (pAlter->daysToKeep2 > 0 && pAlter->daysToKeep2 != pDb->cfg.daysToKeep2) {

×

UNCOV

1089

    pDb->cfg.daysToKeep2 = pAlter->daysToKeep2;

×

UNCOV

1090

    code = 0;

×

UNCOV

1093

  if (pAlter->keepTimeOffset >= 0 && pAlter->keepTimeOffset != pDb->cfg.keepTimeOffset) {

×

UNCOV

1094

    pDb->cfg.keepTimeOffset = pAlter->keepTimeOffset;

×

UNCOV

1095

    code = 0;

×

UNCOV

1098

  if (pAlter->walFsyncPeriod >= 0 && pAlter->walFsyncPeriod != pDb->cfg.walFsyncPeriod) {

×

UNCOV

1099

    pDb->cfg.walFsyncPeriod = pAlter->walFsyncPeriod;

×

UNCOV

1100

    code = 0;

×

UNCOV

1103

  if (pAlter->walLevel >= 0 && pAlter->walLevel != pDb->cfg.walLevel) {

×

UNCOV

1104

    pDb->cfg.walLevel = pAlter->walLevel;

×

UNCOV

1105

    code = 0;

×

UNCOV

1108

  if (pAlter->strict >= 0 && pAlter->strict != pDb->cfg.strict) {

×

1110

    code = TSDB_CODE_OPS_NOT_SUPPORT;

×

UNCOV

1117

  if (pAlter->cacheLast >= 0 && pAlter->cacheLast != pDb->cfg.cacheLast) {

×

UNCOV

1118

    pDb->cfg.cacheLast = pAlter->cacheLast;

×

UNCOV

1119

    code = 0;

×

UNCOV

1122

  if (pAlter->cacheLastSize > 0 && pAlter->cacheLastSize != pDb->cfg.cacheLastSize) {

×

UNCOV

1123

    pDb->cfg.cacheLastSize = pAlter->cacheLastSize;

×

UNCOV

1124

    code = 0;

×

UNCOV

1127

  if (pAlter->replications > 0 && pAlter->replications != pDb->cfg.replications) {

×

UNCOV

1128

    pDb->cfg.replications = pAlter->replications;

×

UNCOV

1129

    pDb->vgVersion++;

×

UNCOV

1130

    code = 0;

×

UNCOV

1133

  if (pAlter->sstTrigger > 0 && pAlter->sstTrigger != pDb->cfg.sstTrigger) {

×

1134

    pDb->cfg.sstTrigger = pAlter->sstTrigger;

×

1135

    pDb->vgVersion++;

×

1136

    code = 0;

×

UNCOV

1139

  if (pAlter->minRows > 0 && pAlter->minRows != pDb->cfg.minRows) {

×

1140

    pDb->cfg.minRows = pAlter->minRows;

×

1141

    pDb->vgVersion++;

×

1142

    code = 0;

×

UNCOV

1145

  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&

×

UNCOV

1146

      pAlter->walRetentionPeriod != pDb->cfg.walRetentionPeriod) {

×

UNCOV

1147

    pDb->cfg.walRetentionPeriod = pAlter->walRetentionPeriod;

×

UNCOV

1148

    pDb->vgVersion++;

×

UNCOV

1149

    code = 0;

×

UNCOV

1152

  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&

×

1153

      pAlter->walRetentionSize != pDb->cfg.walRetentionSize) {

×

1154

    pDb->cfg.walRetentionSize = pAlter->walRetentionSize;

×

1155

    pDb->vgVersion++;

×

1156

    code = 0;

×

UNCOV

1159

  if (pAlter->s3KeepLocal > TSDB_MIN_S3_KEEP_LOCAL && pAlter->s3KeepLocal != pDb->cfg.s3KeepLocal) {

×

1160

    pDb->cfg.s3KeepLocal = pAlter->s3KeepLocal;

×

1161

    pDb->vgVersion++;

×

1162

    code = 0;

×

UNCOV

1165

  if (pAlter->s3Compact > TSDB_MIN_S3_COMPACT && pAlter->s3Compact != pDb->cfg.s3Compact) {

×

1166

    pDb->cfg.s3Compact = pAlter->s3Compact;

×

1167

    pDb->vgVersion++;

×

1168

    code = 0;

×

UNCOV

1171

  if (pAlter->withArbitrator >= TSDB_MIN_DB_WITH_ARBITRATOR && pAlter->withArbitrator != pDb->cfg.withArbitrator) {

×

UNCOV

1172

    pDb->cfg.withArbitrator = pAlter->withArbitrator;

×

UNCOV

1173

    pDb->vgVersion++;

×

UNCOV

1174

    code = 0;

×

UNCOV

1177

  if (pAlter->compactInterval >= TSDB_DEFAULT_COMPACT_INTERVAL && pAlter->compactInterval != pDb->cfg.compactInterval) {

×

1178

    pDb->cfg.compactInterval = pAlter->compactInterval;

×

1179

    pDb->vgVersion++;

×

1180

    code = 0;

×

UNCOV

1183

  bool compactTimeRangeChanged = false;

×

UNCOV

1184

  if (pAlter->compactStartTime != pDb->cfg.compactStartTime &&

×

UNCOV

1185

      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||

×

UNCOV

1186

       pAlter->compactStartTime <= -pDb->cfg.daysPerFile)) {

×

1187

    pDb->cfg.compactStartTime = pAlter->compactStartTime;

×

1188

    compactTimeRangeChanged = true;

×

1189

    code = 0;

×

UNCOV

1192

  if (pAlter->compactEndTime != pDb->cfg.compactEndTime &&

×

UNCOV

1193

      (pAlter->compactEndTime == TSDB_DEFAULT_COMPACT_END_TIME || pAlter->compactEndTime <= -pDb->cfg.daysPerFile)) {

×

1194

    pDb->cfg.compactEndTime = pAlter->compactEndTime;

×

1195

    compactTimeRangeChanged = true;

×

1196

    code = 0;

×

UNCOV

1198

  if(compactTimeRangeChanged) {

×

1199

    pDb->vgVersion++;

×

UNCOV

1202

  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&

×

1203

      pAlter->compactTimeOffset != pDb->cfg.compactTimeOffset) {

×

1204

    pDb->cfg.compactTimeOffset = pAlter->compactTimeOffset;

×

1205

    pDb->vgVersion++;

×

1206

    code = 0;

×

UNCOV

1209

  TAOS_RETURN(code);

×

UNCOV

1212

static int32_t mndSetAlterDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {

×

UNCOV

1213

  int32_t  code = 0;

×

UNCOV

1214

  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);

×

UNCOV

1215

  if (pRedoRaw == NULL) {

×

1216

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1217

    if (terrno != 0) code = terrno;

×

1218

    TAOS_RETURN(code);

×

UNCOV

1220

  if ((code = mndTransAppendPrepareLog(pTrans, pRedoRaw)) != 0) {

×

1221

    sdbFreeRaw(pRedoRaw);

×

1222

    TAOS_RETURN(code);

×

UNCOV

1225

  if ((code = sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY)) != 0) {

×

1226

    sdbFreeRaw(pRedoRaw);

×

1227

    TAOS_RETURN(code);

×

UNCOV

1229

  return 0;

×

UNCOV

1232

static int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {

×

UNCOV

1233

  int32_t  code = 0;

×

UNCOV

1234

  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);

×

UNCOV

1235

  if (pCommitRaw == NULL) {

×

1236

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1237

    if (terrno != 0) code = terrno;

×

1238

    TAOS_RETURN(code);

×

UNCOV

1240

  if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {

×

1241

    sdbFreeRaw(pCommitRaw);

×

1242

    TAOS_RETURN(code);

×

UNCOV

1245

  if ((code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY)) != 0) {

×

1246

    sdbFreeRaw(pCommitRaw);

×

1247

    TAOS_RETURN(code);

×

UNCOV

1249

  TAOS_RETURN(code);

×

UNCOV

1252

static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) {

×

UNCOV

1253

  int32_t code = 0, lino = 0;

×

UNCOV

1254

  SSdb   *pSdb = pMnode->pSdb;

×

UNCOV

1255

  void   *pIter = NULL;

×

UNCOV

1256

  SVgObj *pVgroup = NULL;

×

UNCOV

1257

  SArray *pArray = mndBuildDnodesArray(pMnode, 0, NULL);

×

UNCOV

1259

  TSDB_CHECK_NULL(pArray, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY);

×

UNCOV

1262

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

×

UNCOV

1263

    if (pIter == NULL) break;

×

UNCOV

1265

    if (mndVgroupInDb(pVgroup, pNewDb->uid)) {

×

UNCOV

1266

      SVgObj newVgroup = {0};

×

UNCOV

1267

      TAOS_CHECK_GOTO(mndBuildAlterVgroupAction(pMnode, pTrans, pOldDb, pNewDb, pVgroup, pArray, &newVgroup), &lino,

×

UNCOV

1270

      if (pNewDb->cfg.withArbitrator != pOldDb->cfg.withArbitrator) {

×

1271

        if (pNewDb->cfg.withArbitrator) {

×

1272

          SArbGroup arbGroup = {0};

×

1273

          TAOS_CHECK_GOTO(mndArbGroupInitFromVgObj(&newVgroup, &arbGroup), &lino, _err);

×

1274

          TAOS_CHECK_GOTO(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup), &lino, _err);

×

1276

          SArbGroup arbGroup = {0};

×

1277

          TAOS_CHECK_GOTO(mndArbGroupInitFromVgObj(pVgroup, &arbGroup), &lino, _err);

×

1278

          TAOS_CHECK_GOTO(mndSetDropArbGroupCommitLogs(pTrans, &arbGroup), &lino, _err);

×

UNCOV

1283

    sdbRelease(pSdb, pVgroup);

×

UNCOV

1286

  taosArrayDestroy(pArray);

×

UNCOV

1287

  TAOS_RETURN(code);

×

1289

_err:

×

1290

  mError("db:%s, %s failed at %d since %s", pNewDb->name, __func__, lino, tstrerror(code));

×

1292

  sdbCancelFetch(pSdb, pIter);

×

1293

  sdbRelease(pSdb, pVgroup);

×

1294

  taosArrayDestroy(pArray);

×

1295

  TAOS_RETURN(code);

×

UNCOV

1298

static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *pNew) {

×

UNCOV

1299

  int32_t code = -1;

×

UNCOV

1300

  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "alter-db");

×

UNCOV

1301

  if (pTrans == NULL) {

×

1302

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1303

    if (terrno != 0) code = terrno;

×

1304

    TAOS_RETURN(code);

×

UNCOV

1306

  mInfo("trans:%d, used to alter db:%s", pTrans->id, pOld->name);

×

UNCOV

1307

  mInfo("trans:%d, used to alter db, ableToBeKilled:%d, killMode:%d", pTrans->id, pTrans->ableToBeKilled, pTrans->killMode);

×

UNCOV

1309

  mndTransSetDbName(pTrans, pOld->name, NULL);

×

UNCOV

1310

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

×

UNCOV

1311

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

×

UNCOV

1313

  TAOS_CHECK_GOTO(mndSetAlterDbPrepareLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);

×

UNCOV

1314

  TAOS_CHECK_GOTO(mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);

×

UNCOV

1315

  TAOS_CHECK_GOTO(mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew), NULL, _OVER);

×

UNCOV

1317

  mInfo("trans:%d, used to alter db, ableToBeKilled:%d, killMode:%d", pTrans->id, pTrans->ableToBeKilled, pTrans->killMode);

×

UNCOV

1318

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

×

UNCOV

1319

  code = 0;

×

UNCOV

1321

_OVER:

×

UNCOV

1322

  mndTransDrop(pTrans);

×

UNCOV

1323

  TAOS_RETURN(code);

×

UNCOV

1326

static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {

×

UNCOV

1327

  SMnode     *pMnode = pReq->info.node;

×

UNCOV

1328

  int32_t     code = -1;

×

UNCOV

1329

  SDbObj     *pDb = NULL;

×

UNCOV

1330

  SAlterDbReq alterReq = {0};

×

UNCOV

1331

  SDbObj      dbObj = {0};

×

UNCOV

1333

  TAOS_CHECK_GOTO(tDeserializeSAlterDbReq(pReq->pCont, pReq->contLen, &alterReq), NULL, _OVER);

×

UNCOV

1335

  mInfo("db:%s, start to alter", alterReq.db);

×

UNCOV

1337

  pDb = mndAcquireDb(pMnode, alterReq.db);

×

UNCOV

1338

  if (pDb == NULL) {

×

1339

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1340

    if (terrno != 0) code = terrno;

×

1341

    goto _OVER;

×

UNCOV

1344

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_ALTER_DB, pDb), NULL, _OVER);

×

UNCOV

1346

  if (alterReq.replications == 2) {

×

UNCOV

1347

    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), NULL, _OVER);

×

UNCOV

1350

  int32_t numOfTopics = 0;

×

UNCOV

1351

  TAOS_CHECK_GOTO(mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics), NULL, _OVER);

×

UNCOV

1353

  if (numOfTopics != 0 && alterReq.walRetentionPeriod == 0) {

×

1354

    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;

×

1355

    mError("db:%s, not allowed to set WAL_RETENTION_PERIOD 0 when there are topics defined. numOfTopics:%d", pDb->name,

×

1357

    goto _OVER;

×

UNCOV

1360

  (void)memcpy(&dbObj, pDb, sizeof(SDbObj));

×

UNCOV

1361

  if (dbObj.cfg.pRetensions != NULL) {

×

1362

    dbObj.cfg.pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);

×

1363

    if (dbObj.cfg.pRetensions == NULL) goto _OVER;

×

UNCOV

1366

  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);

×

UNCOV

1367

  if (code != 0) {

×

UNCOV

1368

    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;

×

UNCOV

1369

    goto _OVER;

×

UNCOV

1372

  TAOS_CHECK_GOTO(mndCheckInChangeDbCfg(pMnode, &pDb->cfg, &dbObj.cfg), NULL, _OVER);

×

UNCOV

1374

  dbObj.cfgVersion++;

×

UNCOV

1375

  dbObj.updateTime = taosGetTimestampMs();

×

UNCOV

1376

  code = mndAlterDb(pMnode, pReq, pDb, &dbObj);

×

UNCOV

1378

  if (dbObj.cfg.replications != pDb->cfg.replications) {

×

UNCOV

1380

    mInfo("db:%s, alter db replica from %d to %d", pDb->name, pDb->cfg.replications, dbObj.cfg.replications);

×

UNCOV

1382

    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

×

UNCOV

1385

  SName name = {0};

×

UNCOV

1386

  if (tNameFromString(&name, alterReq.db, T_NAME_ACCT | T_NAME_DB) < 0)

×

1387

    mError("db:%s, failed to parse db name", alterReq.db);

×

UNCOV

1389

  auditRecord(pReq, pMnode->clusterId, "alterDB", name.dbname, "", alterReq.sql, alterReq.sqlLen);

×

UNCOV

1391

_OVER:

×

UNCOV

1392

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

×

UNCOV

1393

    if (terrno != 0) code = terrno;

×

UNCOV

1394

    mError("db:%s, failed to alter since %s", alterReq.db, tstrerror(code));

×

UNCOV

1397

  mndReleaseDb(pMnode, pDb);

×

UNCOV

1398

  taosArrayDestroy(dbObj.cfg.pRetensions);

×

UNCOV

1399

  tFreeSAlterDbReq(&alterReq);

×

UNCOV

1401

  TAOS_RETURN(code);

×

UNCOV

1404

static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb) {

×

UNCOV

1405

  tstrncpy(cfgRsp->db, pDb->name, sizeof(cfgRsp->db));

×

UNCOV

1406

  cfgRsp->dbId = pDb->uid;

×

UNCOV

1407

  cfgRsp->cfgVersion = pDb->cfgVersion;

×

UNCOV

1408

  cfgRsp->numOfVgroups = pDb->cfg.numOfVgroups;

×

UNCOV

1409

  cfgRsp->numOfStables = pDb->cfg.numOfStables;

×

UNCOV

1410

  cfgRsp->buffer = pDb->cfg.buffer;

×

UNCOV

1411

  cfgRsp->cacheSize = pDb->cfg.cacheLastSize;

×

UNCOV

1412

  cfgRsp->pageSize = pDb->cfg.pageSize;

×

UNCOV

1413

  cfgRsp->pages = pDb->cfg.pages;

×

UNCOV

1414

  cfgRsp->daysPerFile = pDb->cfg.daysPerFile;

×

UNCOV

1415

  cfgRsp->daysToKeep0 = pDb->cfg.daysToKeep0;

×

UNCOV

1416

  cfgRsp->daysToKeep1 = pDb->cfg.daysToKeep1;

×

UNCOV

1417

  cfgRsp->daysToKeep2 = pDb->cfg.daysToKeep2;

×

UNCOV

1418

  cfgRsp->keepTimeOffset = pDb->cfg.keepTimeOffset;

×

UNCOV

1419

  cfgRsp->minRows = pDb->cfg.minRows;

×

UNCOV

1420

  cfgRsp->maxRows = pDb->cfg.maxRows;

×

UNCOV

1421

  cfgRsp->walFsyncPeriod = pDb->cfg.walFsyncPeriod;

×

UNCOV

1422

  cfgRsp->hashPrefix = pDb->cfg.hashPrefix;

×

UNCOV

1423

  cfgRsp->hashSuffix = pDb->cfg.hashSuffix;

×

UNCOV

1424

  cfgRsp->hashMethod = pDb->cfg.hashMethod;

×

UNCOV

1425

  cfgRsp->walLevel = pDb->cfg.walLevel;

×

UNCOV

1426

  cfgRsp->precision = pDb->cfg.precision;

×

UNCOV

1427

  cfgRsp->compression = pDb->cfg.compression;

×

UNCOV

1428

  cfgRsp->replications = pDb->cfg.replications;

×

UNCOV

1429

  cfgRsp->strict = pDb->cfg.strict;

×

UNCOV

1430

  cfgRsp->cacheLast = pDb->cfg.cacheLast;

×

UNCOV

1431

  cfgRsp->tsdbPageSize = pDb->cfg.tsdbPageSize;

×

UNCOV

1432

  cfgRsp->walRetentionPeriod = pDb->cfg.walRetentionPeriod;

×

UNCOV

1433

  cfgRsp->walRollPeriod = pDb->cfg.walRollPeriod;

×

UNCOV

1434

  cfgRsp->walRetentionSize = pDb->cfg.walRetentionSize;

×

UNCOV

1435

  cfgRsp->walSegmentSize = pDb->cfg.walSegmentSize;

×

UNCOV

1436

  cfgRsp->numOfRetensions = pDb->cfg.numOfRetensions;

×

UNCOV

1437

  cfgRsp->pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);

×

UNCOV

1438

  cfgRsp->schemaless = pDb->cfg.schemaless;

×

UNCOV

1439

  cfgRsp->sstTrigger = pDb->cfg.sstTrigger;

×

UNCOV

1440

  cfgRsp->s3ChunkSize = pDb->cfg.s3ChunkSize;

×

UNCOV

1441

  cfgRsp->s3KeepLocal = pDb->cfg.s3KeepLocal;

×

UNCOV

1442

  cfgRsp->s3Compact = pDb->cfg.s3Compact;

×

UNCOV

1443

  cfgRsp->withArbitrator = pDb->cfg.withArbitrator;

×

UNCOV

1444

  cfgRsp->encryptAlgorithm = pDb->cfg.encryptAlgorithm;

×

UNCOV

1445

  cfgRsp->compactInterval = pDb->cfg.compactInterval;

×

UNCOV

1446

  cfgRsp->compactStartTime = pDb->cfg.compactStartTime;

×

UNCOV

1447

  cfgRsp->compactEndTime = pDb->cfg.compactEndTime;

×

UNCOV

1448

  cfgRsp->compactTimeOffset = pDb->cfg.compactTimeOffset;

×

UNCOV

1449

×

UNCOV

1451

static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {

×

UNCOV

1452

  SMnode   *pMnode = pReq->info.node;

×

UNCOV

1453

  int32_t   code = -1;

×

UNCOV

1454

  SDbObj   *pDb = NULL;

×

UNCOV

1455

  SDbCfgReq cfgReq = {0};

×

UNCOV

1456

  SDbCfgRsp cfgRsp = {0};

×

UNCOV

1458

  TAOS_CHECK_GOTO(tDeserializeSDbCfgReq(pReq->pCont, pReq->contLen, &cfgReq), NULL, _OVER);

×

UNCOV

1460

  if (strcasecmp(cfgReq.db, TSDB_INFORMATION_SCHEMA_DB) && strcasecmp(cfgReq.db, TSDB_PERFORMANCE_SCHEMA_DB)) {

×

UNCOV

1461

    pDb = mndAcquireDb(pMnode, cfgReq.db);

×

UNCOV

1462

    if (pDb == NULL) {

×

UNCOV

1463

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

UNCOV

1464

      if (terrno != 0) code = terrno;

×

UNCOV

1465

      goto _OVER;

×

UNCOV

1468

    mndDumpDbCfgInfo(&cfgRsp, pDb);

×

UNCOV

1471

  int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);

×

UNCOV

1472

  void   *pRsp = rpcMallocCont(contLen);

×

UNCOV

1473

  if (pRsp == NULL) {

×

1474

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1475

    if (terrno != 0) code = terrno;

×

1476

    goto _OVER;

×

UNCOV

1479

  int32_t ret = 0;

×

UNCOV

1480

  if ((ret = tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp)) < 0) {

×

1481

    code = ret;

×

1482

    goto _OVER;

×

UNCOV

1485

  pReq->info.rsp = pRsp;

×

UNCOV

1486

  pReq->info.rspLen = contLen;

×

UNCOV

1488

  code = 0;

×

UNCOV

1490

_OVER:

×

UNCOV

1492

  tFreeSDbCfgRsp(&cfgRsp);

×

UNCOV

1494

  if (code != 0) {

×

UNCOV

1495

    mError("db:%s, failed to get cfg since %s", cfgReq.db, terrstr());

×

UNCOV

1498

  mndReleaseDb(pMnode, pDb);

×

UNCOV

1500

  TAOS_RETURN(code);

×

UNCOV

1503

static int32_t mndSetDropDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

×

UNCOV

1504

  int32_t  code = 0;

×

UNCOV

1505

  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);

×

UNCOV

1506

  if (pRedoRaw == NULL) {

×

1507

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1508

    if (terrno != 0) code = terrno;

×

1509

    return -1;

×

UNCOV

1511

  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));

×

UNCOV

1512

  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));

×

UNCOV

1514

  SSdb *pSdb = pMnode->pSdb;

×

UNCOV

1515

  void *pIter = NULL;

×

UNCOV

1517

  while (1) {

×

UNCOV

1518

    SArbGroup *pArbGroup = NULL;

×

UNCOV

1519

    pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);

×

UNCOV

1520

    if (pIter == NULL) break;

×

UNCOV

1522

    if (pArbGroup->dbUid == pDb->uid) {

×

UNCOV

1523

      if ((code = mndSetDropArbGroupPrepareLogs(pTrans, pArbGroup)) != 0) {

×

1524

        sdbCancelFetch(pSdb, pIter);

×

1525

        sdbRelease(pSdb, pArbGroup);

×

1526

        TAOS_RETURN(code);

×

UNCOV

1530

    sdbRelease(pSdb, pArbGroup);

×

UNCOV

1533

  TAOS_RETURN(code);

×

UNCOV

1536

static int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

×

UNCOV

1537

  int32_t  code = 0;

×

UNCOV

1538

  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);

×

UNCOV

1539

  if (pCommitRaw == NULL) {

×

1540

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1541

    if (terrno != 0) code = terrno;

×

1542

    return -1;

×

UNCOV

1544

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));

×

UNCOV

1545

  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));

×

UNCOV

1547

  SSdb *pSdb = pMnode->pSdb;

×

UNCOV

1548

  void *pIter = NULL;

×

UNCOV

1550

  while (1) {

×

UNCOV

1551

    SArbGroup *pArbGroup = NULL;

×

UNCOV

1552

    pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);

×

UNCOV

1553

    if (pIter == NULL) break;

×

UNCOV

1555

    if (pArbGroup->dbUid == pDb->uid) {

×

UNCOV

1556

      if ((code = mndSetDropArbGroupCommitLogs(pTrans, pArbGroup)) != 0) {

×

1557

        sdbCancelFetch(pSdb, pIter);

×

1558

        sdbRelease(pSdb, pArbGroup);

×

1559

        TAOS_RETURN(code);

×

UNCOV

1563

    sdbRelease(pSdb, pArbGroup);

×

UNCOV

1566

  while (1) {

×

UNCOV

1567

    SVgObj *pVgroup = NULL;

×

UNCOV

1568

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

×

UNCOV

1569

    if (pIter == NULL) break;

×

UNCOV

1571

    if (pVgroup->dbUid == pDb->uid) {

×

UNCOV

1572

      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);

×

UNCOV

1573

      if (pVgRaw == NULL) {

×

1574

        sdbCancelFetch(pSdb, pIter);

×

1575

        sdbRelease(pSdb, pVgroup);

×

1576

        code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1577

        if (terrno != 0) code = terrno;

×

1578

        TAOS_RETURN(code);

×

UNCOV

1580

      if ((code = mndTransAppendCommitlog(pTrans, pVgRaw)) != 0) {

×

1581

        sdbCancelFetch(pSdb, pIter);

×

1582

        sdbRelease(pSdb, pVgroup);

×

1583

        TAOS_RETURN(code);

×

UNCOV

1585

      if ((code = sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED)) != 0) {

×

1586

        sdbCancelFetch(pSdb, pIter);

×

1587

        sdbRelease(pSdb, pVgroup);

×

1588

        TAOS_RETURN(code);

×

UNCOV

1592

    sdbRelease(pSdb, pVgroup);

×

UNCOV

1595

  while (1) {

×

UNCOV

1596

    SStbObj *pStb = NULL;

×

UNCOV

1597

    pIter = sdbFetch(pSdb, SDB_STB, pIter, (void **)&pStb);

×

UNCOV

1598

    if (pIter == NULL) break;

×

UNCOV

1600

    if (pStb->dbUid == pDb->uid) {

×

UNCOV

1601

      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);

×

UNCOV

1602

      if (pStbRaw == NULL) {

×

1603

        sdbCancelFetch(pSdb, pIter);

×

1604

        sdbRelease(pSdb, pStbRaw);

×

1605

        code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1606

        if (terrno != 0) code = terrno;

×

1607

        return -1;

×

UNCOV

1609

      if ((code = mndTransAppendCommitlog(pTrans, pStbRaw)) != 0) {

×

1610

        sdbCancelFetch(pSdb, pIter);

×

1611

        sdbRelease(pSdb, pStbRaw);

×

1612

        return -1;

×

UNCOV

1614

      if ((code = sdbSetRawStatus(pStbRaw, SDB_STATUS_DROPPED)) != 0) {

×

1615

        sdbCancelFetch(pSdb, pIter);

×

1616

        sdbRelease(pSdb, pStbRaw);

×

1617

        return -1;

×

UNCOV

1621

    sdbRelease(pSdb, pStb);

×

UNCOV

1624

  TAOS_RETURN(code);

×

UNCOV

1627

static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {

×

UNCOV

1628

  int32_t code = 0;

×

UNCOV

1629

  for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {

×

UNCOV

1630

    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

UNCOV

1631

    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, true));

×

UNCOV

1634

  TAOS_RETURN(code);

×

UNCOV

1637

static int32_t mndSetDropDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

×

UNCOV

1638

  int32_t code = 0;

×

UNCOV

1639

  SSdb   *pSdb = pMnode->pSdb;

×

UNCOV

1640

  void   *pIter = NULL;

×

UNCOV

1642

  while (1) {

×

UNCOV

1643

    SVgObj *pVgroup = NULL;

×

UNCOV

1644

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

×

UNCOV

1645

    if (pIter == NULL) break;

×

UNCOV

1647

    if (pVgroup->dbUid == pDb->uid) {

×

UNCOV

1648

      if ((code = mndBuildDropVgroupAction(pMnode, pTrans, pDb, pVgroup)) != 0) {

×

1649

        sdbCancelFetch(pSdb, pIter);

×

1650

        sdbRelease(pSdb, pVgroup);

×

1651

        TAOS_RETURN(code);

×

UNCOV

1655

    sdbRelease(pSdb, pVgroup);

×

UNCOV

1658

  TAOS_RETURN(code);

×

UNCOV

1661

static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {

×

UNCOV

1662

  int32_t    code = 0;

×

UNCOV

1663

  SDropDbRsp dropRsp = {0};

×

UNCOV

1664

  if (pDb != NULL) {

×

UNCOV

1665

    (void)memcpy(dropRsp.db, pDb->name, TSDB_DB_FNAME_LEN);

×

UNCOV

1666

    dropRsp.uid = pDb->uid;

×

UNCOV

1669

  int32_t rspLen = tSerializeSDropDbRsp(NULL, 0, &dropRsp);

×

UNCOV

1670

  void   *pRsp = NULL;

×

UNCOV

1671

  if (useRpcMalloc) {

×

UNCOV

1672

    pRsp = rpcMallocCont(rspLen);

×

UNCOV

1674

    pRsp = taosMemoryMalloc(rspLen);

×

UNCOV

1677

  if (pRsp == NULL) {

×

1678

    code = terrno;

×

1679

    TAOS_RETURN(code);

×

UNCOV

1682

  int32_t ret = 0;

×

UNCOV

1683

  if ((ret = tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp)) < 0) return ret;

×

UNCOV

1684

  *pRspLen = rspLen;

×

UNCOV

1685

  *ppRsp = pRsp;

×

UNCOV

1686

  TAOS_RETURN(code);

×

UNCOV

1689

static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {

×

UNCOV

1690

  int32_t code = -1;

×

UNCOV

1692

  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-db");

×

UNCOV

1693

  if (pTrans == NULL) {

×

1694

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1695

    if (terrno != 0) code = terrno;

×

1696

    goto _OVER;

×

UNCOV

1699

  mInfo("trans:%d start to drop db:%s", pTrans->id, pDb->name);

×

UNCOV

1701

  mndTransSetDbName(pTrans, pDb->name, NULL);

×

UNCOV

1702

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

×

UNCOV

1704

  if (mndTopicExistsForDb(pMnode, pDb)) {

×

UNCOV

1705

    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;

×

UNCOV

1706

    goto _OVER;

×

UNCOV

1709

  TAOS_CHECK_GOTO(mndSetDropDbPrepareLogs(pMnode, pTrans, pDb), NULL, _OVER);

×

UNCOV

1710

  TAOS_CHECK_GOTO(mndSetDropDbCommitLogs(pMnode, pTrans, pDb), NULL, _OVER);

×

UNCOV

1711

  TAOS_CHECK_GOTO(mndDropStreamByDb(pMnode, pTrans, pDb), NULL, _OVER);

×

UNCOV

1713

  TAOS_CHECK_GOTO(mndDropViewByDb(pMnode, pTrans, pDb), NULL, _OVER);

×

UNCOV

1715

  TAOS_CHECK_GOTO(mndDropSmasByDb(pMnode, pTrans, pDb), NULL, _OVER);

×

UNCOV

1716

  TAOS_CHECK_GOTO(mndDropIdxsByDb(pMnode, pTrans, pDb), NULL, _OVER);

×

UNCOV

1717

  TAOS_CHECK_GOTO(mndSetDropDbRedoActions(pMnode, pTrans, pDb), NULL, _OVER);

×

UNCOV

1718

  TAOS_CHECK_GOTO(mndUserRemoveDb(pMnode, pTrans, pDb->name), NULL, _OVER);

×

UNCOV

1720

  int32_t rspLen = 0;

×

UNCOV

1721

  void   *pRsp = NULL;

×

UNCOV

1722

  TAOS_CHECK_GOTO(mndBuildDropDbRsp(pDb, &rspLen, &pRsp, false), NULL, _OVER);

×

UNCOV

1723

  mndTransSetRpcRsp(pTrans, pRsp, rspLen);

×

UNCOV

1725

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

×

UNCOV

1726

  code = 0;

×

UNCOV

1728

_OVER:

×

UNCOV

1729

  mndTransDrop(pTrans);

×

UNCOV

1730

  TAOS_RETURN(code);

×

UNCOV

1733

static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {

×

UNCOV

1734

  SMnode    *pMnode = pReq->info.node;

×

UNCOV

1735

  int32_t    code = -1;

×

UNCOV

1736

  SDbObj    *pDb = NULL;

×

UNCOV

1737

  SDropDbReq dropReq = {0};

×

UNCOV

1739

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

×

UNCOV

1741

  mInfo("db:%s, start to drop", dropReq.db);

×

UNCOV

1743

  pDb = mndAcquireDb(pMnode, dropReq.db);

×

UNCOV

1744

  if (pDb == NULL) {

×

UNCOV

1745

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

UNCOV

1746

    if (terrno != 0) code = terrno;

×

UNCOV

1747

    if (dropReq.ignoreNotExists) {

×

UNCOV

1748

      code = mndBuildDropDbRsp(pDb, &pReq->info.rspLen, &pReq->info.rsp, true);

×

UNCOV

1750

    goto _OVER;

×

UNCOV

1753

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_DB, pDb), NULL, _OVER);

×

UNCOV

1755

  code = mndDropDb(pMnode, pReq, pDb);

×

UNCOV

1756

  if (code == TSDB_CODE_SUCCESS) {

×

UNCOV

1757

    code = TSDB_CODE_ACTION_IN_PROGRESS;

×

UNCOV

1760

  SName name = {0};

×

UNCOV

1761

  if (tNameFromString(&name, dropReq.db, T_NAME_ACCT | T_NAME_DB) < 0)

×

1762

    mError("db:%s, failed to parse db name", dropReq.db);

×

UNCOV

1764

  auditRecord(pReq, pMnode->clusterId, "dropDB", name.dbname, "", dropReq.sql, dropReq.sqlLen);

×

UNCOV

1766

_OVER:

×

UNCOV

1767

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

×

UNCOV

1768

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

×

UNCOV

1771

  mndReleaseDb(pMnode, pDb);

×

UNCOV

1772

  tFreeSDropDbReq(&dropReq);

×

UNCOV

1773

  TAOS_RETURN(code);

×

UNCOV

1776

static int32_t mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode) {

×

UNCOV

1777

  int32_t numOfTables = 0;

×

UNCOV

1778

  int32_t vindex = 0;

×

UNCOV

1779

  SSdb   *pSdb = pMnode->pSdb;

×

UNCOV

1781

  void *pIter = NULL;

×

UNCOV

1782

  while (vindex < pDb->cfg.numOfVgroups) {

×

UNCOV

1783

    SVgObj *pVgroup = NULL;

×

UNCOV

1784

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

×

UNCOV

1785

    if (pIter == NULL) break;

×

UNCOV

1787

    if (mndVgroupInDb(pVgroup, pDb->uid)) {

×

UNCOV

1788

      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

×

UNCOV

1789

      vindex++;

×

UNCOV

1792

    sdbRelease(pSdb, pVgroup);

×

UNCOV

1795

  sdbCancelFetch(pSdb, pIter);

×

UNCOV

1796

  return numOfTables;

×

UNCOV

1799

void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {

×

UNCOV

1800

  int32_t vindex = 0;

×

UNCOV

1801

  SSdb   *pSdb = pMnode->pSdb;

×

UNCOV

1803

  void *pIter = NULL;

×

UNCOV

1804

  while (1) {

×

UNCOV

1805

    SVgObj *pVgroup = NULL;

×

UNCOV

1806

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

×

UNCOV

1807

    if (pIter == NULL) break;

×

UNCOV

1809

    if ((NULL == pDb || pVgroup->dbUid == pDb->uid) && !pVgroup->isTsma) {

×

UNCOV

1810

      SVgroupInfo vgInfo = {0};

×

UNCOV

1811

      vgInfo.vgId = pVgroup->vgId;

×

UNCOV

1812

      vgInfo.hashBegin = pVgroup->hashBegin;

×

UNCOV

1813

      vgInfo.hashEnd = pVgroup->hashEnd;

×

UNCOV

1814

      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

×

UNCOV

1815

      vgInfo.epSet.numOfEps = pVgroup->replica;

×

UNCOV

1816

      for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {

×

UNCOV

1817

        SVnodeGid *pVgid = &pVgroup->vnodeGid[gid];

×

UNCOV

1818

        SEp       *pEp = &vgInfo.epSet.eps[gid];

×

UNCOV

1819

        SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);

×

UNCOV

1820

        if (pDnode != NULL) {

×

UNCOV

1821

          (void)memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);

×

UNCOV

1822

          pEp->port = pDnode->port;

×

UNCOV

1824

        mndReleaseDnode(pMnode, pDnode);

×

UNCOV

1825

        if (pVgid->syncState == TAOS_SYNC_STATE_LEADER || pVgid->syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {

×

UNCOV

1826

          vgInfo.epSet.inUse = gid;

×

UNCOV

1829

      vindex++;

×

UNCOV

1830

      if (taosArrayPush(pVgList, &vgInfo) == NULL) {

×

1831

        mError("db:%s, failed to push vgInfo to array, vgId:%d, but continue next", pDb->name, vgInfo.vgId);

×

UNCOV

1835

    sdbRelease(pSdb, pVgroup);

×

UNCOV

1837

    if (pDb && (vindex >= pDb->cfg.numOfVgroups)) {

×

UNCOV

1838

      sdbCancelFetch(pSdb, pIter);

×

UNCOV

1839

      break;

×

UNCOV

1842

×

UNCOV

1844

int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUseDbReq *pReq) {

×

UNCOV

1845

  int32_t code = 0;

×

UNCOV

1846

  pRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));

×

UNCOV

1847

  if (pRsp->pVgroupInfos == NULL) {

×

1848

    code = terrno;

×

1849

    TAOS_RETURN(code);

×

UNCOV

1852

  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

×

UNCOV

1854

  if (pReq == NULL || pReq->vgVersion < pDb->vgVersion || pReq->dbId != pDb->uid || numOfTable != pReq->numOfTable ||

×

UNCOV

1855

      pReq->stateTs < pDb->stateTs) {

×

UNCOV

1856

    mndBuildDBVgroupInfo(pDb, pMnode, pRsp->pVgroupInfos);

×

UNCOV

1859

  (void)memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);

×

UNCOV

1860

  pRsp->uid = pDb->uid;

×

UNCOV

1861

  pRsp->vgVersion = pDb->vgVersion;

×

UNCOV

1862

  pRsp->stateTs = pDb->stateTs;

×

UNCOV

1863

  pRsp->vgNum = taosArrayGetSize(pRsp->pVgroupInfos);

×

UNCOV

1864

  pRsp->hashMethod = pDb->cfg.hashMethod;

×

UNCOV

1865

  pRsp->hashPrefix = pDb->cfg.hashPrefix;

×

UNCOV

1866

  pRsp->hashSuffix = pDb->cfg.hashSuffix;

×

UNCOV

1867

  TAOS_RETURN(code);

×

UNCOV

1870

static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {

×

UNCOV

1871

  SMnode   *pMnode = pReq->info.node;

×

UNCOV

1872

  int32_t   code = -1;

×

UNCOV

1873

  SDbObj   *pDb = NULL;

×

UNCOV

1874

  SUseDbReq usedbReq = {0};

×

UNCOV

1875

  SUseDbRsp usedbRsp = {0};

×

UNCOV

1877

  TAOS_CHECK_GOTO(tDeserializeSUseDbReq(pReq->pCont, pReq->contLen, &usedbReq), NULL, _OVER);

×

UNCOV

1879

  char *p = strchr(usedbReq.db, '.');

×

UNCOV

1880

  if (p && ((0 == strcmp(p + 1, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcmp(p + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {

×

UNCOV

1881

    (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);

×

UNCOV

1882

    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

×

UNCOV

1883

    if (usedbReq.vgVersion < vgVersion) {

×

UNCOV

1884

      usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));

×

UNCOV

1885

      if (usedbRsp.pVgroupInfos == NULL) goto _OVER;

×

UNCOV

1887

      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);

×

UNCOV

1888

      usedbRsp.vgVersion = vgVersion++;

×

UNCOV

1890

      usedbRsp.vgVersion = usedbReq.vgVersion;

×

UNCOV

1892

    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);

×

UNCOV

1893

    code = 0;

×

UNCOV

1895

    pDb = mndAcquireDb(pMnode, usedbReq.db);

×

UNCOV

1896

    if (pDb == NULL) {

×

UNCOV

1897

      (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);

×

UNCOV

1898

      usedbRsp.uid = usedbReq.dbId;

×

UNCOV

1899

      usedbRsp.vgVersion = usedbReq.vgVersion;

×

UNCOV

1900

      usedbRsp.errCode = terrno;

×

UNCOV

1902

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

UNCOV

1903

      if (terrno != 0) code = terrno;

×

UNCOV

1904

      goto _OVER;

×

UNCOV

1906

      TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_USE_DB, pDb), NULL, _OVER);

×

UNCOV

1908

      TAOS_CHECK_GOTO(mndExtractDbInfo(pMnode, pDb, &usedbRsp, &usedbReq), NULL, _OVER);

×

UNCOV

1910

      mDebug("db:%s, process usedb req vgVersion:%d stateTs:%" PRId64 ", rsp vgVersion:%d stateTs:%" PRId64,

×

UNCOV

1912

      code = 0;

×

UNCOV

1916

  int32_t contLen = tSerializeSUseDbRsp(NULL, 0, &usedbRsp);

×

UNCOV

1917

  void   *pRsp = rpcMallocCont(contLen);

×

UNCOV

1918

  if (pRsp == NULL) {

×

1919

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1920

    code = -1;

×

1921

    goto _OVER;

×

UNCOV

1924

  int32_t ret = 0;

×

UNCOV

1925

  if ((ret = tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp)) < 0) {

×

1926

    code = ret;

×

1927

    goto _OVER;

×

UNCOV

1930

  pReq->info.rsp = pRsp;

×

UNCOV

1931

  pReq->info.rspLen = contLen;

×

UNCOV

1933

_OVER:

×

UNCOV

1934

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

×

UNCOV

1935

    mError("db:%s, failed to process use db req since %s", usedbReq.db, tstrerror(code));

×

UNCOV

1938

  mndReleaseDb(pMnode, pDb);

×

UNCOV

1939

  tFreeSUsedbRsp(&usedbRsp);

×

UNCOV

1941

  TAOS_RETURN(code);

×

UNCOV

1944

int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen) {

×

UNCOV

1945

  int32_t       code = 0;

×

UNCOV

1946

  SDbHbBatchRsp batchRsp = {0};

×

UNCOV

1947

  batchRsp.pArray = taosArrayInit(numOfDbs, sizeof(SDbHbRsp));

×

UNCOV

1948

  if (batchRsp.pArray == NULL) {

×

1949

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1950

    TAOS_RETURN(code);

×

UNCOV

1953

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

×

UNCOV

1954

    SDbCacheInfo *pDbCacheInfo = &pDbs[i];

×

UNCOV

1955

    pDbCacheInfo->dbId = be64toh(pDbCacheInfo->dbId);

×

UNCOV

1956

    pDbCacheInfo->vgVersion = htonl(pDbCacheInfo->vgVersion);

×

UNCOV

1957

    pDbCacheInfo->cfgVersion = htonl(pDbCacheInfo->cfgVersion);

×

UNCOV

1958

    pDbCacheInfo->numOfTable = htonl(pDbCacheInfo->numOfTable);

×

UNCOV

1959

    pDbCacheInfo->stateTs = be64toh(pDbCacheInfo->stateTs);

×

UNCOV

1960

    pDbCacheInfo->tsmaVersion = htonl(pDbCacheInfo->tsmaVersion);

×

UNCOV

1962

    SDbHbRsp rsp = {0};

×

UNCOV

1963

    (void)memcpy(rsp.db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);

×

UNCOV

1964

    rsp.dbId = pDbCacheInfo->dbId;

×

UNCOV

1966

    if ((0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_INFORMATION_SCHEMA_DB) ||

×

UNCOV

1967

         (0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_PERFORMANCE_SCHEMA_DB)))) {

×

UNCOV

1968

      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

×

UNCOV

1969

      if (pDbCacheInfo->vgVersion >= vgVersion) {

×

UNCOV

1970

        continue;

×

UNCOV

1973

      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));

×

UNCOV

1974

      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);

×

UNCOV

1975

      rsp.useDbRsp->pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));

×

UNCOV

1977

      mndBuildDBVgroupInfo(NULL, pMnode, rsp.useDbRsp->pVgroupInfos);

×

UNCOV

1978

      rsp.useDbRsp->vgVersion = vgVersion++;

×

UNCOV

1980

      rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);

×

UNCOV

1982

      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {

×

1983

        if (terrno != 0) code = terrno;

×

1984

        return code;

×

UNCOV

1987

      continue;

×

UNCOV

1990

    SDbObj *pDb = mndAcquireDb(pMnode, pDbCacheInfo->dbFName);

×

UNCOV

1991

    if (pDb == NULL) {

×

UNCOV

1992

      mTrace("db:%s, no exist", pDbCacheInfo->dbFName);

×

UNCOV

1993

      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));

×

UNCOV

1994

      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);

×

UNCOV

1995

      rsp.useDbRsp->uid = pDbCacheInfo->dbId;

×

UNCOV

1996

      rsp.useDbRsp->vgVersion = -1;

×

UNCOV

1997

      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {

×

1998

        if (terrno != 0) code = terrno;

×

1999

        return code;

×

UNCOV

2001

      continue;

×

UNCOV

2004

    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

×

UNCOV

2006

    if (pDbCacheInfo->vgVersion >= pDb->vgVersion && pDbCacheInfo->cfgVersion >= pDb->cfgVersion &&

×

UNCOV

2007

        numOfTable == pDbCacheInfo->numOfTable && pDbCacheInfo->stateTs == pDb->stateTs &&

×

UNCOV

2008

        pDbCacheInfo->tsmaVersion >= pDb->tsmaVersion) {

×

UNCOV

2009

      mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64

×

UNCOV

2013

      mndReleaseDb(pMnode, pDb);

×

UNCOV

2014

      continue;

×

UNCOV

2016

      mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64

×

UNCOV

2022

    if (pDbCacheInfo->cfgVersion < pDb->cfgVersion) {

×

UNCOV

2023

      rsp.cfgRsp = taosMemoryCalloc(1, sizeof(SDbCfgRsp));

×

UNCOV

2024

      mndDumpDbCfgInfo(rsp.cfgRsp, pDb);

×

UNCOV

2027

    if (pDbCacheInfo->tsmaVersion != pDb->tsmaVersion) {

×

UNCOV

2028

      rsp.pTsmaRsp = taosMemoryCalloc(1, sizeof(STableTSMAInfoRsp));

×

UNCOV

2029

      if (rsp.pTsmaRsp) rsp.pTsmaRsp->pTsmas = taosArrayInit(4, POINTER_BYTES);

×

UNCOV

2030

      if (rsp.pTsmaRsp && rsp.pTsmaRsp->pTsmas) {

×

UNCOV

2031

        bool    exist = false;

×

UNCOV

2032

        int32_t code = mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist);

×

UNCOV

2033

        if (TSDB_CODE_SUCCESS != code) {

×

UNCOV

2034

          mndReleaseDb(pMnode, pDb);

×

UNCOV

2035

          if (code != TSDB_CODE_NEED_RETRY) {

×

2036

            mError("db:%s, failed to get db tsmas", pDb->name);

×

UNCOV

2038

            mWarn("db:%s, need retry to get db tsmas", pDb->name);

×

UNCOV

2040

          taosArrayDestroyP(rsp.pTsmaRsp->pTsmas, tFreeAndClearTableTSMAInfo);

×

UNCOV

2041

          taosMemoryFreeClear(rsp.pTsmaRsp);

×

UNCOV

2042

          continue;

×

UNCOV

2044

        rsp.dbTsmaVersion = pDb->tsmaVersion;

×

UNCOV

2045

        mDebug("update tsma version to %d, got tsma num: %ld", pDb->tsmaVersion, rsp.pTsmaRsp->pTsmas->size);

×

UNCOV

2049

    if (pDbCacheInfo->vgVersion < pDb->vgVersion || numOfTable != pDbCacheInfo->numOfTable ||

×

UNCOV

2050

        pDbCacheInfo->stateTs != pDb->stateTs) {

×

UNCOV

2051

      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));

×

UNCOV

2052

      rsp.useDbRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));

×

UNCOV

2053

      if (rsp.useDbRsp->pVgroupInfos == NULL) {

×

2054

        mndReleaseDb(pMnode, pDb);

×

2055

        mError("db:%s, failed to malloc usedb response", pDb->name);

×

2056

        taosArrayDestroyP(rsp.pTsmaRsp->pTsmas, tFreeAndClearTableTSMAInfo);

×

2057

        taosMemoryFreeClear(rsp.pTsmaRsp);

×

2058

        continue;

×

UNCOV

2061

      mndBuildDBVgroupInfo(pDb, pMnode, rsp.useDbRsp->pVgroupInfos);

×

UNCOV

2062

      (void)memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);

×

UNCOV

2063

      rsp.useDbRsp->uid = pDb->uid;

×

UNCOV

2064

      rsp.useDbRsp->vgVersion = pDb->vgVersion;

×

UNCOV

2065

      rsp.useDbRsp->stateTs = pDb->stateTs;

×

UNCOV

2066

      rsp.useDbRsp->vgNum = (int32_t)taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);

×

UNCOV

2067

      rsp.useDbRsp->hashMethod = pDb->cfg.hashMethod;

×

UNCOV

2068

      rsp.useDbRsp->hashPrefix = pDb->cfg.hashPrefix;

×

UNCOV

2069

      rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;

×

UNCOV

2072

    if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {

×

2073

      mndReleaseDb(pMnode, pDb);

×

2074

      if (terrno != 0) code = terrno;

×

2075

      return code;

×

UNCOV

2077

    mndReleaseDb(pMnode, pDb);

×

UNCOV

2080

  int32_t rspLen = tSerializeSDbHbBatchRsp(NULL, 0, &batchRsp);

×

UNCOV

2081

  void   *pRsp = taosMemoryMalloc(rspLen);

×

UNCOV

2082

  if (pRsp == NULL) {

×

2083

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

2084

    tFreeSDbHbBatchRsp(&batchRsp);

×

2085

    return -1;

×

UNCOV

2087

  int32_t ret = 0;

×

UNCOV

2088

  if ((ret = tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp)) < 0) return ret;

×

UNCOV

2090

  *ppRsp = pRsp;

×

UNCOV

2091

  *pRspLen = rspLen;

×

UNCOV

2093

  tFreeSDbHbBatchRsp(&batchRsp);

×

UNCOV

2094

  TAOS_RETURN(code);

×

UNCOV

2097

static int32_t mndTrimDb(SMnode *pMnode, SDbObj *pDb) {

×

UNCOV

2098

  SSdb       *pSdb = pMnode->pSdb;

×

UNCOV

2099

  SVgObj     *pVgroup = NULL;

×

UNCOV

2100

  void       *pIter = NULL;

×

UNCOV

2101

  int32_t     code = 0;

×

UNCOV

2102

  SVTrimDbReq trimReq = {.timestamp = taosGetTimestampSec()};

×

UNCOV

2103

  int32_t     reqLen = tSerializeSVTrimDbReq(NULL, 0, &trimReq);

×

UNCOV

2104

  int32_t     contLen = reqLen + sizeof(SMsgHead);

×

UNCOV

2106

  while (1) {

×

UNCOV

2107

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

×

UNCOV

2108

    if (pIter == NULL) break;

×

UNCOV

2110

    SMsgHead *pHead = rpcMallocCont(contLen);

×

UNCOV

2111

    if (pHead == NULL) {

×

2112

      sdbCancelFetch(pSdb, pVgroup);

×

2113

      sdbRelease(pSdb, pVgroup);

×

2114

      continue;

×

UNCOV

2116

    pHead->contLen = htonl(contLen);

×

UNCOV

2117

    pHead->vgId = htonl(pVgroup->vgId);

×

UNCOV

2118

    int32_t ret = 0;

×

UNCOV

2119

    if ((ret = tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), contLen, &trimReq)) < 0) {

×

2120

      sdbRelease(pSdb, pVgroup);

×

2121

      return ret;

×

UNCOV

2124

    SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM, .pCont = pHead, .contLen = contLen};

×

UNCOV

2125

    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);

×

UNCOV

2126

    int32_t code = tmsgSendReq(&epSet, &rpcMsg);

×

UNCOV

2127

    if (code != 0) {

×

2128

      mError("vgId:%d, failed to send vnode-trim request to vnode since 0x%x", pVgroup->vgId, code);

×

UNCOV

2130

      mInfo("vgId:%d, send vnode-trim request to vnode, time:%d", pVgroup->vgId, trimReq.timestamp);

×

UNCOV

2132

    sdbRelease(pSdb, pVgroup);

×

UNCOV

2135

  return 0;

×

UNCOV

2138

static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {

×

UNCOV

2139

  SMnode    *pMnode = pReq->info.node;

×

UNCOV

2140

  int32_t    code = -1;

×

UNCOV

2141

  SDbObj    *pDb = NULL;

×

UNCOV

2142

  STrimDbReq trimReq = {0};

×

UNCOV

2144

  TAOS_CHECK_GOTO(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq), NULL, _OVER);

×

UNCOV

2146

  mInfo("db:%s, start to trim", trimReq.db);

×

UNCOV

2148

  pDb = mndAcquireDb(pMnode, trimReq.db);

×

UNCOV

2149

  if (pDb == NULL) {

×

2150

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

2151

    if (terrno != 0) code = terrno;

×

2152

    goto _OVER;

×

UNCOV

2155

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb), NULL, _OVER);

×

UNCOV

2157

  code = mndTrimDb(pMnode, pDb);

×

UNCOV

2159

_OVER:

×

UNCOV

2160

  if (code != 0) {

×

2161

    mError("db:%s, failed to process trim db req since %s", trimReq.db, terrstr());

×

UNCOV

2164

  mndReleaseDb(pMnode, pDb);

×

UNCOV

2165

  TAOS_RETURN(code);

×

2168

static int32_t mndS3MigrateDb(SMnode *pMnode, SDbObj *pDb) {

×

2169

  SSdb            *pSdb = pMnode->pSdb;

×

2170

  SVgObj          *pVgroup = NULL;

×

2171

  void            *pIter = NULL;

×

2172

  SVS3MigrateDbReq s3migrateReq = {.timestamp = taosGetTimestampSec()};

×

2173

  int32_t          reqLen = tSerializeSVS3MigrateDbReq(NULL, 0, &s3migrateReq);

×

2174

  int32_t          contLen = reqLen + sizeof(SMsgHead);

×

2175

  int32_t          code = 0;

×

2177

  while (1) {

×

2178

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

×

2179

    if (pIter == NULL) break;

×

2181

    if (pVgroup->dbUid != pDb->uid) continue;

×

2183

    SMsgHead *pHead = rpcMallocCont(contLen);

×

2184

    if (pHead == NULL) {

×

2185

      sdbCancelFetch(pSdb, pVgroup);

×

2186

      sdbRelease(pSdb, pVgroup);

×

2187

      continue;

×

2189

    pHead->contLen = htonl(contLen);

×

2190

    pHead->vgId = htonl(pVgroup->vgId);

×

2191

    int32_t ret = 0;

×

2192

    if ((ret = tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), contLen, &s3migrateReq)) < 0) {

×

2193

      sdbRelease(pSdb, pVgroup);

×

2194

      return ret;

×

2197

    SRpcMsg rpcMsg = {.msgType = TDMT_VND_S3MIGRATE, .pCont = pHead, .contLen = contLen};

×

2198

    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);

×

2199

    int32_t code = tmsgSendReq(&epSet, &rpcMsg);

×

2200

    if (code != 0) {

×

2201

      mError("vgId:%d, failed to send vnode-s3migrate request to vnode since 0x%x", pVgroup->vgId, code);

×

2203

      mInfo("vgId:%d, send vnode-s3migrate request to vnode, time:%d", pVgroup->vgId, s3migrateReq.timestamp);

×

2205

    sdbRelease(pSdb, pVgroup);

×

2208

  return 0;

×

2211

static int32_t mndProcessS3MigrateDbReq(SRpcMsg *pReq) {

×

2212

  SMnode         *pMnode = pReq->info.node;

×

2213

  int32_t         code = -1;

×

2214

  SDbObj         *pDb = NULL;

×

2215

  SS3MigrateDbReq s3migrateReq = {0};

×

2217

  TAOS_CHECK_GOTO(tDeserializeSS3MigrateDbReq(pReq->pCont, pReq->contLen, &s3migrateReq), NULL, _OVER);

×

2219

  mInfo("db:%s, start to s3migrate", s3migrateReq.db);

×

2221

  pDb = mndAcquireDb(pMnode, s3migrateReq.db);

×

2222

  if (pDb == NULL) {

×

2223

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

2224

    if (terrno != 0) code = terrno;

×

2225

    goto _OVER;

×

2228

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb), NULL, _OVER);

×

2230

  code = mndS3MigrateDb(pMnode, pDb);

×

2232

_OVER:

×

2233

  if (code != 0) {

×

2234

    mError("db:%s, failed to process s3migrate db req since %s", s3migrateReq.db, terrstr());

×

2237

  mndReleaseDb(pMnode, pDb);

×

2238

  TAOS_RETURN(code);

×

UNCOV

2241

const char *mndGetDbStr(const char *src) {

×

UNCOV

2242

  char *pos = strstr(src, TS_PATH_DELIMITER);

×

UNCOV

2243

  if (pos != NULL) ++pos;

×

UNCOV

2244

  if (pos == NULL) return src;

×

UNCOV

2245

  return pos;

×

2248

const char *mndGetStableStr(const char *src) {

×

2249

  char *pos = strstr(src, TS_PATH_DELIMITER);

×

2250

  if (pos != NULL) ++pos;

×

2251

  if (pos == NULL) return src;

×

2252

  return mndGetDbStr(pos);

×

UNCOV

2255

static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {

×

UNCOV

2256

  int64_t v = 0;

×

UNCOV

2257

  switch (unit) {

×

UNCOV

2258

    case 's':

×

UNCOV

2259

      v = val / 1000;

×

UNCOV

2260

      break;

×

UNCOV

2261

    case 'm':

×

UNCOV

2262

      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];

×

UNCOV

2263

      break;

×

2264

    case 'h':

×

2265

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);

×

2266

      break;

×

UNCOV

2267

    case 'd':

×

UNCOV

2268

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);

×

UNCOV

2269

      break;

×

2270

    case 'w':

×

2271

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);

×

2272

      break;

×

2273

    default:

×

2274

      break;

×

UNCOV

2277

  return v;

×

UNCOV

2280

static char *buildRetension(SArray *pRetension) {

×

UNCOV

2281

  size_t size = taosArrayGetSize(pRetension);

×

UNCOV

2282

  if (size == 0) {

×

UNCOV

2283

    return NULL;

×

2286

  char       *p1 = taosMemoryCalloc(1, 100);

×

UNCOV

2287

  SRetention *p = taosArrayGet(pRetension, 0);

×

UNCOV

2289

  int32_t len = 2;

×

UNCOV

2291

  int64_t v1 = getValOfDiffPrecision(p->freqUnit, p->freq);

×

UNCOV

2292

  int64_t v2 = getValOfDiffPrecision(p->keepUnit, p->keep);

×

UNCOV

2293

  len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);

×

UNCOV

2295

  if (size > 1) {

×

UNCOV

2296

    len += tsnprintf(p1 + len, 100 - len, ",");

×

UNCOV

2297

    p = taosArrayGet(pRetension, 1);

×

UNCOV

2299

    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);

×

UNCOV

2300

    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);

×

UNCOV

2301

    len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);

×

UNCOV

2304

  if (size > 2) {

×

UNCOV

2305

    len += tsnprintf(p1 + len, 100 - len, ",");

×

UNCOV

2306

    p = taosArrayGet(pRetension, 2);

×

UNCOV

2308

    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);

×

UNCOV

2309

    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);

×

UNCOV

2310

    len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);

×

UNCOV

2313

  varDataSetLen(p1, len);

×

UNCOV

2314

  return p1;

×

UNCOV

2317

static const char *getCacheModelStr(int8_t cacheModel) {

×

UNCOV

2318

  switch (cacheModel) {

×

UNCOV

2319

    case TSDB_CACHE_MODEL_NONE:

×

UNCOV

2320

      return TSDB_CACHE_MODEL_NONE_STR;

×

UNCOV

2321

    case TSDB_CACHE_MODEL_LAST_ROW:

×

UNCOV

2322

      return TSDB_CACHE_MODEL_LAST_ROW_STR;

×

UNCOV

2323

    case TSDB_CACHE_MODEL_LAST_VALUE:

×

UNCOV

2324

      return TSDB_CACHE_MODEL_LAST_VALUE_STR;

×

UNCOV

2325

    case TSDB_CACHE_MODEL_BOTH:

×

UNCOV

2326

      return TSDB_CACHE_MODEL_BOTH_STR;

×

2327

    default:

×

2328

      break;

×

2330

  return "unknown";

×

UNCOV

2333

static const char *getEncryptAlgorithmStr(int8_t encryptAlgorithm) {

×

UNCOV

2334

  switch (encryptAlgorithm) {

×

UNCOV

2335

    case TSDB_ENCRYPT_ALGO_NONE:

×

UNCOV

2336

      return TSDB_ENCRYPT_ALGO_NONE_STR;

×

2337

    case TSDB_ENCRYPT_ALGO_SM4:

×

2338

      return TSDB_ENCRYPT_ALGO_SM4_STR;

×

2339

    default:

×

2340

      break;

×

2342

  return "unknown";

×

UNCOV

2345

bool mndIsDbReady(SMnode *pMnode, SDbObj *pDb) {

×

UNCOV

2346

  if (pDb->cfg.replications == 1) return true;

×

UNCOV

2348

  SSdb *pSdb = pMnode->pSdb;

×

UNCOV

2349

  void *pIter = NULL;

×

UNCOV

2350

  bool  isReady = true;

×

UNCOV

2351

  while (1) {

×

UNCOV

2352

    SVgObj *pVgroup = NULL;

×

UNCOV

2353

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

×

UNCOV

2354

    if (pIter == NULL) break;

×

UNCOV

2356

    if (pVgroup->dbUid == pDb->uid && pVgroup->replica > 1) {

×

UNCOV

2357

      bool hasLeader = false;

×

UNCOV

2358

      for (int32_t i = 0; i < pVgroup->replica; ++i) {

×

UNCOV

2359

        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_LEADER ||

×

UNCOV

2360

            pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {

×

UNCOV

2361

          hasLeader = true;

×

UNCOV

2364

      if (!hasLeader) isReady = false;

×

UNCOV

2366

    sdbRelease(pSdb, pVgroup);

×

UNCOV

2369

  return isReady;

×

UNCOV

2372

static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows,

×

UNCOV

2374

  int32_t cols = 0;

×

UNCOV

2375

  int32_t bytes = pShow->pMeta->pSchemas[cols].bytes;

×

UNCOV

2376

  char   *buf = taosMemoryMalloc(bytes);

×

UNCOV

2377

  if (buf == NULL) {

×

2378

    mError("db:%s, failed to malloc buffer", pDb->name);

×

2379

    return;

×

UNCOV

2381

  int32_t code = 0;

×

UNCOV

2382

  int32_t lino = 0;

×

UNCOV

2384

  const char *name = mndGetDbStr(pDb->name);

×

UNCOV

2385

  if (name != NULL) {

×

UNCOV

2386

    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);

×

UNCOV

2388

    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);

×

UNCOV

2391

  const char *precStr = NULL;

×

UNCOV

2392

  switch (pDb->cfg.precision) {

×

UNCOV

2393

    case TSDB_TIME_PRECISION_MILLI:

×

UNCOV

2394

      precStr = TSDB_TIME_PRECISION_MILLI_STR;

×

UNCOV

2395

      break;

×

UNCOV

2396

    case TSDB_TIME_PRECISION_MICRO:

×

UNCOV

2397

      precStr = TSDB_TIME_PRECISION_MICRO_STR;

×

UNCOV

2398

      break;

×

UNCOV

2399

    case TSDB_TIME_PRECISION_NANO:

×

UNCOV

2400

      precStr = TSDB_TIME_PRECISION_NANO_STR;

×

UNCOV

2401

      break;

×

2402

    default:

×

2403

      precStr = "none";

×

2404

      break;

×

UNCOV

2406

  char precVstr[10] = {0};

×

UNCOV

2407

  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);

×

UNCOV

2409

  char *statusStr = "ready";

×

UNCOV

2410

  if (objStatus == SDB_STATUS_CREATING) {

×

UNCOV

2411

    statusStr = "creating";

×

UNCOV

2412

  } else if (objStatus == SDB_STATUS_DROPPING) {

×

UNCOV

2413

    statusStr = "dropping";

×

UNCOV

2415

    if (!sysDb && !mndIsDbReady(pMnode, pDb)) {

×

UNCOV

2416

      statusStr = "unsynced";

×

UNCOV

2419

  char statusVstr[24] = {0};

×

UNCOV

2420

  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);

×

UNCOV

2422

  if (sysDb || !sysinfo) {

×

UNCOV

2423

    for (int32_t i = 0; i < pShow->numOfColumns; ++i) {

×

UNCOV

2424

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

×

UNCOV

2425

      if (i == 0) {

×

UNCOV

2426

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);

×

UNCOV

2427

      } else if (i == 1) {

×

UNCOV

2428

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);

×

UNCOV

2429

      } else if (i == 3) {

×

UNCOV

2430

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);

×

UNCOV

2431

      } else if (i == 14) {

×

UNCOV

2432

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, precVstr, false), &lino, _OVER);

×

UNCOV

2433

      } else if (i == 15) {

×

UNCOV

2434

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, statusVstr, false), &lino, _OVER);

×

UNCOV

2436

        colDataSetNULL(pColInfo, rows);

×

UNCOV

2440

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

×

UNCOV

2441

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);

×

UNCOV

2443

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

×

UNCOV

2444

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);

×

UNCOV

2446

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

×

UNCOV

2447

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false), &lino, _OVER);

×

UNCOV

2449

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

×

UNCOV

2450

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);

×

UNCOV

2452

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

×

UNCOV

2453

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false), &lino, _OVER);

×

UNCOV

2455

    const char *strictStr = pDb->cfg.strict ? "on" : "off";

×

UNCOV

2456

    char        strictVstr[24] = {0};

×

UNCOV

2457

    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);

×

UNCOV

2458

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

×

UNCOV

2459

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)strictVstr, false), &lino, _OVER);

×

UNCOV

2461

    char    durationStr[128] = {0};

×

UNCOV

2462

    char    durationVstr[128] = {0};

×

UNCOV

2463

    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE,

×

UNCOV

2466

    varDataSetLen(durationVstr, len);

×

UNCOV

2467

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

×

UNCOV

2468

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

×

UNCOV

2470

    char keepVstr[128] = {0};

×

UNCOV

2471

    char keep0Str[32] = {0};

×

UNCOV

2472

    char keep1Str[32] = {0};

×

UNCOV

2473

    char keep2Str[32] = {0};

×

UNCOV

2475

    int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pDb->cfg.daysToKeep0);

×

UNCOV

2476

    int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pDb->cfg.daysToKeep1);

×

UNCOV

2477

    int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pDb->cfg.daysToKeep2);

×

UNCOV

2479

    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {

×

UNCOV

2480

      len = tsnprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr), "%s,%s,%s", keep1Str, keep2Str, keep0Str);

×

UNCOV

2482

      len = tsnprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr), "%s,%s,%s", keep0Str, keep1Str, keep2Str);

×

UNCOV

2484

    varDataSetLen(keepVstr, len);

×

UNCOV

2485

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

×

UNCOV

2486

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keepVstr, false), &lino, _OVER);

×

UNCOV

2488

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

×

UNCOV

2489

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false), &lino, _OVER);

×

UNCOV

2491

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

×

UNCOV

2492

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false), &lino, _OVER);

×

UNCOV

2494

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

×

UNCOV

2495

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false), &lino, _OVER);

×

UNCOV

2497

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

×

UNCOV

2498

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false), &lino, _OVER);

×

UNCOV

2500

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

×

UNCOV

2501

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false), &lino, _OVER);

×

UNCOV

2503

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

×

UNCOV

2504

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false), &lino, _OVER);

×

UNCOV

2506

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

×

UNCOV

2507

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)precVstr, false), &lino, _OVER);

×

UNCOV

2509

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

×

UNCOV

2510

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)statusVstr, false), &lino, _OVER);

×

UNCOV

2512

    char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);

×

UNCOV

2513

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

×

UNCOV

2514

    if (rentensionVstr == NULL) {

×

UNCOV

2515

      colDataSetNULL(pColInfo, rows);

×

UNCOV

2517

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false), &lino, _OVER);

×

UNCOV

2518

      taosMemoryFree(rentensionVstr);

×

UNCOV

2521

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

×

UNCOV

2522

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false), &lino, _OVER);

×

UNCOV

2524

    const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);

×

UNCOV

2525

    char        cacheModelVstr[24] = {0};

×

UNCOV

2526

    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);

×

UNCOV

2527

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

×

UNCOV

2528

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false), &lino, _OVER);

×

UNCOV

2530

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

×

UNCOV

2531

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false), &lino, _OVER);

×

UNCOV

2533

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

×

UNCOV

2534

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false), &lino, _OVER);

×

UNCOV

2536

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

×

UNCOV

2537

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false), &lino, _OVER);

×

UNCOV

2539

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

×

UNCOV

2540

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false), &lino, _OVER);

×

UNCOV

2542

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

×

UNCOV

2543

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false), &lino, _OVER);

×

UNCOV

2545

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

×

UNCOV

2546

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false), &lino, _OVER);

×

UNCOV

2548

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

×

UNCOV

2549

    int16_t hashPrefix = pDb->cfg.hashPrefix;

×

UNCOV

2550

    if (hashPrefix > 0) {

×

UNCOV

2551

      hashPrefix = pDb->cfg.hashPrefix - strlen(pDb->name) - 1;

×

UNCOV

2552

    } else if (hashPrefix < 0) {

×

UNCOV

2553

      hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;

×

UNCOV

2555

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false), &lino, _OVER);

×

UNCOV

2557

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

×

UNCOV

2558

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false), &lino, _OVER);

×

UNCOV

2560

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

×

UNCOV

2561

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false), &lino, _OVER);

×

UNCOV

2563

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

×

UNCOV

2564

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);

×

UNCOV

2566

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

×

UNCOV

2567

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3ChunkSize, false), &lino, _OVER);

×

UNCOV

2569

    char keeplocalVstr[128] = {0};

×

UNCOV

2570

    len = tsnprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr), "%dm", pDb->cfg.s3KeepLocal);

×

UNCOV

2571

    varDataSetLen(keeplocalVstr, len);

×

UNCOV

2572

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

×

UNCOV

2573

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false), &lino, _OVER);

×

UNCOV

2575

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

×

UNCOV

2576

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3Compact, false), &lino, _OVER);

×

UNCOV

2578

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

×

UNCOV

2579

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false), &lino, _OVER);

×

UNCOV

2581

    const char *encryptAlgorithmStr = getEncryptAlgorithmStr(pDb->cfg.encryptAlgorithm);

×

UNCOV

2582

    char        encryptAlgorithmVStr[24] = {0};

×

UNCOV

2583

    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);

×

UNCOV

2584

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

×

UNCOV

2585

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false), &lino, _OVER);

×

UNCOV

2587

    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));

×

UNCOV

2588

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

UNCOV

2589

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

×

UNCOV

2590

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

×

UNCOV

2593

    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);

×

UNCOV

2594

    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));

×

UNCOV

2595

    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));

×

UNCOV

2596

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

UNCOV

2597

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

×

UNCOV

2598

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

×

UNCOV

2601

    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));

×

UNCOV

2602

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

UNCOV

2603

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

×

UNCOV

2604

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

×

UNCOV

2607

_OVER:

×

UNCOV

2608

  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));

×

UNCOV

2609

  taosMemoryFree(buf);

×

UNCOV

2612

static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

×

UNCOV

2613

  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));

×

UNCOV

2614

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

×

UNCOV

2615

  pDbObj->cfg.numOfVgroups = 0;

×

UNCOV

2616

  pDbObj->cfg.strict = 1;

×

UNCOV

2617

  pDbObj->cfg.replications = 1;

×

UNCOV

2618

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

×

UNCOV

2619

×

UNCOV

2621

static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

×

UNCOV

2622

  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));

×

UNCOV

2623

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

×

UNCOV

2624

  pDbObj->cfg.numOfVgroups = 0;

×

UNCOV

2625

  pDbObj->cfg.strict = 1;

×

UNCOV

2626

  pDbObj->cfg.replications = 1;

×

UNCOV

2627

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

×

UNCOV

2628

×

UNCOV

2630

static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {

×

UNCOV

2631

  SVgObj  *pVgroup = pObj;

×

UNCOV

2632

  int32_t *numOfTables = p1;

×

UNCOV

2633

  int64_t  uid = *(int64_t *)p2;

×

UNCOV

2634

  if (pVgroup->dbUid == uid) {

×

UNCOV

2635

    *numOfTables += pVgroup->numOfTables;

×

UNCOV

2637

  return true;

×

UNCOV

2640

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

×

UNCOV

2641

  SMnode    *pMnode = pReq->info.node;

×

UNCOV

2642

  SSdb      *pSdb = pMnode->pSdb;

×

UNCOV

2643

  int32_t    numOfRows = 0;

×

UNCOV

2644

  SDbObj    *pDb = NULL;

×

UNCOV

2645

  SUserObj  *pUser = NULL;

×

UNCOV

2646

  ESdbStatus objStatus = 0;

×

UNCOV

2648

  (void)mndAcquireUser(pMnode, pReq->info.conn.user, &pUser);

×

UNCOV

2649

  if (pUser == NULL) return 0;

×

UNCOV

2650

  bool sysinfo = pUser->sysInfo;

×

UNCOV

2653

  if (!pShow->sysDbRsp) {

×

UNCOV

2654

    SDbObj infoschemaDb = {0};

×

UNCOV

2655

    setInformationSchemaDbCfg(pMnode, &infoschemaDb);

×

UNCOV

2656

    size_t numOfTables = 0;

×

UNCOV

2657

    getVisibleInfosTablesNum(sysinfo, &numOfTables);

×

UNCOV

2658

    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

×

UNCOV

2660

    numOfRows += 1;

×

UNCOV

2662

    SDbObj perfschemaDb = {0};

×

UNCOV

2663

    setPerfSchemaDbCfg(pMnode, &perfschemaDb);

×

UNCOV

2664

    numOfTables = 0;

×

UNCOV

2665

    getPerfDbMeta(NULL, &numOfTables);

×

UNCOV

2666

    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

×

UNCOV

2668

    numOfRows += 1;

×

UNCOV

2669

    pShow->sysDbRsp = true;

×

UNCOV

2672

  while (numOfRows < rowsCapacity) {

×

UNCOV

2673

    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);

×

UNCOV

2674

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

×

UNCOV

2676

    if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb) == 0) {

×

UNCOV

2677

      int32_t numOfTables = 0;

×

UNCOV

2678

      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);

×

UNCOV

2679

      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo);

×

UNCOV

2680

      numOfRows++;

×

UNCOV

2683

    sdbRelease(pSdb, pDb);

×

UNCOV

2686

  pShow->numOfRows += numOfRows;

×

UNCOV

2687

  mndReleaseUser(pMnode, pUser);

×

UNCOV

2688

  return numOfRows;

×

2691

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

×

2692

  SSdb *pSdb = pMnode->pSdb;

×

2693

  sdbCancelFetchByType(pSdb, pIter, SDB_DB);

×

2694

×

taosdata / TDengine / #3621

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

taosdata / TDengine / #3621

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