taosdata/TDengine | Build 4986 | source/common/src/msg/xnode.c | Coveralls

27

CowStr xCreateCowStr(int32_t len, const char *ptr, bool shouldClone) {

×

28

  CowStr cow = {0};

×

29

  if (NULL == ptr) {

×

30

    return cow;

×

32

  if (shouldClone) {

×

33

    cow.len = len;

×

34

    cow.ptr = taosMemoryCalloc(1, len + 1);

×

35

    if (cow.ptr == NULL) {

×

36

      cow.len = 0;

×

37

      return cow;

×

39

    (void)memcpy((void*)cow.ptr, ptr, len);

×

40

    ((char*)cow.ptr)[len] = '\0';

×

41

    cow.shouldFree = true;

×

43

    cow.len = len;

×

44

    cow.ptr = ptr;

×

45

    cow.shouldFree = false;

×

47

  return cow;

×

49

void xSetCowStr(CowStr *cow, int32_t len, const char *ptr, bool shouldFree) {

×

50

  if (cow == NULL) {

×

51

    return;

×

53

  if (NULL == ptr) {

×

54

    xFreeCowStr(cow);

×

55

    return;

×

57

  cow->len = len;

×

58

  cow->ptr = taosMemoryCalloc(1, len + 1);

×

59

  if (cow->ptr == NULL) {

×

60

    cow->len = 0;

×

61

    return;

×

63

  (void)memcpy((void*)cow->ptr, ptr, len);

×

64

  ((char*)cow->ptr)[len] = '\0';

×

65

  cow->shouldFree = shouldFree;

×

67

CowStr xCloneRefCowStr(CowStr *cow) {

×

68

  CowStr ref = {0};

×

69

  if (cow == NULL) {

×

70

    return ref;

×

72

  ref.len = cow->len;

×

73

  ref.ptr = cow->ptr;

×

74

  ref.shouldFree = false;

×

75

  return ref;

×

78

char *xCowStrToStr(CowStr *cow) { return taosStrndupi(cow->ptr, (int64_t)cow->len); }

×

79

void xFreeCowStr(CowStr *cow) {

×

81

  if (cow == NULL) {

×

82

    return;

×

84

  if (cow->shouldFree && cow->ptr != NULL) {

×

85

    taosMemoryFreeClear(cow->ptr);

×

86

    cow->ptr = NULL;

×

88

  cow->len = 0;

×

89

  cow->ptr = NULL;

×

90

  cow->shouldFree = false;

×

92

int32_t xEncodeCowStr(SEncoder *encoder, CowStr *cow) {

×

93

  if (cow->ptr == NULL) {

×

94

    return tEncodeU32v(encoder, 0);

×

96

  return tEncodeBinary(encoder, (uint8_t*)cow->ptr, cow->len + 1);

×

98

int32_t xDecodeCowStr(SDecoder *decoder, CowStr *cow, bool shouldClone) {

×

99

  if (decoder == NULL || cow == NULL) {

×

100

    return TSDB_CODE_MND_XNODE_INVALID_MSG;

×

102

  int32_t code = 0;

×

103

  int32_t  lino = 0;

×

105

  if (shouldClone) {

×

106

    uint64_t len = 0;

×

107

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(decoder, (void**)&cow->ptr, &len));

×

108

    cow->len = (int32_t)len - 1;

×

109

    cow->shouldFree = true;

×

111

    TAOS_CHECK_EXIT(tDecodeBinary(decoder, (uint8_t**)&cow->ptr, (uint32_t *)&cow->len));

×

112

    cow->len -= 1;

×

113

    cow->shouldFree = false;

×

115

_exit:

×

116

  return code;

×

144

int32_t tSerializeSMCreateXnodeReq(void *buf, int32_t bufLen, SMCreateXnodeReq *pReq) {

×

145

  SEncoder encoder = {0};

×

146

  int32_t  code = 0;

×

147

  int32_t  lino = 0;

×

148

  int32_t  tlen = 0;

×

149

  tEncoderInit(&encoder, buf, bufLen);

×

151

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

152

  ENCODESQL();

×

154

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->urlLen));

×

155

  if (pReq->urlLen > 0) {

×

156

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (const uint8_t *)pReq->url, pReq->urlLen));

×

158

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->userLen));

×

159

  if (pReq->userLen > 0) {

×

160

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (const uint8_t *)pReq->user, pReq->userLen));

×

162

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->passLen));

×

163

  if (pReq->passLen > 0) {

×

164

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (const uint8_t *)pReq->pass, pReq->passLen));

×

166

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->passIsMd5));

×

167

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->token));

×

169

  tEndEncode(&encoder);

×

171

_exit:

×

172

  if (code) {

×

173

    tlen = code;

×

175

    tlen = encoder.pos;

×

177

  tEncoderClear(&encoder);

×

178

  return tlen;

×

181

int32_t tDeserializeSMCreateXnodeReq(void *buf, int32_t bufLen, SMCreateXnodeReq *pReq) {

×

182

  SDecoder decoder = {0};

×

183

  int32_t  code = 0;

×

184

  int32_t  lino = 0;

×

186

  tDecoderInit(&decoder, buf, bufLen);

×

188

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

189

  DECODESQL();

×

191

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->urlLen));

×

192

  if (pReq->urlLen > 0) {

×

193

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->url, NULL));

×

195

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->userLen));

×

196

  if (pReq->userLen > 0) {

×

197

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->user, NULL));

×

199

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->passLen));

×

200

  if (pReq->passLen > 0) {

×

201

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->pass, NULL));

×

203

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->passIsMd5));

×

204

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->token, true));

×

206

  tEndDecode(&decoder);

×

208

_exit:

×

209

  tDecoderClear(&decoder);

×

210

  return code;

×

213

void tFreeSMCreateXnodeReq(SMCreateXnodeReq *pReq) {

×

214

  taosMemoryFreeClear(pReq->url);

×

215

  taosMemoryFreeClear(pReq->user);

×

216

  taosMemoryFreeClear(pReq->pass);

×

217

  xFreeCowStr(&pReq->token);

×

218

  FREESQL();

×

219

×

220

void xFreeTaskSource(xTaskSource *source) {

×

221

  if (source == NULL) {

×

222

    return;

×

224

  xFreeCowStr(&source->cstr);

×

226

xTaskSource xCreateClonedTaskSource(ENodeXTaskSourceType sourceType, int32_t len, char *source) {

×

228

  xTaskSource taskSource = {0};

×

229

  taskSource.type = sourceType;

×

230

  taskSource.cstr = xCreateCowStr(len, source, true);

×

231

  return taskSource;

×

233

xTaskSource xCreateTaskSource(ENodeXTaskSourceType sourceType, int32_t len, char *ptr) {

×

234

   xTaskSource taskSource = {0};

×

235

  taskSource.type = sourceType;

×

236

  taskSource.cstr = xCreateCowStr(len, ptr, false);

×

237

   return taskSource;

×

239

xTaskSource xCloneTaskSourceRef(xTaskSource *source) {

×

240

  xTaskSource taskSource = {0};

×

241

  if (source == NULL) {

×

242

    return taskSource;

×

244

  taskSource.type = source->type;

×

245

  taskSource.cstr = xCloneRefCowStr(&source->cstr);

×

246

  return taskSource;

×

249

const char *xGetTaskSourceTypeAsStr(xTaskSource *source) {

×

250

  switch (source->type) {

×

251

    case XNODE_TASK_SOURCE_DATABASE:

×

252

      return "database";

×

253

    case XNODE_TASK_SOURCE_TOPIC:

×

254

      return "topic";

×

255

    case XNODE_TASK_SOURCE_DSN:

×

256

      return "dsn";

×

257

    default:

×

258

      return "unknown";

×

261

const char *xGetTaskSourceStr(xTaskSource *source) { return source->cstr.ptr; }

×

262

int32_t     xSerializeTaskSource(SEncoder *encoder, xTaskSource *source) {

×

263

  int32_t code = 0;

×

264

  int32_t  lino = 0;

×

265

  TAOS_CHECK_EXIT(tEncodeI32(encoder, source->type));

×

266

  TAOS_CHECK_EXIT(xEncodeCowStr(encoder, &source->cstr));

×

267

_exit:

×

268

  return code;

×

270

int32_t xDeserializeTaskSource(SDecoder *decoder, xTaskSource *source) {

×

271

  if (decoder == NULL || source == NULL) {

×

272

    return TSDB_CODE_MND_XNODE_INVALID_MSG;

×

274

  int32_t code = 0;

×

275

  int32_t lino = 0;

×

276

  int32_t type = 0;

×

277

  TAOS_CHECK_EXIT(tDecodeI32(decoder, &type));

×

278

  source->type = type;

×

279

  TAOS_CHECK_EXIT(xDecodeCowStr(decoder, &source->cstr, true));

×

280

_exit:

×

281

  return code;

×

284

void xFreeTaskSink(xTaskSink *sink) {

×

285

  if (sink == NULL) {

×

286

    return;

×

288

  xFreeCowStr(&sink->cstr);

×

290

xTaskSink xCreateClonedTaskSink(ENodeXTaskSinkType sinkType, int32_t len, char *sink) {

×

291

  xTaskSink taskSink = {0};

×

292

  taskSink.type = sinkType;

×

293

  taskSink.cstr = xCreateCowStr(len, sink, false);

×

294

  return taskSink;

×

296

xTaskSink xCreateTaskSink(ENodeXTaskSinkType sinkType, int32_t len, char *ptr) {

×

297

  xTaskSink taskSink = {0};

×

298

  taskSink.type = sinkType;

×

299

  taskSink.cstr = xCreateCowStr(len, ptr, false);

×

300

  return taskSink;

×

302

xTaskSink   xCloneTaskSinkRef(xTaskSink* sink) {

×

303

  xTaskSink taskSink = {0};

×

304

  if (sink == NULL) {

×

305

    return taskSink;

×

307

  taskSink.type = sink->type;

×

308

  taskSink.cstr = xCloneRefCowStr(&sink->cstr);

×

309

  return taskSink;

×

311

const char *xGetTaskSinkTypeAsStr(xTaskSink *sink) {

×

312

  switch (sink->type) {

×

313

    case XNODE_TASK_SINK_DATABASE:

×

314

      return "database";

×

315

    case XNODE_TASK_SINK_DSN:

×

316

      return "dsn";

×

317

    default:

×

318

      return "unknown";

×

321

const char *xGetTaskSinkStr(xTaskSink *sink) { return sink->cstr.ptr; }

×

323

int32_t xSerializeTaskSink(SEncoder *encoder, xTaskSink *sink) {

×

324

  int32_t code = 0;

×

325

  int32_t lino = 0;

×

326

  TAOS_CHECK_EXIT(tEncodeI32(encoder, sink->type));

×

327

  TAOS_CHECK_EXIT(xEncodeCowStr(encoder, &sink->cstr));

×

328

_exit:

×

329

  return code;

×

331

int32_t xDeserializeTaskSink(SDecoder *decoder, xTaskSink *sink) {

×

332

  if (decoder == NULL || sink == NULL) {

×

333

    return TSDB_CODE_MND_XNODE_INVALID_MSG;

×

335

  int32_t code = 0;

×

336

  int32_t lino = 0;

×

337

  int32_t type = 0;

×

338

  TAOS_CHECK_EXIT(tDecodeI32(decoder, &type));

×

339

  sink->type = type;

×

348

  TAOS_CHECK_EXIT(xDecodeCowStr(decoder, &sink->cstr, true));

×

349

_exit:

×

350

  return code;

×

353

void xFreeTaskOptions(xTaskOptions *options) {

×

354

  if (options == NULL) {

×

355

    return;

×

357

  xFreeCowStr(&options->trigger);

×

358

  xFreeCowStr(&options->parser);

×

359

  xFreeCowStr(&options->health);

×

361

  for (int i = 0; i < TSDB_XNODE_TASK_OPTIONS_MAX_NUM; i++) {

×

362

    xFreeCowStr(&options->options[i]);

×

365

void printXnodeTaskOptions(xTaskOptions *options) {

×

366

  printf("Xnode Task Options:\n");

×

367

  printf("  trigger: %s\n", options->trigger.ptr);

×

368

  printf("  parser: %s\n", options->parser.ptr);

×

369

  printf("  health: %s\n", options->health.ptr);

×

371

  if (options->via > 0) {

×

372

    printf("  via: %d\n", options->via);

×

374

    printf("  via: nil\n");

×

376

  for (int i = 0; i < options->optionsNum; ++i) {

×

377

    printf("  option[%d]: %s\n", i, options->options[i].ptr);

×

379

×

380

int32_t xSerializeTaskOptions(SEncoder *encoder, xTaskOptions *options) {

×

381

  int32_t code = 0;

×

382

  int32_t lino = 0;

×

383

  TAOS_CHECK_EXIT(tEncodeI32(encoder, options->via));

×

384

  TAOS_CHECK_EXIT(xEncodeCowStr(encoder, &options->parser));

×

386

  TAOS_CHECK_EXIT(xEncodeCowStr(encoder, &options->trigger));

×

387

  TAOS_CHECK_EXIT(xEncodeCowStr(encoder, &options->health));

×

388

  TAOS_CHECK_EXIT(tEncodeI32(encoder, options->optionsNum));

×

389

  for (int i = 0; i < options->optionsNum && i < TSDB_XNODE_TASK_OPTIONS_MAX_NUM; i++) {

×

390

    TAOS_CHECK_EXIT(xEncodeCowStr(encoder, &options->options[i]));

×

392

_exit:

×

393

  return code;

×

395

int32_t xDeserializeTaskOptions(SDecoder *decoder, xTaskOptions *options) {

×

396

  if (decoder == NULL || options == NULL) {

×

397

    return TSDB_CODE_MND_XNODE_INVALID_MSG;

×

399

  int32_t code = 0;

×

400

  int32_t  lino = 0;

×

402

  TAOS_CHECK_EXIT(tDecodeI32(decoder, &options->via));

×

403

  TAOS_CHECK_EXIT(xDecodeCowStr(decoder, &options->parser, true));

×

405

  TAOS_CHECK_EXIT(xDecodeCowStr(decoder, &options->trigger, true));

×

406

  TAOS_CHECK_EXIT(xDecodeCowStr(decoder, &options->health, true));

×

407

  TAOS_CHECK_EXIT(tDecodeI32(decoder, &options->optionsNum));

×

408

  for (int i = 0; i < options->optionsNum && i < TSDB_XNODE_TASK_OPTIONS_MAX_NUM; i++) {

×

409

    TAOS_CHECK_EXIT(xDecodeCowStr(decoder, &options->options[i], true));

×

411

_exit:

×

412

  return code;

×

414

int32_t tSerializeXnodeTaskSource(SEncoder *encoder, xTaskSource *source) {

×

415

  int32_t code = 0;

×

416

  int32_t lino = 0;

×

417

  int32_t tlen = 0;

×

418

  TAOS_CHECK_EXIT(tEncodeI32(encoder, source->type));

×

419

  TAOS_CHECK_EXIT(xEncodeCowStr(encoder, &source->cstr));

×

420

_exit:

×

421

  return code;

×

424

int32_t tDeserializeXnodeTaskSource(SDecoder *decoder, xTaskSource *source) {

×

425

  int32_t code = 0;

×

426

  int32_t lino = 0;

×

428

  TAOS_CHECK_EXIT(tDecodeI32(decoder, (int32_t *)&source->type));

×

429

  TAOS_CHECK_EXIT(xDecodeCowStr(decoder, &source->cstr, true));

×

430

_exit:

×

431

  return code;

×

433

int32_t tSerializeSMCreateXnodeTaskReq(void *buf, int32_t bufLen, SMCreateXnodeTaskReq *pReq) {

×

434

  SEncoder encoder = {0};

×

435

  int32_t  code = 0;

×

436

  int32_t  lino = 0;

×

437

  int32_t  tlen = 0;

×

438

  tEncoderInit(&encoder, buf, bufLen);

×

440

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

441

  ENCODESQL();

×

442

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->xnodeId));

×

443

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->name));

×

444

  TAOS_CHECK_EXIT(xSerializeTaskSource(&encoder, &pReq->source));

×

445

  TAOS_CHECK_EXIT(xSerializeTaskSink(&encoder, &pReq->sink));

×

446

  TAOS_CHECK_EXIT(xSerializeTaskOptions(&encoder, &pReq->options));

×

447

  tEndEncode(&encoder);

×

449

_exit:

×

450

  if (code) {

×

451

    tlen = code;

×

453

    tlen = encoder.pos;

×

455

  tEncoderClear(&encoder);

×

456

  return tlen;

×

458

int32_t tDeserializeSMCreateXnodeTaskReq(void *buf, int32_t bufLen, SMCreateXnodeTaskReq *pReq) {

×

459

  SDecoder decoder = {0};

×

460

  int32_t  code = 0;

×

461

  int32_t  lino = 0;

×

463

  tDecoderInit(&decoder, buf, bufLen);

×

465

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

466

  DECODESQL();

×

467

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->xnodeId));

×

468

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->name, true));

×

469

  TAOS_CHECK_EXIT(xDeserializeTaskSource(&decoder, &pReq->source));

×

470

  TAOS_CHECK_EXIT(xDeserializeTaskSink(&decoder, &pReq->sink));

×

471

  TAOS_CHECK_EXIT(xDeserializeTaskOptions(&decoder, &pReq->options));

×

472

  tEndDecode(&decoder);

×

474

_exit:

×

475

  tDecoderClear(&decoder);

×

476

  return code;

×

478

void tFreeSMCreateXnodeTaskReq(SMCreateXnodeTaskReq *pReq) {

×

480

  FREESQL();

×

481

  xFreeCowStr(&pReq->name);

×

482

  xFreeTaskSource(&pReq->source);

×

483

  xFreeTaskSink(&pReq->sink);

×

484

  xFreeTaskOptions(&pReq->options);

×

485

×

486

int32_t tSerializeSMDropXnodeTaskReq(void *buf, int32_t bufLen, SMDropXnodeTaskReq *pReq) {

×

488

  SEncoder encoder = {0};

×

489

  int32_t  code = 0;

×

490

  int32_t  lino = 0;

×

491

  int32_t  tlen = 0;

×

493

  tEncoderInit(&encoder, buf, bufLen);

×

495

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

496

  ENCODESQL();

×

497

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->id));

×

498

  TAOS_CHECK_EXIT(tEncodeBool(&encoder, pReq->force));

×

499

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->name));

×

500

  tEndEncode(&encoder);

×

502

_exit:

×

503

  if (code) {

×

504

    tlen = code;

×

506

    tlen = encoder.pos;

×

508

  tEncoderClear(&encoder);

×

509

  return tlen;

×

511

int32_t tDeserializeSMDropXnodeTaskReq(void *buf, int32_t bufLen, SMDropXnodeTaskReq *pReq) {

×

513

  SDecoder decoder = {0};

×

514

  int32_t  code = 0;

×

515

  int32_t  lino = 0;

×

516

  tDecoderInit(&decoder, buf, bufLen);

×

518

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

519

  DECODESQL();

×

520

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->id));

×

521

  TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pReq->force));

×

522

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->name, true));

×

523

  tEndDecode(&decoder);

×

525

_exit:

×

526

  tDecoderClear(&decoder);

×

527

  return code;

×

529

void tFreeSMDropXnodeTaskReq(SMDropXnodeTaskReq *pReq) {

×

530

  FREESQL();

×

531

  xFreeCowStr(&pReq->name);

×

532

×

534

int32_t tSerializeSMStartXnodeTaskReq(void *buf, int32_t bufLen, SMStartXnodeTaskReq *pReq) {

×

535

  SEncoder encoder = {0};

×

536

  int32_t  code = 0;

×

537

  int32_t  lino = 0;

×

538

  int32_t  tlen = 0;

×

540

  tEncoderInit(&encoder, buf, bufLen);

×

542

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

543

  ENCODESQL();

×

544

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->tid));

×

545

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->name));

×

546

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->sqlLen));

×

547

  tEndEncode(&encoder);

×

549

_exit:

×

550

  if (code) {

×

551

    tlen = code;

×

553

    tlen = encoder.pos;

×

555

  tEncoderClear(&encoder);

×

556

  return tlen;

×

558

int32_t tDeserializeSMStartXnodeTaskReq(void *buf, int32_t bufLen, SMStartXnodeTaskReq *pReq) {

×

559

  SDecoder decoder = {0};

×

560

  int32_t  code = 0;

×

561

  int32_t  lino = 0;

×

562

  tDecoderInit(&decoder, buf, bufLen);

×

564

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

565

  DECODESQL();

×

566

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->tid));

×

567

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->name, true));

×

568

  tEndDecode(&decoder);

×

570

_exit:

×

571

  tDecoderClear(&decoder);

×

572

  return code;

×

574

void tFreeSMStartXnodeTaskReq(SMStartXnodeTaskReq *pReq) {

×

575

  FREESQL();

×

576

  xFreeCowStr(&pReq->name);

×

577

×

579

int32_t tSerializeSMStopXnodeTaskReq(void *buf, int32_t bufLen, SMStopXnodeTaskReq *pReq) {

×

580

  return tSerializeSMStartXnodeTaskReq(buf, bufLen, pReq);

×

582

int32_t tDeserializeSMStopXnodeTaskReq(void *buf, int32_t bufLen, SMStopXnodeTaskReq *pReq) {

×

583

  return tDeserializeSMStartXnodeTaskReq(buf, bufLen, pReq);

×

585

void tFreeSMStopXnodeTaskReq(SMStopXnodeTaskReq *pReq) { tFreeSMStartXnodeTaskReq(pReq); }

×

587

int32_t tSerializeSMUpdateXnodeTaskReq(void *buf, int32_t bufLen, SMUpdateXnodeTaskReq *pReq) {

×

588

  SEncoder encoder = {0};

×

589

  int32_t  code = 0;

×

590

  int32_t  lino = 0;

×

591

  int32_t  tlen = 0;

×

592

  tEncoderInit(&encoder, buf, bufLen);

×

594

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

595

  ENCODESQL();

×

596

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->tid));

×

597

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->name));

×

598

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->via));

×

599

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->xnodeId));

×

600

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->status));

×

601

  TAOS_CHECK_EXIT(xSerializeTaskSource(&encoder, &pReq->source));

×

602

  TAOS_CHECK_EXIT(xSerializeTaskSink(&encoder, &pReq->sink));

×

603

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->parser));

×

604

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->reason));

×

605

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->labels));

×

606

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->updateName));

×

607

  tEndEncode(&encoder);

×

609

_exit:

×

610

  if (code) {

×

611

    tlen = code;

×

613

    tlen = encoder.pos;

×

615

  tEncoderClear(&encoder);

×

616

  return tlen;

×

619

int32_t tDeserializeSMUpdateXnodeTaskReq(void *buf, int32_t bufLen, SMUpdateXnodeTaskReq *pReq) {

×

620

  SDecoder decoder = {0};

×

621

  int32_t  code = 0;

×

622

  int32_t  lino = 0;

×

624

  tDecoderInit(&decoder, buf, bufLen);

×

626

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

627

  DECODESQL();

×

628

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->tid));

×

629

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->name, true));

×

630

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->via));

×

631

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->xnodeId));

×

632

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->status, true));

×

633

  TAOS_CHECK_EXIT(xDeserializeTaskSource(&decoder, &pReq->source));

×

634

  TAOS_CHECK_EXIT(xDeserializeTaskSink(&decoder, &pReq->sink));

×

635

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->parser, true));

×

636

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->reason, true));

×

637

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->labels, true));

×

638

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->updateName, true));

×

639

  tEndDecode(&decoder);

×

641

_exit:

×

642

  tDecoderClear(&decoder);

×

643

  return code;

×

646

void tFreeSMUpdateXnodeTaskReq(SMUpdateXnodeTaskReq *pReq) {

×

648

  xFreeCowStr(&pReq->name);

×

649

  xFreeTaskSource(&pReq->source);

×

650

  xFreeTaskSink(&pReq->sink);

×

651

  xFreeCowStr(&pReq->parser);

×

652

  xFreeCowStr(&pReq->reason);

×

653

  xFreeCowStr(&pReq->status);

×

654

  xFreeCowStr(&pReq->labels);

×

655

  xFreeCowStr(&pReq->updateName);

×

656

  FREESQL();

×

657

×

659

int32_t tSerializeSMDropXnodeReq(void *buf, int32_t bufLen, SMDropXnodeReq *pReq) {

×

660

  SEncoder encoder = {0};

×

661

  int32_t  code = 0;

×

662

  int32_t  lino = 0;

×

663

  int32_t  tlen = 0;

×

664

  tEncoderInit(&encoder, buf, bufLen);

×

666

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

667

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->xnodeId));

×

668

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->force));

×

669

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->urlLen));

×

670

  if (pReq->urlLen > 0) {

×

671

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (const uint8_t *)pReq->url, pReq->urlLen));

×

673

  ENCODESQL();

×

674

  tEndEncode(&encoder);

×

676

_exit:

×

677

  if (code) {

×

678

    tlen = code;

×

680

    tlen = encoder.pos;

×

682

  tEncoderClear(&encoder);

×

683

  return tlen;

×

686

int32_t tDeserializeSMDropXnodeReq(void *buf, int32_t bufLen, SMDropXnodeReq *pReq) {

×

687

  SDecoder decoder = {0};

×

688

  int32_t  code = 0;

×

689

  int32_t  lino = 0;

×

691

  tDecoderInit(&decoder, buf, bufLen);

×

693

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

694

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->xnodeId));

×

695

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->force));

×

696

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->urlLen));

×

697

  if (pReq->urlLen > 0) {

×

698

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->url, NULL));

×

700

  DECODESQL();

×

701

  tEndDecode(&decoder);

×

703

_exit:

×

704

  tDecoderClear(&decoder);

×

705

  return code;

×

708

void tFreeSMDropXnodeReq(SMDropXnodeReq *pReq) {

×

709

  FREESQL();

×

710

  if (pReq->urlLen > 0 && pReq->url != NULL) {

×

711

    taosMemoryFree(pReq->url);

×

713

×

715

int32_t tSerializeSMDrainXnodeReq(void *buf, int32_t bufLen, SMDrainXnodeReq *pReq) {

×

716

  SEncoder encoder = {0};

×

717

  int32_t  code = 0;

×

718

  int32_t  lino = 0;

×

719

  int32_t  tlen = 0;

×

720

  tEncoderInit(&encoder, buf, bufLen);

×

722

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

723

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->xnodeId));

×

724

  ENCODESQL();

×

725

  tEndEncode(&encoder);

×

727

_exit:

×

728

  if (code) {

×

729

    tlen = code;

×

731

    tlen = encoder.pos;

×

733

  tEncoderClear(&encoder);

×

734

  return tlen;

×

737

int32_t tDeserializeSMDrainXnodeReq(void *buf, int32_t bufLen, SMDrainXnodeReq *pReq) {

×

738

  SDecoder decoder = {0};

×

739

  int32_t  code = 0;

×

740

  int32_t  lino = 0;

×

742

  tDecoderInit(&decoder, buf, bufLen);

×

744

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

745

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->xnodeId));

×

746

  DECODESQL();

×

747

  tEndDecode(&decoder);

×

749

_exit:

×

750

  tDecoderClear(&decoder);

×

751

  return code;

×

754

void tFreeSMDrainXnodeReq(SMDrainXnodeReq *pReq) { FREESQL(); }

×

756

int32_t tSerializeSMUpdateXnodeReq(void *buf, int32_t bufLen, SMUpdateXnodeReq *pReq) {

×

757

  SEncoder encoder = {0};

×

758

  int32_t  code = 0;

×

759

  int32_t  lino = 0;

×

760

  int32_t  tlen = 0;

×

761

  tEncoderInit(&encoder, buf, bufLen);

×

763

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

764

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->id));

×

765

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->token));

×

766

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->user));

×

767

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->pass));

×

768

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->urlLen));

×

769

  if (pReq->urlLen > 0) {

×

770

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (const uint8_t *)pReq->url, pReq->urlLen));

×

772

  ENCODESQL();

×

773

  tEndEncode(&encoder);

×

775

_exit:

×

776

  if (code) {

×

777

    tlen = code;

×

779

    tlen = encoder.pos;

×

781

  tEncoderClear(&encoder);

×

782

  return tlen;

×

785

int32_t tDeserializeSMUpdateXnodeReq(void *buf, int32_t bufLen, SMUpdateXnodeReq *pReq) {

×

786

  SDecoder decoder = {0};

×

787

  int32_t  code = 0;

×

788

  int32_t  lino = 0;

×

790

  tDecoderInit(&decoder, buf, bufLen);

×

792

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

793

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->id));

×

794

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->token, true));

×

795

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->user, true));

×

796

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->pass, true));

×

797

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->urlLen));

×

798

  if (pReq->urlLen > 0) {

×

799

    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->url, NULL));

×

801

  DECODESQL();

×

802

  tEndDecode(&decoder);

×

804

_exit:

×

805

  tDecoderClear(&decoder);

×

806

  return code;

×

809

void tFreeSMUpdateXnodeReq(SMUpdateXnodeReq *pReq) {

×

810

  FREESQL();

×

811

  if (pReq->urlLen > 0 && pReq->url != NULL) {

×

812

    taosMemoryFree(pReq->url);

×

814

  xFreeCowStr(&pReq->token);

×

815

  xFreeCowStr(&pReq->user);

×

816

  xFreeCowStr(&pReq->pass);

×

817

×

819

int32_t tSerializeSMCreateXnodeJobReq(void *buf, int32_t bufLen, SMCreateXnodeJobReq *pReq) {

×

820

  SEncoder encoder = {0};

×

821

  int32_t  code = 0;

×

822

  int32_t  lino = 0;

×

823

  int32_t  tlen = 0;

×

825

  tEncoderInit(&encoder, buf, bufLen);

×

827

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

829

  ENCODESQL();

×

831

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->tid));

×

832

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->via));

×

833

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->xnodeId));

×

834

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->status));

×

835

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->config));

×

836

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->reason));

×

837

  tEndEncode(&encoder);

×

839

_exit:

×

840

  if (code) {

×

841

    tlen = code;

×

843

    tlen = encoder.pos;

×

845

  tEncoderClear(&encoder);

×

846

  return tlen;

×

849

int32_t tDeserializeSMCreateXnodeJobReq(void *buf, int32_t bufLen, SMCreateXnodeJobReq *pReq) {

×

851

  SDecoder decoder = {0};

×

852

  int32_t  code = 0;

×

853

  int32_t  lino = 0;

×

855

  tDecoderInit(&decoder, buf, bufLen);

×

857

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

858

  DECODESQL();

×

859

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->tid));

×

860

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->via));

×

861

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->xnodeId));

×

862

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->status, true));

×

863

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->config, true));

×

864

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->reason, true));

×

865

  tEndDecode(&decoder);

×

867

_exit:

×

868

  tDecoderClear(&decoder);

×

869

  return code;

×

871

void tFreeSMCreateXnodeJobReq(SMCreateXnodeJobReq *pReq) {

×

872

  FREESQL();

×

873

  xFreeCowStr(&pReq->config);

×

874

  xFreeCowStr(&pReq->reason);

×

875

  xFreeCowStr(&pReq->status);

×

876

×

878

int32_t tSerializeSMUpdateXnodeJobReq(void *buf, int32_t bufLen, SMUpdateXnodeJobReq *pReq) {

×

879

  SEncoder encoder = {0};

×

880

  int32_t  code = 0;

×

881

  int32_t  lino = 0;

×

882

  int32_t  tlen = 0;

×

884

  tEncoderInit(&encoder, buf, bufLen);

×

886

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

888

  ENCODESQL();

×

890

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->jid));

×

891

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->via));

×

892

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->xnodeId));

×

893

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->status));

×

894

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->configLen));

×

895

  if (pReq->config != NULL) {

×

896

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (const uint8_t *)pReq->config, pReq->configLen + 1));

×

898

    TAOS_CHECK_EXIT(tEncodeU32v(&encoder, 0));

×

900

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->reasonLen));

×

901

  if (pReq->reason != NULL) {

×

902

    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (const uint8_t *)pReq->reason, pReq->reasonLen + 1));

×

904

    TAOS_CHECK_EXIT(tEncodeU32v(&encoder, 0));

×

906

  tEndEncode(&encoder);

×

908

_exit:

×

909

  if (code) {

×

910

    tlen = code;

×

912

    tlen = encoder.pos;

×

914

  tEncoderClear(&encoder);

×

915

  return tlen;

×

918

int32_t tDeserializeSMUpdateXnodeJobReq(void *buf, int32_t bufLen, SMUpdateXnodeJobReq *pReq) {

×

919

  SDecoder decoder = {0};

×

920

  int32_t  code = 0;

×

921

  int32_t  lino = 0;

×

923

  tDecoderInit(&decoder, buf, bufLen);

×

925

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

926

  DECODESQL();

×

927

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->jid));

×

928

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->via));

×

929

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->xnodeId));

×

930

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->status, true));

×

931

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->configLen));

×

932

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->config, NULL));

×

933

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->reasonLen));

×

934

  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->reason, NULL));

×

935

  tEndDecode(&decoder);

×

937

_exit:

×

938

  tDecoderClear(&decoder);

×

939

  return code;

×

942

void tFreeSMUpdateXnodeJobReq(SMUpdateXnodeJobReq *pReq) {

×

943

  FREESQL();

×

944

  if (pReq->config != NULL) {

×

945

    pReq->configLen = 0;

×

946

    taosMemoryFreeClear(pReq->config);

×

948

  if (pReq->reason != NULL) {

×

949

    pReq->reasonLen = 0;

×

950

    taosMemoryFreeClear(pReq->reason);

×

952

  xFreeCowStr(&pReq->status);

×

953

×

955

int32_t tSerializeSMRebalanceXnodeJobReq(void *buf, int32_t bufLen, SMRebalanceXnodeJobReq *pReq) {

×

956

  SEncoder encoder = {0};

×

957

  int32_t  code = 0;

×

958

  int32_t  lino = 0;

×

959

  int32_t  tlen = 0;

×

961

  tEncoderInit(&encoder, buf, bufLen);

×

963

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

964

  ENCODESQL();

×

965

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->jid));

×

966

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->xnodeId));

×

968

  tEndEncode(&encoder);

×

969

_exit:

×

970

  if (code) {

×

971

    tlen = code;

×

973

    tlen = encoder.pos;

×

975

  tEncoderClear(&encoder);

×

976

  return tlen;

×

978

int32_t tDeserializeSMRebalanceXnodeJobReq(void *buf, int32_t bufLen, SMRebalanceXnodeJobReq *pReq) {

×

979

  SDecoder decoder = {0};

×

980

  int32_t  code = 0;

×

981

  int32_t  lino = 0;

×

983

  tDecoderInit(&decoder, buf, bufLen);

×

985

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

986

  DECODESQL();

×

987

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->jid));

×

988

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->xnodeId));

×

990

  tEndDecode(&decoder);

×

991

_exit:

×

992

  tDecoderClear(&decoder);

×

993

  return code;

×

996

void tFreeSMRebalanceXnodeJobReq(SMRebalanceXnodeJobReq *pReq) { FREESQL(); }

×

998

int32_t tSerializeSMRebalanceXnodeJobsWhereReq(void *buf, int32_t bufLen, SMRebalanceXnodeJobsWhereReq *pReq) {

×

999

  SEncoder encoder = {0};

×

1000

  int32_t  code = 0;

×

1001

  int32_t  lino = 0;

×

1002

  int32_t  tlen = 0;

×

1004

  tEncoderInit(&encoder, buf, bufLen);

×

1006

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

1007

  ENCODESQL();

×

1008

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->ast));

×

1009

  tEndEncode(&encoder);

×

1010

_exit:

×

1011

  if (code) {

×

1012

    tlen = code;

×

1014

    tlen = encoder.pos;

×

1016

  tEncoderClear(&encoder);

×

1017

  return tlen;

×

1019

int32_t tDeserializeSMRebalanceXnodeJobsWhereReq(void *buf, int32_t bufLen, SMRebalanceXnodeJobsWhereReq *pReq) {

×

1020

  SDecoder decoder = {0};

×

1021

  int32_t  code = 0;

×

1022

  int32_t  lino = 0;

×

1024

  tDecoderInit(&decoder, buf, bufLen);

×

1026

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

1027

  DECODESQL();

×

1028

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->ast, true));

×

1030

  tEndDecode(&decoder);

×

1031

_exit:

×

1032

  tDecoderClear(&decoder);

×

1033

  return code;

×

1036

void tFreeSMRebalanceXnodeJobsWhereReq(SMRebalanceXnodeJobsWhereReq *pReq) {

×

1037

  FREESQL();

×

1038

  xFreeCowStr(&pReq->ast);

×

1039

×

1041

int32_t tSerializeSMDropXnodeJobReq(void *buf, int32_t bufLen, SMDropXnodeJobReq *pReq) {

×

1042

  SEncoder encoder = {0};

×

1043

  int32_t  code = 0;

×

1044

  int32_t  lino = 0;

×

1045

  int32_t  tlen = 0;

×

1047

  tEncoderInit(&encoder, buf, bufLen);

×

1049

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

1050

  ENCODESQL();

×

1051

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->jid));

×

1052

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->ast));

×

1054

  tEndEncode(&encoder);

×

1055

_exit:

×

1056

  if (code) {

×

1057

    tlen = code;

×

1059

    tlen = encoder.pos;

×

1061

  tEncoderClear(&encoder);

×

1062

  return tlen;

×

1064

int32_t tDeserializeSMDropXnodeJobReq(void *buf, int32_t bufLen, SMDropXnodeJobReq *pReq) {

×

1065

  SDecoder decoder = {0};

×

1066

  int32_t  code = 0;

×

1067

  int32_t  lino = 0;

×

1069

  tDecoderInit(&decoder, buf, bufLen);

×

1071

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

1072

  DECODESQL();

×

1073

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->jid));

×

1074

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->ast, true));

×

1076

  tEndDecode(&decoder);

×

1077

_exit:

×

1078

  tDecoderClear(&decoder);

×

1079

  return code;

×

1081

void tFreeSMDropXnodeJobReq(SMDropXnodeJobReq *pReq) {

×

1082

  FREESQL();

×

1083

  xFreeCowStr(&pReq->ast);

×

1084

×

1086

int32_t tSerializeSMCreateXnodeAgentReq(void *buf, int32_t bufLen, SMCreateXnodeAgentReq *pReq) {

×

1087

  SEncoder encoder = {0};

×

1088

  int32_t  code = 0;

×

1089

  int32_t  lino = 0;

×

1090

  int32_t  tlen = 0;

×

1091

  tEncoderInit(&encoder, buf, bufLen);

×

1093

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

1094

  ENCODESQL();

×

1095

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->name));

×

1096

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->status));

×

1097

  TAOS_CHECK_EXIT(xSerializeTaskOptions(&encoder, &pReq->options));

×

1098

  tEndEncode(&encoder);

×

1100

_exit:

×

1101

  if (code) {

×

1102

    tlen = code;

×

1104

    tlen = encoder.pos;

×

1106

  tEncoderClear(&encoder);

×

1107

  return tlen;

×

1110

int32_t tDeserializeSMCreateXnodeAgentReq(void *buf, int32_t bufLen, SMCreateXnodeAgentReq *pReq) {

×

1111

  SDecoder decoder = {0};

×

1112

  int32_t  code = 0;

×

1113

  int32_t  lino = 0;

×

1115

  tDecoderInit(&decoder, buf, bufLen);

×

1117

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

1118

  DECODESQL();

×

1119

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->name, true));

×

1120

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->status, true));

×

1121

  TAOS_CHECK_EXIT(xDeserializeTaskOptions(&decoder, &pReq->options));

×

1123

  tEndDecode(&decoder);

×

1124

_exit:

×

1125

  tDecoderClear(&decoder);

×

1126

  return code;

×

1129

void tFreeSMCreateXnodeAgentReq(SMCreateXnodeAgentReq *pReq) {

×

1130

  FREESQL();

×

1131

  xFreeCowStr(&pReq->name);

×

1132

  xFreeCowStr(&pReq->status);

×

1133

  xFreeTaskOptions(&pReq->options);

×

1134

×

1136

int32_t tSerializeSMUpdateXnodeAgentReq(void *buf, int32_t bufLen, SMUpdateXnodeAgentReq *pReq) {

×

1137

  SEncoder encoder = {0};

×

1138

  int32_t  code = 0;

×

1139

  int32_t  lino = 0;

×

1140

  int32_t  tlen = 0;

×

1141

  tEncoderInit(&encoder, buf, bufLen);

×

1143

  TAOS_CHECK_EXIT(tStartEncode(&encoder));

×

1144

  ENCODESQL();

×

1145

  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->id));

×

1146

  TAOS_CHECK_EXIT(xEncodeCowStr(&encoder, &pReq->name));

×

1147

  TAOS_CHECK_EXIT(xSerializeTaskOptions(&encoder, &pReq->options));

×

1148

  tEndEncode(&encoder);

×

1150

_exit:

×

1151

  if (code) {

×

1152

    tlen = code;

×

1154

    tlen = encoder.pos;

×

1156

  tEncoderClear(&encoder);

×

1157

  return tlen;

×

1159

int32_t tDeserializeSMUpdateXnodeAgentReq(void *buf, int32_t bufLen, SMUpdateXnodeAgentReq *pReq) {

×

1160

  SDecoder decoder = {0};

×

1161

  int32_t  code = 0;

×

1162

  int32_t  lino = 0;

×

1164

  tDecoderInit(&decoder, buf, bufLen);

×

1166

  TAOS_CHECK_EXIT(tStartDecode(&decoder));

×

1167

  DECODESQL();

×

1168

  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->id));

×

1169

  TAOS_CHECK_EXIT(xDecodeCowStr(&decoder, &pReq->name, true));

×

1170

  TAOS_CHECK_EXIT(xDeserializeTaskOptions(&decoder, &pReq->options));

×

1172

  tEndDecode(&decoder);

×

1173

_exit:

×

1174

  tDecoderClear(&decoder);

×

1175

  return code;

×

1177

void tFreeSMUpdateXnodeAgentReq(SMUpdateXnodeAgentReq *pReq) {

×

1178

  FREESQL();

×

1179

  xFreeCowStr(&pReq->name);

×

1180

  xFreeTaskOptions(&pReq->options);

×

1181

×

1183

int32_t tSerializeSMDropXnodeAgentReq(void *buf, int32_t bufLen, SMDropXnodeAgentReq *pReq) {

×

1184

  return tSerializeSMDropXnodeTaskReq(buf, bufLen, (SMDropXnodeTaskReq *)pReq);

×

1186

int32_t tDeserializeSMDropXnodeAgentReq(void *buf, int32_t bufLen, SMDropXnodeAgentReq *pReq) {

×

1187

  return tDeserializeSMDropXnodeTaskReq(buf, bufLen, (SMDropXnodeTaskReq *)pReq);

×

1189

void tFreeSMDropXnodeAgentReq(SMDropXnodeAgentReq *pReq) { tFreeSMDropXnodeTaskReq((SMDropXnodeTaskReq *)pReq); }

×

taosdata / TDengine / #4986

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

taosdata / TDengine / #4986

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