taosdata/TDengine | Build 3621 | source/dnode/vnode/src/tsdb/tsdbSnapshotRAW.c | Coveralls

UNCOV

int32_t tsdbSnapRAWReaderOpen(STsdb* tsdb, int64_t ever, int8_t type, STsdbSnapRAWReader** reader) {

×

UNCOV

51

  int32_t code = 0;

×

UNCOV

52

  int32_t lino = 0;

×

UNCOV

54

  reader[0] = taosMemoryCalloc(1, sizeof(STsdbSnapRAWReader));

×

UNCOV

55

  if (reader[0] == NULL) return terrno;

×

UNCOV

57

  reader[0]->tsdb = tsdb;

×

UNCOV

58

  reader[0]->ever = ever;

×

UNCOV

59

  reader[0]->type = type;

×

UNCOV

61

  code = tsdbFSCreateRefSnapshot(tsdb->pFS, &reader[0]->fsetArr);

×

UNCOV

62

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

64

_exit:

×

UNCOV

65

  if (code) {

×

66

    tsdbError("vgId:%d %s failed at line %d since %s, sver:0, ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode), __func__,

×

68

    tsdbFSDestroyRefSnapshot(&reader[0]->fsetArr);

×

69

    taosMemoryFree(reader[0]);

×

70

    reader[0] = NULL;

×

UNCOV

72

    tsdbInfo("vgId:%d, tsdb snapshot raw reader opened. sver:0, ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode), ever,

×

UNCOV

75

  return code;

×

UNCOV

78

void tsdbSnapRAWReaderClose(STsdbSnapRAWReader** reader) {

×

UNCOV

79

  if (reader[0] == NULL) return;

×

UNCOV

81

  int32_t code = 0;

×

UNCOV

82

  int32_t lino = 0;

×

UNCOV

84

  STsdb* tsdb = reader[0]->tsdb;

×

UNCOV

86

  TARRAY2_DESTROY(reader[0]->dataReaderArr, tsdbDataFileRAWReaderClose);

×

UNCOV

87

  tsdbFSDestroyRefSnapshot(&reader[0]->fsetArr);

×

UNCOV

88

  taosMemoryFree(reader[0]);

×

UNCOV

89

  reader[0] = NULL;

×

UNCOV

90

  return;

×

UNCOV

93

static int32_t tsdbSnapRAWReadFileSetOpenReader(STsdbSnapRAWReader* reader) {

×

UNCOV

94

  int32_t code = 0;

×

UNCOV

95

  int32_t lino = 0;

×

UNCOV

98

  for (int32_t ftype = 0; ftype < TSDB_FTYPE_MAX; ftype++) {

×

UNCOV

99

    if (reader->ctx->fset->farr[ftype] == NULL) {

×

UNCOV

100

      continue;

×

UNCOV

102

    STFileObj*               fobj = reader->ctx->fset->farr[ftype];

×

UNCOV

104

    SDataFileRAWReaderConfig config = {

×

UNCOV

105

        .tsdb = reader->tsdb,

×

UNCOV

106

        .szPage = reader->tsdb->pVnode->config.tsdbPageSize,

×

UNCOV

109

    code = tsdbDataFileRAWReaderOpen(NULL, &config, &dataReader);

×

UNCOV

110

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

112

    code = TARRAY2_APPEND(reader->dataReaderArr, dataReader);

×

UNCOV

113

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

118

  TARRAY2_FOREACH(reader->ctx->fset->lvlArr, lvl) {

×

UNCOV

120

    TARRAY2_FOREACH(lvl->fobjArr, fobj) {

×

UNCOV

122

      SDataFileRAWReaderConfig config = {

×

UNCOV

123

          .tsdb = reader->tsdb,

×

UNCOV

124

          .szPage = reader->tsdb->pVnode->config.tsdbPageSize,

×

UNCOV

127

      code = tsdbDataFileRAWReaderOpen(NULL, &config, &dataReader);

×

UNCOV

128

      TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

130

      code = TARRAY2_APPEND(reader->dataReaderArr, dataReader);

×

UNCOV

131

      TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

135

_exit:

×

UNCOV

136

  if (code) {

×

137

    tsdbSnapRAWReadFileSetCloseReader(reader);

×

138

    TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);

×

UNCOV

140

  return code;

×

UNCOV

143

static void tsdbSnapRAWReadFileSetCloseReader(STsdbSnapRAWReader* reader) {

×

UNCOV

144

  TARRAY2_CLEAR(reader->dataReaderArr, tsdbDataFileRAWReaderClose);

×

UNCOV

145

×

UNCOV

147

static int32_t tsdbSnapRAWReadFileSetOpenIter(STsdbSnapRAWReader* reader) {

×

UNCOV

148

  reader->dataIter->count = TARRAY2_SIZE(reader->dataReaderArr);

×

UNCOV

149

  reader->dataIter->idx = 0;

×

UNCOV

150

  return 0;

×

UNCOV

153

static void tsdbSnapRAWReadFileSetCloseIter(STsdbSnapRAWReader* reader) {

×

UNCOV

154

  reader->dataIter->count = 0;

×

UNCOV

155

  reader->dataIter->idx = 0;

×

UNCOV

156

×

UNCOV

158

static int64_t tsdbSnapRAWReadPeek(SDataFileRAWReader* reader) {

×

UNCOV

159

  int64_t size = TMIN(reader->config->file.size - reader->ctx->offset, TSDB_SNAP_DATA_PAYLOAD_SIZE);

×

UNCOV

160

  return size;

×

UNCOV

163

static SDataFileRAWReader* tsdbSnapRAWReaderIterNext(STsdbSnapRAWReader* reader) {

×

UNCOV

164

  while (reader->dataIter->idx < reader->dataIter->count) {

×

UNCOV

165

    SDataFileRAWReader* dataReader = TARRAY2_GET(reader->dataReaderArr, reader->dataIter->idx);

×

UNCOV

166

    if (dataReader->ctx->offset < dataReader->config->file.size) {

×

UNCOV

167

      return dataReader;

×

UNCOV

169

    reader->dataIter->idx++;

×

UNCOV

171

  return NULL;

×

UNCOV

174

static int32_t tsdbSnapRAWReadNext(STsdbSnapRAWReader* reader, SSnapDataHdr** ppData) {

×

UNCOV

175

  int32_t code = 0;

×

UNCOV

176

  int32_t lino = 0;

×

UNCOV

177

  int8_t  type = reader->type;

×

UNCOV

178

  ppData[0] = NULL;

×

UNCOV

180

  SDataFileRAWReader* dataReader = tsdbSnapRAWReaderIterNext(reader);

×

UNCOV

181

  if (dataReader == NULL) {

×

UNCOV

182

    return 0;

×

UNCOV

186

  int64_t dataLength = tsdbSnapRAWReadPeek(dataReader);

×

UNCOV

188

  void* pBuf = taosMemoryCalloc(1, sizeof(SSnapDataHdr) + sizeof(STsdbDataRAWBlockHeader) + dataLength);

×

UNCOV

189

  if (pBuf == NULL) {

×

190

    code = terrno;

×

191

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

193

  SSnapDataHdr* pHdr = pBuf;

×

UNCOV

194

  pHdr->type = type;

×

UNCOV

195

  pHdr->size = sizeof(STsdbDataRAWBlockHeader) + dataLength;

×

UNCOV

198

  STsdbDataRAWBlockHeader* pBlock = (void*)pHdr->data;

×

UNCOV

199

  pBlock->offset = dataReader->ctx->offset;

×

UNCOV

200

  pBlock->dataLength = dataLength;

×

UNCOV

202

  code = tsdbDataFileRAWReadBlockData(dataReader, pBlock);

×

UNCOV

203

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

206

  dataReader->ctx->offset += pBlock->dataLength;

×

UNCOV

207

  ppData[0] = pBuf;

×

UNCOV

209

_exit:

×

UNCOV

210

  if (code) {

×

211

    taosMemoryFree(pBuf);

×

212

    pBuf = NULL;

×

213

    TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);

×

UNCOV

215

  return code;

×

UNCOV

218

static int32_t tsdbSnapRAWReadData(STsdbSnapRAWReader* reader, uint8_t** ppData) {

×

UNCOV

219

  int32_t code = 0;

×

UNCOV

220

  int32_t lino = 0;

×

UNCOV

222

  code = tsdbSnapRAWReadNext(reader, (SSnapDataHdr**)ppData);

×

UNCOV

223

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

225

_exit:

×

UNCOV

226

  if (code) {

×

227

    TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);

×

UNCOV

229

  return code;

×

UNCOV

232

static int32_t tsdbSnapRAWReadBegin(STsdbSnapRAWReader* reader) {

×

UNCOV

233

  int32_t code = 0;

×

UNCOV

234

  int32_t lino = 0;

×

UNCOV

236

  if (reader->ctx->fsetArrIdx < TARRAY2_SIZE(reader->fsetArr)) {

×

UNCOV

237

    reader->ctx->fset = TARRAY2_GET(reader->fsetArr, reader->ctx->fsetArrIdx++);

×

UNCOV

238

    reader->ctx->isDataDone = false;

×

UNCOV

240

    code = tsdbSnapRAWReadFileSetOpenReader(reader);

×

UNCOV

241

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

243

    code = tsdbSnapRAWReadFileSetOpenIter(reader);

×

UNCOV

244

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

247

_exit:

×

UNCOV

248

  if (code) {

×

249

    TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);

×

UNCOV

251

  return code;

×

UNCOV

254

static int32_t tsdbSnapRAWReadEnd(STsdbSnapRAWReader* reader) {

×

UNCOV

255

  tsdbSnapRAWReadFileSetCloseIter(reader);

×

UNCOV

256

  tsdbSnapRAWReadFileSetCloseReader(reader);

×

UNCOV

257

  reader->ctx->fset = NULL;

×

UNCOV

258

  return 0;

×

UNCOV

261

int32_t tsdbSnapRAWRead(STsdbSnapRAWReader* reader, uint8_t** data) {

×

UNCOV

262

  int32_t code = 0;

×

UNCOV

263

  int32_t lino = 0;

×

UNCOV

265

  data[0] = NULL;

×

UNCOV

268

    if (reader->ctx->fset == NULL) {

×

UNCOV

269

      code = tsdbSnapRAWReadBegin(reader);

×

UNCOV

270

      TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

272

      if (reader->ctx->fset == NULL) {

×

UNCOV

273

        break;

×

UNCOV

277

    if (!reader->ctx->isDataDone) {

×

UNCOV

278

      code = tsdbSnapRAWReadData(reader, data);

×

UNCOV

279

      TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

280

      if (data[0]) {

×

UNCOV

281

        goto _exit;

×

UNCOV

283

        reader->ctx->isDataDone = true;

×

UNCOV

287

    code = tsdbSnapRAWReadEnd(reader);

×

UNCOV

288

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

291

_exit:

×

UNCOV

292

  if (code) {

×

293

    TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);

×

UNCOV

295

    tsdbDebug("vgId:%d %s done", TD_VID(reader->tsdb->pVnode), __func__);

×

UNCOV

297

  return code;

×

UNCOV

330

int32_t tsdbSnapRAWWriterOpen(STsdb* pTsdb, int64_t ever, STsdbSnapRAWWriter** writer) {

×

UNCOV

331

  int32_t code = 0;

×

UNCOV

332

  int32_t lino = 0;

×

UNCOV

335

  writer[0] = taosMemoryCalloc(1, sizeof(*writer[0]));

×

UNCOV

336

  if (writer[0] == NULL) return terrno;

×

UNCOV

338

  writer[0]->tsdb = pTsdb;

×

UNCOV

339

  writer[0]->ever = ever;

×

UNCOV

340

  writer[0]->minutes = pTsdb->keepCfg.days;

×

UNCOV

341

  writer[0]->precision = pTsdb->keepCfg.precision;

×

UNCOV

342

  writer[0]->minRow = pTsdb->pVnode->config.tsdbCfg.minRows;

×

UNCOV

343

  writer[0]->maxRow = pTsdb->pVnode->config.tsdbCfg.maxRows;

×

UNCOV

344

  writer[0]->cmprAlg = pTsdb->pVnode->config.tsdbCfg.compression;

×

UNCOV

345

  writer[0]->commitID = tsdbFSAllocEid(pTsdb->pFS);

×

UNCOV

346

  writer[0]->szPage = pTsdb->pVnode->config.tsdbPageSize;

×

UNCOV

347

  writer[0]->compactVersion = INT64_MAX;

×

UNCOV

348

  writer[0]->now = taosGetTimestampMs();

×

UNCOV

350

  code = tsdbFSCreateCopySnapshot(pTsdb->pFS, &writer[0]->fsetArr);

×

UNCOV

351

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

353

_exit:

×

UNCOV

354

  if (code) {

×

355

    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code));

×

UNCOV

357

    tsdbInfo("vgId:%d %s done, sver:0, ever:%" PRId64, TD_VID(pTsdb->pVnode), __func__, ever);

×

UNCOV

359

  return code;

×

362

static int32_t tsdbSnapRAWWriteFileSetCloseIter(STsdbSnapRAWWriter* writer) { return 0; }

×

UNCOV

364

static int32_t tsdbSnapRAWWriteFileSetOpenWriter(STsdbSnapRAWWriter* writer) {

×

UNCOV

365

  int32_t code = 0;

×

UNCOV

366

  int32_t lino = 0;

×

UNCOV

368

  SFSetRAWWriterConfig config = {

×

UNCOV

369

      .tsdb = writer->tsdb,

×

UNCOV

370

      .szPage = writer->szPage,

×

UNCOV

371

      .fid = writer->ctx->fid,

×

UNCOV

372

      .cid = writer->commitID,

×

UNCOV

373

      .expLevel = writer->ctx->level,

×

UNCOV

374

      .level = writer->ctx->level,

×

UNCOV

377

  code = tsdbFSetRAWWriterOpen(&config, &writer->ctx->fsetWriter);

×

UNCOV

378

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

380

_exit:

×

UNCOV

381

  if (code) {

×

382

    TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);

×

UNCOV

384

  return code;

×

UNCOV

387

static int32_t tsdbSnapRAWWriteFileSetCloseWriter(STsdbSnapRAWWriter* writer) {

×

UNCOV

388

  return tsdbFSetRAWWriterClose(&writer->ctx->fsetWriter, 0, writer->fopArr);

×

UNCOV

391

static int32_t tsdbSnapRAWWriteFileSetBegin(STsdbSnapRAWWriter* writer, int32_t fid) {

×

UNCOV

392

  int32_t code = 0;

×

UNCOV

393

  int32_t lino = 0;

×

UNCOV

395

  STFileSet* fset = &(STFileSet){.fid = fid};

×

UNCOV

397

  writer->ctx->fid = fid;

×

UNCOV

398

  STFileSet** fsetPtr = TARRAY2_SEARCH(writer->fsetArr, &fset, tsdbTFileSetCmprFn, TD_EQ);

×

UNCOV

399

  writer->ctx->fset = (fsetPtr == NULL) ? NULL : *fsetPtr;

×

UNCOV

401

  int32_t level = tsdbFidLevel(fid, &writer->tsdb->keepCfg, taosGetTimestampSec());

×

UNCOV

403

  code = tsdbSnapRAWWriteFileSetOpenWriter(writer);

×

UNCOV

404

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

406

  writer->ctx->fsetWriteBegin = true;

×

UNCOV

408

_exit:

×

UNCOV

409

  if (code) {

×

410

    TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);

×

UNCOV

412

  return code;

×

UNCOV

415

static int32_t tsdbSnapRAWWriteFileSetEnd(STsdbSnapRAWWriter* writer) {

×

UNCOV

416

  if (!writer->ctx->fsetWriteBegin) return 0;

×

UNCOV

418

  int32_t code = 0;

×

UNCOV

419

  int32_t lino = 0;

×

UNCOV

422

  code = tsdbSnapRAWWriteFileSetCloseWriter(writer);

×

UNCOV

423

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

425

  writer->ctx->fsetWriteBegin = false;

×

UNCOV

427

_exit:

×

UNCOV

428

  if (code) {

×

429

    TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);

×

UNCOV

431

  return code;

×

UNCOV

434

int32_t tsdbSnapRAWWriterPrepareClose(STsdbSnapRAWWriter* writer) {

×

UNCOV

435

  int32_t code = 0;

×

UNCOV

436

  int32_t lino = 0;

×

UNCOV

438

  code = tsdbSnapRAWWriteFileSetEnd(writer);

×

UNCOV

439

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

441

  code = tsdbFSEditBegin(writer->tsdb->pFS, writer->fopArr, TSDB_FEDIT_COMMIT);

×

UNCOV

442

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

444

_exit:

×

UNCOV

445

  if (code) {

×

446

    TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);

×

UNCOV

448

    tsdbDebug("vgId:%d %s done", TD_VID(writer->tsdb->pVnode), __func__);

×

UNCOV

450

  return code;

×

UNCOV

453

int32_t tsdbSnapRAWWriterClose(STsdbSnapRAWWriter** writer, int8_t rollback) {

×

UNCOV

454

  if (writer[0] == NULL) return 0;

×

UNCOV

456

  int32_t code = 0;

×

UNCOV

457

  int32_t lino = 0;

×

UNCOV

459

  STsdb* tsdb = writer[0]->tsdb;

×

UNCOV

461

  if (rollback) {

×

462

    code = tsdbFSEditAbort(writer[0]->tsdb->pFS);

×

463

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

465

    (void)taosThreadMutexLock(&writer[0]->tsdb->mutex);

×

UNCOV

467

    code = tsdbFSEditCommit(writer[0]->tsdb->pFS);

×

UNCOV

468

    if (code) {

×

469

      (void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex);

×

470

      TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

473

    writer[0]->tsdb->pFS->fsstate = TSDB_FS_STATE_NORMAL;

×

UNCOV

475

    (void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex);

×

UNCOV

478

  TARRAY2_DESTROY(writer[0]->fopArr, NULL);

×

UNCOV

479

  tsdbFSDestroyCopySnapshot(&writer[0]->fsetArr);

×

UNCOV

481

  taosMemoryFree(writer[0]);

×

UNCOV

482

  writer[0] = NULL;

×

UNCOV

484

_exit:

×

UNCOV

485

  if (code) {

×

486

    TSDB_ERROR_LOG(TD_VID(tsdb->pVnode), lino, code);

×

UNCOV

488

    tsdbInfo("vgId:%d %s done", TD_VID(tsdb->pVnode), __func__);

×

UNCOV

490

  return code;

×

UNCOV

493

static int32_t tsdbSnapRAWWriteTimeSeriesData(STsdbSnapRAWWriter* writer, STsdbDataRAWBlockHeader* bHdr) {

×

UNCOV

494

  int32_t code = 0;

×

UNCOV

495

  int32_t lino = 0;

×

UNCOV

497

  int32_t encryptAlgorithm = writer->tsdb->pVnode->config.tsdbCfg.encryptAlgorithm;

×

UNCOV

498

  char*   encryptKey = writer->tsdb->pVnode->config.tsdbCfg.encryptKey;

×

UNCOV

500

  code = tsdbFSetRAWWriteBlockData(writer->ctx->fsetWriter, bHdr, encryptAlgorithm, encryptKey);

×

UNCOV

501

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

503

_exit:

×

UNCOV

504

  if (code) {

×

505

    TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);

×

UNCOV

507

  return code;

×

UNCOV

510

static int32_t tsdbSnapRAWWriteData(STsdbSnapRAWWriter* writer, SSnapDataHdr* hdr) {

×

UNCOV

511

  int32_t code = 0;

×

UNCOV

512

  int32_t lino = 0;

×

UNCOV

514

  STsdbDataRAWBlockHeader* bHdr = (void*)hdr->data;

×

UNCOV

515

  int32_t                  fid = bHdr->file.fid;

×

UNCOV

516

  if (!writer->ctx->fsetWriteBegin || fid != writer->ctx->fid) {

×

UNCOV

517

    code = tsdbSnapRAWWriteFileSetEnd(writer);

×

UNCOV

518

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

520

    code = tsdbSnapRAWWriteFileSetBegin(writer, fid);

×

UNCOV

521

    TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

524

  code = tsdbSnapRAWWriteTimeSeriesData(writer, bHdr);

×

UNCOV

525

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

527

_exit:

×

UNCOV

528

  if (code) {

×

529

    TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);

×

UNCOV

531

  return code;

×

UNCOV

534

int32_t tsdbSnapRAWWrite(STsdbSnapRAWWriter* writer, SSnapDataHdr* hdr) {

×

UNCOV

535

  int32_t code = 0;

×

UNCOV

536

  int32_t lino = 0;

×

UNCOV

538

  code = tsdbSnapRAWWriteData(writer, hdr);

×

UNCOV

539

  TSDB_CHECK_CODE(code, lino, _exit);

×

UNCOV

541

_exit:

×

UNCOV

542

  if (code) {

×

543

    tsdbError("vgId:%d %s failed at line %d since %s, type:%d index:%" PRId64 " size:%" PRId64,

×

UNCOV

546

    tsdbDebug("vgId:%d %s done, type:%d index:%" PRId64 " size:%" PRId64, TD_VID(writer->tsdb->pVnode), __func__,

×

UNCOV

549

  return code;

×

taosdata / TDengine / #3621

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

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#include "tsdb.h"
17	#include "tsdbDataFileRAW.h"
18	#include "tsdbFS2.h"
19	#include "tsdbFSetRAW.h"
20
21	static void tsdbSnapRAWReadFileSetCloseReader(STsdbSnapRAWReader* reader);
22
23	// reader
24	typedef struct SDataFileRAWReaderIter {
25	int32_t count;
26	int32_t idx;
27	} SDataFileRAWReaderIter;
28
29	typedef struct STsdbSnapRAWReader {
30	STsdb* tsdb;
31	int64_t ever;
32	int8_t type;
33
34	TFileSetArray* fsetArr;
35
36	// context
37	struct {
38	int32_t fsetArrIdx;
39	STFileSet* fset;
40	bool isDataDone;
41	} ctx[1];
42
43	// reader
44	SDataFileRAWReaderArray dataReaderArr[1];
45
46	// iter
47	SDataFileRAWReaderIter dataIter[1];
48	} STsdbSnapRAWReader;
49
UNCOV 50	int32_t tsdbSnapRAWReaderOpen(STsdb* tsdb, int64_t ever, int8_t type, STsdbSnapRAWReader** reader) {	×
UNCOV 51	int32_t code = 0;	×
UNCOV 52	int32_t lino = 0;	×
53
UNCOV 54	reader[0] = taosMemoryCalloc(1, sizeof(STsdbSnapRAWReader));	×
UNCOV 55	if (reader[0] == NULL) return terrno;	×
56
UNCOV 57	reader[0]->tsdb = tsdb;	×
UNCOV 58	reader[0]->ever = ever;	×
UNCOV 59	reader[0]->type = type;	×
60
UNCOV 61	code = tsdbFSCreateRefSnapshot(tsdb->pFS, &reader[0]->fsetArr);	×
UNCOV 62	TSDB_CHECK_CODE(code, lino, _exit);	×
63
UNCOV 64	_exit:	×
UNCOV 65	if (code) {	×
66	tsdbError("vgId:%d %s failed at line %d since %s, sver:0, ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode), __func__,	×
67	lino, tstrerror(code), ever, type);
68	tsdbFSDestroyRefSnapshot(&reader[0]->fsetArr);	×
69	taosMemoryFree(reader[0]);	×
70	reader[0] = NULL;	×
71	} else {
UNCOV 72	tsdbInfo("vgId:%d, tsdb snapshot raw reader opened. sver:0, ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode), ever,	×
73	type);
74	}
UNCOV 75	return code;	×
76	}
77
UNCOV 78	void tsdbSnapRAWReaderClose(STsdbSnapRAWReader** reader) {	×
UNCOV 79	if (reader[0] == NULL) return;	×
80
UNCOV 81	int32_t code = 0;	×
UNCOV 82	int32_t lino = 0;	×
83
UNCOV 84	STsdb* tsdb = reader[0]->tsdb;	×
85
UNCOV 86	TARRAY2_DESTROY(reader[0]->dataReaderArr, tsdbDataFileRAWReaderClose);	×
UNCOV 87	tsdbFSDestroyRefSnapshot(&reader[0]->fsetArr);	×
UNCOV 88	taosMemoryFree(reader[0]);	×
UNCOV 89	reader[0] = NULL;	×
UNCOV 90	return;	×
91	}
92
UNCOV 93	static int32_t tsdbSnapRAWReadFileSetOpenReader(STsdbSnapRAWReader* reader) {	×
UNCOV 94	int32_t code = 0;	×
UNCOV 95	int32_t lino = 0;	×
96
97	// data
UNCOV 98	for (int32_t ftype = 0; ftype < TSDB_FTYPE_MAX; ftype++) {	×
UNCOV 99	if (reader->ctx->fset->farr[ftype] == NULL) {	×
UNCOV 100	continue;	×
101	}
UNCOV 102	STFileObj* fobj = reader->ctx->fset->farr[ftype];	×
103	SDataFileRAWReader* dataReader;
UNCOV 104	SDataFileRAWReaderConfig config = {	×
UNCOV 105	.tsdb = reader->tsdb,	×
UNCOV 106	.szPage = reader->tsdb->pVnode->config.tsdbPageSize,	×
107	.file = fobj->f[0],
108	};
UNCOV 109	code = tsdbDataFileRAWReaderOpen(NULL, &config, &dataReader);	×
UNCOV 110	TSDB_CHECK_CODE(code, lino, _exit);	×
111
UNCOV 112	code = TARRAY2_APPEND(reader->dataReaderArr, dataReader);	×
UNCOV 113	TSDB_CHECK_CODE(code, lino, _exit);	×
114	}
115
116	// stt
117	SSttLvl* lvl;
UNCOV 118	TARRAY2_FOREACH(reader->ctx->fset->lvlArr, lvl) {	×
119	STFileObj* fobj;
UNCOV 120	TARRAY2_FOREACH(lvl->fobjArr, fobj) {	×
121	SDataFileRAWReader* dataReader;
UNCOV 122	SDataFileRAWReaderConfig config = {	×
UNCOV 123	.tsdb = reader->tsdb,	×
UNCOV 124	.szPage = reader->tsdb->pVnode->config.tsdbPageSize,	×
125	.file = fobj->f[0],
126	};
UNCOV 127	code = tsdbDataFileRAWReaderOpen(NULL, &config, &dataReader);	×
UNCOV 128	TSDB_CHECK_CODE(code, lino, _exit);	×
129
UNCOV 130	code = TARRAY2_APPEND(reader->dataReaderArr, dataReader);	×
UNCOV 131	TSDB_CHECK_CODE(code, lino, _exit);	×
132	}
133	}
134
UNCOV 135	_exit:	×
UNCOV 136	if (code) {	×
137	tsdbSnapRAWReadFileSetCloseReader(reader);	×
138	TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);	×
139	}
UNCOV 140	return code;	×
141	}
142
UNCOV 143	static void tsdbSnapRAWReadFileSetCloseReader(STsdbSnapRAWReader* reader) {	×
UNCOV 144	TARRAY2_CLEAR(reader->dataReaderArr, tsdbDataFileRAWReaderClose);	×
UNCOV 145	}	×
146
UNCOV 147	static int32_t tsdbSnapRAWReadFileSetOpenIter(STsdbSnapRAWReader* reader) {	×
UNCOV 148	reader->dataIter->count = TARRAY2_SIZE(reader->dataReaderArr);	×
UNCOV 149	reader->dataIter->idx = 0;	×
UNCOV 150	return 0;	×
151	}
152
UNCOV 153	static void tsdbSnapRAWReadFileSetCloseIter(STsdbSnapRAWReader* reader) {	×
UNCOV 154	reader->dataIter->count = 0;	×
UNCOV 155	reader->dataIter->idx = 0;	×
UNCOV 156	}	×
157
UNCOV 158	static int64_t tsdbSnapRAWReadPeek(SDataFileRAWReader* reader) {	×
UNCOV 159	int64_t size = TMIN(reader->config->file.size - reader->ctx->offset, TSDB_SNAP_DATA_PAYLOAD_SIZE);	×
UNCOV 160	return size;	×
161	}
162
UNCOV 163	static SDataFileRAWReader* tsdbSnapRAWReaderIterNext(STsdbSnapRAWReader* reader) {	×
UNCOV 164	while (reader->dataIter->idx < reader->dataIter->count) {	×
UNCOV 165	SDataFileRAWReader* dataReader = TARRAY2_GET(reader->dataReaderArr, reader->dataIter->idx);	×
UNCOV 166	if (dataReader->ctx->offset < dataReader->config->file.size) {	×
UNCOV 167	return dataReader;	×
168	}
UNCOV 169	reader->dataIter->idx++;	×
170	}
UNCOV 171	return NULL;	×
172	}
173
UNCOV 174	static int32_t tsdbSnapRAWReadNext(STsdbSnapRAWReader* reader, SSnapDataHdr** ppData) {	×
UNCOV 175	int32_t code = 0;	×
UNCOV 176	int32_t lino = 0;	×
UNCOV 177	int8_t type = reader->type;	×
UNCOV 178	ppData[0] = NULL;	×
179
UNCOV 180	SDataFileRAWReader* dataReader = tsdbSnapRAWReaderIterNext(reader);	×
UNCOV 181	if (dataReader == NULL) {	×
UNCOV 182	return 0;	×
183	}
184
185	// prepare
UNCOV 186	int64_t dataLength = tsdbSnapRAWReadPeek(dataReader);	×
187
UNCOV 188	void* pBuf = taosMemoryCalloc(1, sizeof(SSnapDataHdr) + sizeof(STsdbDataRAWBlockHeader) + dataLength);	×
UNCOV 189	if (pBuf == NULL) {	×
190	code = terrno;	×
191	TSDB_CHECK_CODE(code, lino, _exit);	×
192	}
UNCOV 193	SSnapDataHdr* pHdr = pBuf;	×
UNCOV 194	pHdr->type = type;	×
UNCOV 195	pHdr->size = sizeof(STsdbDataRAWBlockHeader) + dataLength;	×
196
197	// read
UNCOV 198	STsdbDataRAWBlockHeader* pBlock = (void*)pHdr->data;	×
UNCOV 199	pBlock->offset = dataReader->ctx->offset;	×
UNCOV 200	pBlock->dataLength = dataLength;	×
201
UNCOV 202	code = tsdbDataFileRAWReadBlockData(dataReader, pBlock);	×
UNCOV 203	TSDB_CHECK_CODE(code, lino, _exit);	×
204
205	// finish
UNCOV 206	dataReader->ctx->offset += pBlock->dataLength;	×
UNCOV 207	ppData[0] = pBuf;	×
208
UNCOV 209	_exit:	×
UNCOV 210	if (code) {	×
211	taosMemoryFree(pBuf);	×
212	pBuf = NULL;	×
213	TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);	×
214	}
UNCOV 215	return code;	×
216	}
217
UNCOV 218	static int32_t tsdbSnapRAWReadData(STsdbSnapRAWReader* reader, uint8_t** ppData) {	×
UNCOV 219	int32_t code = 0;	×
UNCOV 220	int32_t lino = 0;	×
221
UNCOV 222	code = tsdbSnapRAWReadNext(reader, (SSnapDataHdr**)ppData);	×
UNCOV 223	TSDB_CHECK_CODE(code, lino, _exit);	×
224
UNCOV 225	_exit:	×
UNCOV 226	if (code) {	×
227	TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);	×
228	}
UNCOV 229	return code;	×
230	}
231
UNCOV 232	static int32_t tsdbSnapRAWReadBegin(STsdbSnapRAWReader* reader) {	×
UNCOV 233	int32_t code = 0;	×
UNCOV 234	int32_t lino = 0;	×
235
UNCOV 236	if (reader->ctx->fsetArrIdx < TARRAY2_SIZE(reader->fsetArr)) {	×
UNCOV 237	reader->ctx->fset = TARRAY2_GET(reader->fsetArr, reader->ctx->fsetArrIdx++);	×
UNCOV 238	reader->ctx->isDataDone = false;	×
239
UNCOV 240	code = tsdbSnapRAWReadFileSetOpenReader(reader);	×
UNCOV 241	TSDB_CHECK_CODE(code, lino, _exit);	×
242
UNCOV 243	code = tsdbSnapRAWReadFileSetOpenIter(reader);	×
UNCOV 244	TSDB_CHECK_CODE(code, lino, _exit);	×
245	}
246
UNCOV 247	_exit:	×
UNCOV 248	if (code) {	×
249	TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);	×
250	}
UNCOV 251	return code;	×
252	}
253
UNCOV 254	static int32_t tsdbSnapRAWReadEnd(STsdbSnapRAWReader* reader) {	×
UNCOV 255	tsdbSnapRAWReadFileSetCloseIter(reader);	×
UNCOV 256	tsdbSnapRAWReadFileSetCloseReader(reader);	×
UNCOV 257	reader->ctx->fset = NULL;	×
UNCOV 258	return 0;	×
259	}
260
UNCOV 261	int32_t tsdbSnapRAWRead(STsdbSnapRAWReader* reader, uint8_t** data) {	×
UNCOV 262	int32_t code = 0;	×
UNCOV 263	int32_t lino = 0;	×
264
UNCOV 265	data[0] = NULL;	×
266
267	for (;;) {
UNCOV 268	if (reader->ctx->fset == NULL) {	×
UNCOV 269	code = tsdbSnapRAWReadBegin(reader);	×
UNCOV 270	TSDB_CHECK_CODE(code, lino, _exit);	×
271
UNCOV 272	if (reader->ctx->fset == NULL) {	×
UNCOV 273	break;	×
274	}
275	}
276
UNCOV 277	if (!reader->ctx->isDataDone) {	×
UNCOV 278	code = tsdbSnapRAWReadData(reader, data);	×
UNCOV 279	TSDB_CHECK_CODE(code, lino, _exit);	×
UNCOV 280	if (data[0]) {	×
UNCOV 281	goto _exit;	×
282	} else {
UNCOV 283	reader->ctx->isDataDone = true;	×
284	}
285	}
286
UNCOV 287	code = tsdbSnapRAWReadEnd(reader);	×
UNCOV 288	TSDB_CHECK_CODE(code, lino, _exit);	×
289	}
290
UNCOV 291	_exit:	×
UNCOV 292	if (code) {	×
293	TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);	×
294	} else {
UNCOV 295	tsdbDebug("vgId:%d %s done", TD_VID(reader->tsdb->pVnode), __func__);	×
296	}
UNCOV 297	return code;	×
298	}
299
300	// writer
301	struct STsdbSnapRAWWriter {
302	STsdb* tsdb;
303	int64_t sver;
304	int64_t ever;
305	int32_t minutes;
306	int8_t precision;
307	int32_t minRow;
308	int32_t maxRow;
309	int8_t cmprAlg;
310	int64_t commitID;
311	int32_t szPage;
312	int64_t compactVersion;
313	int64_t now;
314
315	TFileSetArray* fsetArr;
316	TFileOpArray fopArr[1];
317
318	struct {
319	bool fsetWriteBegin;
320	int32_t fid;
321	STFileSet* fset;
322	int64_t cid;
323	int64_t level;
324
325	// writer
326	SFSetRAWWriter* fsetWriter;
327	} ctx[1];
328	};
329
UNCOV 330	int32_t tsdbSnapRAWWriterOpen(STsdb* pTsdb, int64_t ever, STsdbSnapRAWWriter** writer) {	×
UNCOV 331	int32_t code = 0;	×
UNCOV 332	int32_t lino = 0;	×
333
334	// start to write
UNCOV 335	writer[0] = taosMemoryCalloc(1, sizeof(*writer[0]));	×
UNCOV 336	if (writer[0] == NULL) return terrno;	×
337
UNCOV 338	writer[0]->tsdb = pTsdb;	×
UNCOV 339	writer[0]->ever = ever;	×
UNCOV 340	writer[0]->minutes = pTsdb->keepCfg.days;	×
UNCOV 341	writer[0]->precision = pTsdb->keepCfg.precision;	×
UNCOV 342	writer[0]->minRow = pTsdb->pVnode->config.tsdbCfg.minRows;	×
UNCOV 343	writer[0]->maxRow = pTsdb->pVnode->config.tsdbCfg.maxRows;	×
UNCOV 344	writer[0]->cmprAlg = pTsdb->pVnode->config.tsdbCfg.compression;	×
UNCOV 345	writer[0]->commitID = tsdbFSAllocEid(pTsdb->pFS);	×
UNCOV 346	writer[0]->szPage = pTsdb->pVnode->config.tsdbPageSize;	×
UNCOV 347	writer[0]->compactVersion = INT64_MAX;	×
UNCOV 348	writer[0]->now = taosGetTimestampMs();	×
349
UNCOV 350	code = tsdbFSCreateCopySnapshot(pTsdb->pFS, &writer[0]->fsetArr);	×
UNCOV 351	TSDB_CHECK_CODE(code, lino, _exit);	×
352
UNCOV 353	_exit:	×
UNCOV 354	if (code) {	×
355	tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code));	×
356	} else {
UNCOV 357	tsdbInfo("vgId:%d %s done, sver:0, ever:%" PRId64, TD_VID(pTsdb->pVnode), __func__, ever);	×
358	}
UNCOV 359	return code;	×
360	}
361
362	static int32_t tsdbSnapRAWWriteFileSetCloseIter(STsdbSnapRAWWriter* writer) { return 0; }	×
363
UNCOV 364	static int32_t tsdbSnapRAWWriteFileSetOpenWriter(STsdbSnapRAWWriter* writer) {	×
UNCOV 365	int32_t code = 0;	×
UNCOV 366	int32_t lino = 0;	×
367
UNCOV 368	SFSetRAWWriterConfig config = {	×
UNCOV 369	.tsdb = writer->tsdb,	×
UNCOV 370	.szPage = writer->szPage,	×
UNCOV 371	.fid = writer->ctx->fid,	×
UNCOV 372	.cid = writer->commitID,	×
UNCOV 373	.expLevel = writer->ctx->level,	×
UNCOV 374	.level = writer->ctx->level,	×
375	};
376
UNCOV 377	code = tsdbFSetRAWWriterOpen(&config, &writer->ctx->fsetWriter);	×
UNCOV 378	TSDB_CHECK_CODE(code, lino, _exit);	×
379
UNCOV 380	_exit:	×
UNCOV 381	if (code) {	×
382	TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);	×
383	}
UNCOV 384	return code;	×
385	}
386
UNCOV 387	static int32_t tsdbSnapRAWWriteFileSetCloseWriter(STsdbSnapRAWWriter* writer) {	×
UNCOV 388	return tsdbFSetRAWWriterClose(&writer->ctx->fsetWriter, 0, writer->fopArr);	×
389	}
390
UNCOV 391	static int32_t tsdbSnapRAWWriteFileSetBegin(STsdbSnapRAWWriter* writer, int32_t fid) {	×
UNCOV 392	int32_t code = 0;	×
UNCOV 393	int32_t lino = 0;	×
394
UNCOV 395	STFileSet* fset = &(STFileSet){.fid = fid};	×
396
UNCOV 397	writer->ctx->fid = fid;	×
UNCOV 398	STFileSet** fsetPtr = TARRAY2_SEARCH(writer->fsetArr, &fset, tsdbTFileSetCmprFn, TD_EQ);	×
UNCOV 399	writer->ctx->fset = (fsetPtr == NULL) ? NULL : *fsetPtr;	×
400
UNCOV 401	int32_t level = tsdbFidLevel(fid, &writer->tsdb->keepCfg, taosGetTimestampSec());	×
402
UNCOV 403	code = tsdbSnapRAWWriteFileSetOpenWriter(writer);	×
UNCOV 404	TSDB_CHECK_CODE(code, lino, _exit);	×
405
UNCOV 406	writer->ctx->fsetWriteBegin = true;	×
407
UNCOV 408	_exit:	×
UNCOV 409	if (code) {	×
410	TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);	×
411	}
UNCOV 412	return code;	×
413	}
414
UNCOV 415	static int32_t tsdbSnapRAWWriteFileSetEnd(STsdbSnapRAWWriter* writer) {	×
UNCOV 416	if (!writer->ctx->fsetWriteBegin) return 0;	×
417
UNCOV 418	int32_t code = 0;	×
UNCOV 419	int32_t lino = 0;	×
420
421	// close write
UNCOV 422	code = tsdbSnapRAWWriteFileSetCloseWriter(writer);	×
UNCOV 423	TSDB_CHECK_CODE(code, lino, _exit);	×
424
UNCOV 425	writer->ctx->fsetWriteBegin = false;	×
426
UNCOV 427	_exit:	×
UNCOV 428	if (code) {	×
429	TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);	×
430	}
UNCOV 431	return code;	×
432	}
433
UNCOV 434	int32_t tsdbSnapRAWWriterPrepareClose(STsdbSnapRAWWriter* writer) {	×
UNCOV 435	int32_t code = 0;	×
UNCOV 436	int32_t lino = 0;	×
437
UNCOV 438	code = tsdbSnapRAWWriteFileSetEnd(writer);	×
UNCOV 439	TSDB_CHECK_CODE(code, lino, _exit);	×
440
UNCOV 441	code = tsdbFSEditBegin(writer->tsdb->pFS, writer->fopArr, TSDB_FEDIT_COMMIT);	×
UNCOV 442	TSDB_CHECK_CODE(code, lino, _exit);	×
443
UNCOV 444	_exit:	×
UNCOV 445	if (code) {	×
446	TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);	×
447	} else {
UNCOV 448	tsdbDebug("vgId:%d %s done", TD_VID(writer->tsdb->pVnode), __func__);	×
449	}
UNCOV 450	return code;	×
451	}
452
UNCOV 453	int32_t tsdbSnapRAWWriterClose(STsdbSnapRAWWriter** writer, int8_t rollback) {	×
UNCOV 454	if (writer[0] == NULL) return 0;	×
455
UNCOV 456	int32_t code = 0;	×
UNCOV 457	int32_t lino = 0;	×
458
UNCOV 459	STsdb* tsdb = writer[0]->tsdb;	×
460
UNCOV 461	if (rollback) {	×
462	code = tsdbFSEditAbort(writer[0]->tsdb->pFS);	×
463	TSDB_CHECK_CODE(code, lino, _exit);	×
464	} else {
UNCOV 465	(void)taosThreadMutexLock(&writer[0]->tsdb->mutex);	×
466
UNCOV 467	code = tsdbFSEditCommit(writer[0]->tsdb->pFS);	×
UNCOV 468	if (code) {	×
469	(void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex);	×
470	TSDB_CHECK_CODE(code, lino, _exit);	×
471	}
472
UNCOV 473	writer[0]->tsdb->pFS->fsstate = TSDB_FS_STATE_NORMAL;	×
474
UNCOV 475	(void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex);	×
476	}
477
UNCOV 478	TARRAY2_DESTROY(writer[0]->fopArr, NULL);	×
UNCOV 479	tsdbFSDestroyCopySnapshot(&writer[0]->fsetArr);	×
480
UNCOV 481	taosMemoryFree(writer[0]);	×
UNCOV 482	writer[0] = NULL;	×
483
UNCOV 484	_exit:	×
UNCOV 485	if (code) {	×
486	TSDB_ERROR_LOG(TD_VID(tsdb->pVnode), lino, code);	×
487	} else {
UNCOV 488	tsdbInfo("vgId:%d %s done", TD_VID(tsdb->pVnode), __func__);	×
489	}
UNCOV 490	return code;	×
491	}
492
UNCOV 493	static int32_t tsdbSnapRAWWriteTimeSeriesData(STsdbSnapRAWWriter* writer, STsdbDataRAWBlockHeader* bHdr) {	×
UNCOV 494	int32_t code = 0;	×
UNCOV 495	int32_t lino = 0;	×
496
UNCOV 497	int32_t encryptAlgorithm = writer->tsdb->pVnode->config.tsdbCfg.encryptAlgorithm;	×
UNCOV 498	char* encryptKey = writer->tsdb->pVnode->config.tsdbCfg.encryptKey;	×
499
UNCOV 500	code = tsdbFSetRAWWriteBlockData(writer->ctx->fsetWriter, bHdr, encryptAlgorithm, encryptKey);	×
UNCOV 501	TSDB_CHECK_CODE(code, lino, _exit);	×
502
UNCOV 503	_exit:	×
UNCOV 504	if (code) {	×
505	TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);	×
506	}
UNCOV 507	return code;	×
508	}
509
UNCOV 510	static int32_t tsdbSnapRAWWriteData(STsdbSnapRAWWriter* writer, SSnapDataHdr* hdr) {	×
UNCOV 511	int32_t code = 0;	×
UNCOV 512	int32_t lino = 0;	×
513
UNCOV 514	STsdbDataRAWBlockHeader* bHdr = (void*)hdr->data;	×
UNCOV 515	int32_t fid = bHdr->file.fid;	×
UNCOV 516	if (!writer->ctx->fsetWriteBegin \|\| fid != writer->ctx->fid) {	×
UNCOV 517	code = tsdbSnapRAWWriteFileSetEnd(writer);	×
UNCOV 518	TSDB_CHECK_CODE(code, lino, _exit);	×
519
UNCOV 520	code = tsdbSnapRAWWriteFileSetBegin(writer, fid);	×
UNCOV 521	TSDB_CHECK_CODE(code, lino, _exit);	×
522	}
523
UNCOV 524	code = tsdbSnapRAWWriteTimeSeriesData(writer, bHdr);	×
UNCOV 525	TSDB_CHECK_CODE(code, lino, _exit);	×
526
UNCOV 527	_exit:	×
UNCOV 528	if (code) {	×
529	TSDB_ERROR_LOG(TD_VID(writer->tsdb->pVnode), lino, code);	×
530	}
UNCOV 531	return code;	×
532	}
533
UNCOV 534	int32_t tsdbSnapRAWWrite(STsdbSnapRAWWriter* writer, SSnapDataHdr* hdr) {	×
UNCOV 535	int32_t code = 0;	×
UNCOV 536	int32_t lino = 0;	×
537
UNCOV 538	code = tsdbSnapRAWWriteData(writer, hdr);	×
UNCOV 539	TSDB_CHECK_CODE(code, lino, _exit);	×
540
UNCOV 541	_exit:	×
UNCOV 542	if (code) {	×
543	tsdbError("vgId:%d %s failed at line %d since %s, type:%d index:%" PRId64 " size:%" PRId64,	×
544	TD_VID(writer->tsdb->pVnode), __func__, lino, tstrerror(code), hdr->type, hdr->index, hdr->size);
545	} else {
UNCOV 546	tsdbDebug("vgId:%d %s done, type:%d index:%" PRId64 " size:%" PRId64, TD_VID(writer->tsdb->pVnode), __func__,	×
547	hdr->type, hdr->index, hdr->size);
548	}
UNCOV 549	return code;	×
550	}

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