taosdata / TDengine / #4986

coverage: 37.305% (-31.3%) from 68.601%
#4986

push

travis-ci

tomchon 
test: keep docs and unit test

125478 of 336361 relevant lines covered (37.3%)

1134847.06 hits per line

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

0.23
/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
1 
/*
2 
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3 
 *
4 
 * This program is free software: you can use, redistribute, and/or modify
5 
 * it under the terms of the GNU Affero General Public License, version 3
6 
 * or later ("AGPL"), as published by the Free Software Foundation.
7 
 *
8 
 * This program is distributed in the hope that it will be useful, but WITHOUT
9 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 
 * FITNESS FOR A PARTICULAR PURPOSE.
11 
 *
12 
 * You should have received a copy of the GNU Affero General Public License
13 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 
 */
15 









16



#include "tsdb.h"










17



#include "tsdbFS2.h"










18












19



#define TSDB_SNAP_MSG_VER 1










20












21



// fset partition










22



static int32_t tsdbFSetPartCmprFn(STsdbFSetPartition* x, STsdbFSetPartition* y) {




×







23



  if (x->fid < y->fid) return -1;




×







24



  if (x->fid > y->fid) return 1;




×







25



  return 0;




×







26



}










27












28



static int32_t tVersionRangeCmprFn(SVersionRange* x, SVersionRange* y) {




×







29



  if (x->minVer < y->minVer) return -1;




×







30



  if (x->minVer > y->minVer) return 1;




×







31



  if (x->maxVer < y->maxVer) return -1;




×







32



  if (x->maxVer > y->maxVer) return 1;




×







33



  return 0;




×







34



}










35












36



static int32_t tsdbTFileSetRangeCmprFn(STFileSetRange* x, STFileSetRange* y) {




×







37



  if (x->fid < y->fid) return -1;




×







38



  if (x->fid > y->fid) return 1;




×







39



  return 0;




×







40



}










41












42



STsdbFSetPartition* tsdbFSetPartitionCreate() {




×







43



  STsdbFSetPartition* pSP = taosMemoryCalloc(1, sizeof(STsdbFSetPartition));




×







44



  if (pSP == NULL) {




×







45



    return NULL;




×







46



  }










47



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




×







48



    TARRAY2_INIT(&pSP->verRanges[i]);




×







49



  }










50



  return pSP;




×







51



}










52












53



void tsdbFSetPartitionClear(STsdbFSetPartition** ppSP) {




×







54



  if (ppSP == NULL || ppSP[0] == NULL) {




×







55



    return;




×







56



  }










57



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




×







58



    TARRAY2_DESTROY(&ppSP[0]->verRanges[i], NULL);




×







59



  }










60



  taosMemoryFree(ppSP[0]);




×







61



  ppSP[0] = NULL;




×







62



}










63












64



static int32_t tsdbFTypeToFRangeType(tsdb_ftype_t ftype) {




×







65



  switch (ftype) {




×







66



    case TSDB_FTYPE_HEAD:




×







67



      return TSDB_FSET_RANGE_TYP_HEAD;




×







68



    case TSDB_FTYPE_DATA:




×







69



      return TSDB_FSET_RANGE_TYP_DATA;




×







70



    case TSDB_FTYPE_SMA:




×







71



      return TSDB_FSET_RANGE_TYP_SMA;




×







72



    case TSDB_FTYPE_TOMB:




×







73



      return TSDB_FSET_RANGE_TYP_TOMB;




×







74



    case TSDB_FTYPE_STT:




×







75



      return TSDB_FSET_RANGE_TYP_STT;




×







76



  }










77



  return TSDB_FSET_RANGE_TYP_MAX;




×







78



}










79












80



static int32_t tsdbTFileSetToFSetPartition(STFileSet* fset, STsdbFSetPartition** ppSP) {




×







81



  STsdbFSetPartition* p = tsdbFSetPartitionCreate();




×







82



  if (p == NULL) {




×







83



    return terrno;




×







84



  }










85












86



  p->fid = fset->fid;




×







87












88



  int32_t code = 0;




×







89



  int32_t typ = 0;




×







90



  int32_t corrupt = false;




×







91



  int32_t count = 0;




×







92



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




×







93



    if (fset->farr[ftype] == NULL) continue;




×







94



    typ = tsdbFTypeToFRangeType(ftype);




×







95



    STFile* f = fset->farr[ftype]->f;




×







96



    if (f->maxVer > fset->maxVerValid) {




×







97



      corrupt = true;




×







98



      tsdbError("skip incomplete data file: fid:%d, maxVerValid:%" PRId64 ", minVer:%" PRId64 ", maxVer:%" PRId64




×







99



                ", ftype: %d",










100



                fset->fid, fset->maxVerValid, f->minVer, f->maxVer, ftype);










101



      continue;




×







102



    }










103



    count++;




×







104



    SVersionRange vr = {.minVer = f->minVer, .maxVer = f->maxVer};




×







105



    code = TARRAY2_SORT_INSERT(&p->verRanges[typ], vr, tVersionRangeCmprFn);




×







106



    if (code) {




×







107



      tsdbFSetPartitionClear(&p);




×







108



      return code;




×







109



    }










110



  }










111












112



  typ = TSDB_FSET_RANGE_TYP_STT;




×







113



  const SSttLvl* lvl;










114



  TARRAY2_FOREACH(fset->lvlArr, lvl) {




×







115



    STFileObj* fobj;










116



    TARRAY2_FOREACH(lvl->fobjArr, fobj) {




×







117



      STFile* f = fobj->f;




×







118



      if (f->maxVer > fset->maxVerValid) {




×







119



        corrupt = true;




×







120



        tsdbError("skip incomplete stt file.fid:%d, maxVerValid:%" PRId64 ", minVer:%" PRId64 ", maxVer:%" PRId64




×







121



                  ", ftype: %d",










122



                  fset->fid, fset->maxVerValid, f->minVer, f->maxVer, typ);










123



        continue;




×







124



      }










125



      count++;




×







126



      SVersionRange vr = {.minVer = f->minVer, .maxVer = f->maxVer};




×







127



      code = TARRAY2_SORT_INSERT(&p->verRanges[typ], vr, tVersionRangeCmprFn);




×







128



      if (code) {




×







129



        tsdbFSetPartitionClear(&p);




×







130



        return code;




×







131



      }










132



    }










133



  }










134



  if (corrupt && count == 0) {




×







135



    SVersionRange vr = {.minVer = VERSION_MIN, .maxVer = fset->maxVerValid};




×







136



    code = TARRAY2_SORT_INSERT(&p->verRanges[typ], vr, tVersionRangeCmprFn);




×







137



    if (code) {




×







138



      tsdbFSetPartitionClear(&p);




×







139



      return code;




×







140



    }










141



  }










142



  ppSP[0] = p;




×







143



  return 0;




×







144



}










145












146



// fset partition list










147



STsdbFSetPartList* tsdbFSetPartListCreate() {




×







148



  STsdbFSetPartList* pList = taosMemoryCalloc(1, sizeof(STsdbFSetPartList));




×







149



  if (pList == NULL) {




×







150



    return NULL;




×







151



  }










152



  TARRAY2_INIT(pList);




×







153



  return pList;




×







154



}










155












156



void tsdbFSetPartListDestroy(STsdbFSetPartList** ppList) {




×







157



  if (ppList == NULL || ppList[0] == NULL) return;




×







158












159



  TARRAY2_DESTROY(ppList[0], tsdbFSetPartitionClear);




×







160



  taosMemoryFree(ppList[0]);




×







161



  ppList[0] = NULL;




×







162



}










163












164



int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray** ppRanges) {




×







165



  int32_t code = 0;




×







166












167



  TFileSetRangeArray* pDiff = taosMemoryCalloc(1, sizeof(TFileSetRangeArray));




×







168



  if (pDiff == NULL) {




×







169



    code = terrno;




×







170



    goto _err;




×







171



  }










172



  TARRAY2_INIT(pDiff);




×







173












174



  STsdbFSetPartition* part;










175



  TARRAY2_FOREACH(pList, part) {




×







176



    STFileSetRange* r = taosMemoryCalloc(1, sizeof(STFileSetRange));




×







177



    if (r == NULL) {




×







178



      code = terrno;




×







179



      goto _err;




×







180



    }










181



    int64_t maxVerValid = -1;




×







182



    int32_t typMax = TSDB_FSET_RANGE_TYP_MAX;




×







183



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




×







184



      SVerRangeList* iList = &part->verRanges[i];




×







185



      SVersionRange  vr = {0};




×







186



      TARRAY2_FOREACH(iList, vr) {




×







187



        if (vr.maxVer < vr.minVer) {




×







188



          continue;




×







189



        }










190



        maxVerValid = TMAX(maxVerValid, vr.maxVer);




×







191



      }










192



    }










193



    r->fid = part->fid;




×







194



    r->sver = maxVerValid + 1;




×







195



    r->ever = VERSION_MAX;




×







196



    tsdbDebug("range diff fid:%" PRId64 ", sver:%" PRId64 ", ever:%" PRId64, part->fid, r->sver, r->ever);




×







197



    code = TARRAY2_SORT_INSERT(pDiff, r, tsdbTFileSetRangeCmprFn);




×







198



    if (code) {




×







199



      taosMemoryFree(r);




×







200



      goto _err;




×







201



    }










202



  }










203



  ppRanges[0] = pDiff;




×







204












205



  tsdbInfo("pDiff size:%d", TARRAY2_SIZE(pDiff));




×







206



  return 0;




×







207












208



_err:




×







209



  if (pDiff) {




×







210



    tsdbTFileSetRangeArrayDestroy(&pDiff);




×







211



  }










212



  return code;




×







213



}










214












215



// serialization










216



int32_t tTsdbFSetPartListDataLenCalc(STsdbFSetPartList* pList) {




×







217



  int32_t hdrLen = sizeof(int32_t);




×







218



  int32_t datLen = 0;




×







219












220



  int8_t  msgVer = 1;




×







221



  int32_t len = TARRAY2_SIZE(pList);




×







222



  hdrLen += sizeof(msgVer);




×







223



  hdrLen += sizeof(len);




×







224



  datLen += hdrLen;




×







225












226



  for (int32_t u = 0; u < len; u++) {




×







227



    STsdbFSetPartition* p = TARRAY2_GET(pList, u);




×







228



    int32_t             typMax = TSDB_FSET_RANGE_TYP_MAX;




×







229



    int32_t             uItem = 0;




×







230



    uItem += sizeof(STsdbFSetPartition);




×







231



    uItem += sizeof(typMax);




×







232












233



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




×







234



      int32_t iLen = TARRAY2_SIZE(&p->verRanges[i]);




×







235



      int32_t jItem = 0;




×







236



      jItem += sizeof(SVersionRange);




×







237



      jItem += sizeof(int64_t);




×







238



      uItem += sizeof(iLen) + jItem * iLen;




×







239



    }










240



    datLen += uItem;




×







241



  }










242



  return datLen;




×







243



}










244












245



static int32_t tSerializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList, int32_t* encodeSize) {




×







246



  SEncoder encoder = {0};




×







247



  int8_t   reserved8 = 0;




×







248



  int16_t  reserved16 = 0;




×







249



  int64_t  reserved64 = 0;




×







250



  int8_t   msgVer = TSDB_SNAP_MSG_VER;




×







251



  int32_t  len = TARRAY2_SIZE(pList);




×







252



  int32_t  code = 0;




×







253












254



  tEncoderInit(&encoder, buf, bufLen);




×







255



  if ((code = tStartEncode(&encoder))) goto _exit;




×







256



  if ((code = tEncodeI8(&encoder, msgVer))) goto _exit;




×







257



  if ((code = tEncodeI32(&encoder, len))) goto _exit;




×







258












259



  for (int32_t u = 0; u < len; u++) {




×







260



    STsdbFSetPartition* p = TARRAY2_GET(pList, u);




×







261



    if ((code = tEncodeI64(&encoder, p->fid))) goto _exit;




×







262



    if ((code = tEncodeI8(&encoder, p->stat))) goto _exit;




×







263



    if ((code = tEncodeI8(&encoder, reserved8))) goto _exit;




×







264



    if ((code = tEncodeI16(&encoder, reserved16))) goto _exit;




×







265












266



    int32_t typMax = TSDB_FSET_RANGE_TYP_MAX;




×







267



    if ((code = tEncodeI32(&encoder, typMax))) goto _exit;




×







268












269



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




×







270



      SVerRangeList* iList = &p->verRanges[i];




×







271



      int32_t        iLen = TARRAY2_SIZE(iList);




×







272












273



      if ((code = tEncodeI32(&encoder, iLen))) goto _exit;




×







274



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




×







275



        SVersionRange r = TARRAY2_GET(iList, j);




×







276



        if ((code = tEncodeI64(&encoder, r.minVer))) goto _exit;




×







277



        if ((code = tEncodeI64(&encoder, r.maxVer))) goto _exit;




×







278



        if ((code = tEncodeI64(&encoder, reserved64))) goto _exit;




×







279



      }










280



    }










281



  }










282












283



  tEndEncode(&encoder);




×







284












285



  if (encodeSize) {




×







286



    encodeSize[0] = encoder.pos;




×







287



  }










288












289



_exit:




×







290



  tEncoderClear(&encoder);




×







291



  return code;




×







292



}










293












294



int32_t tDeserializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList) {




×







295



  SDecoder decoder = {0};




×







296



  int8_t   reserved8 = 0;




×







297



  int16_t  reserved16 = 0;




×







298



  int64_t  reserved64 = 0;




×







299



  int32_t  code = 0;




×







300












301



  STsdbFSetPartition* p = NULL;




×







302












303



  tDecoderInit(&decoder, buf, bufLen);




×







304



  int8_t  msgVer = 0;




×







305



  int32_t len = 0;




×







306



  if ((code = tStartDecode(&decoder))) goto _err;




×







307



  if ((code = tDecodeI8(&decoder, &msgVer))) goto _err;




×







308



  if (msgVer != TSDB_SNAP_MSG_VER) {




×







309



    code = TSDB_CODE_INVALID_MSG;




×







310



    goto _err;




×







311



  }










312



  if ((code = tDecodeI32(&decoder, &len))) goto _err;




×







313












314



  for (int32_t u = 0; u < len; u++) {




×







315



    p = tsdbFSetPartitionCreate();




×







316



    if (p == NULL) {




×







317



      code = terrno;




×







318



      goto _err;




×







319



    }










320












321



    if ((code = tDecodeI64(&decoder, &p->fid))) goto _err;




×







322



    if ((code = tDecodeI8(&decoder, &p->stat))) goto _err;




×







323



    if ((code = tDecodeI8(&decoder, &reserved8))) goto _err;




×







324



    if ((code = tDecodeI16(&decoder, &reserved16))) goto _err;




×







325












326



    int32_t typMax = 0;




×







327



    if ((code = tDecodeI32(&decoder, &typMax))) goto _err;




×







328












329



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




×







330



      SVerRangeList* iList = &p->verRanges[i];




×







331



      int32_t        iLen = 0;




×







332



      if ((code = tDecodeI32(&decoder, &iLen))) goto _err;




×







333



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




×







334



        SVersionRange r = {0};




×







335



        if ((code = tDecodeI64(&decoder, &r.minVer))) goto _err;




×







336



        if ((code = tDecodeI64(&decoder, &r.maxVer))) goto _err;




×







337



        if ((code = tDecodeI64(&decoder, &reserved64))) goto _err;




×







338



        if ((code = TARRAY2_APPEND(iList, r))) goto _err;




×







339



      }










340



    }










341



    if ((code = TARRAY2_APPEND(pList, p))) goto _err;




×







342



    p = NULL;




×







343



  }










344












345



  tEndDecode(&decoder);




×







346



  tDecoderClear(&decoder);




×







347



  return 0;




×







348












349



_err:




×







350



  if (p) {




×







351



    tsdbFSetPartitionClear(&p);




×







352



  }










353



  tDecoderClear(&decoder);




×







354



  return code;




×







355



}










356












357



// fs state










358



static STsdbFSetPartList* tsdbSnapGetFSetPartList(STFileSystem* fs) {




×







359



  STsdbFSetPartList* pList = tsdbFSetPartListCreate();




×







360



  if (pList == NULL) {




×







361



    return NULL;




×







362



  }










363












364



  int32_t code = 0;




×







365



  (void)taosThreadMutexLock(&fs->tsdb->mutex);




×







366



  STFileSet* fset;










367



  TARRAY2_FOREACH(fs->fSetArr, fset) {




×







368



    STsdbFSetPartition* pItem = NULL;




×







369



    code = tsdbTFileSetToFSetPartition(fset, &pItem);




×







370



    if (code) {




×







371



      terrno = code;




×







372



      break;




×







373



    }










374



    code = TARRAY2_SORT_INSERT(pList, pItem, tsdbFSetPartCmprFn);




×







375



    if (code) {




×







376



      terrno = code;




×







377



      break;




×







378



    }










379



  }










380



  (void)taosThreadMutexUnlock(&fs->tsdb->mutex);




×







381












382



  if (code) {




×







383



    TARRAY2_DESTROY(pList, tsdbFSetPartitionClear);




×







384



    taosMemoryFree(pList);




×







385



    pList = NULL;




×







386



  }










387



  return pList;




×







388



}










389












390



ETsdbFsState tsdbSnapGetFsState(SVnode* pVnode) { return pVnode->pTsdb->pFS->fsstate; }




800✔





391












392



// description










393



typedef struct STsdbPartitionInfo {










394



  int32_t            vgId;










395



  int32_t            tsdbMaxCnt;










396



  int32_t            subTyps[TSDB_RETENTION_MAX];










397



  STsdbFSetPartList* pLists[TSDB_RETENTION_MAX];










398



} STsdbPartitionInfo;










399












400



static int32_t tsdbPartitionInfoInit(SVnode* pVnode, STsdbPartitionInfo* pInfo) {




×







401



  int32_t subTyps[TSDB_RETENTION_MAX] = {SNAP_DATA_TSDB, SNAP_DATA_RSMA1, SNAP_DATA_RSMA2};




×







402



  pInfo->vgId = TD_VID(pVnode);




×







403



  pInfo->tsdbMaxCnt = 1;




×







404












405



  if (!(sizeof(pInfo->subTyps) == sizeof(subTyps))) {










406



    return TSDB_CODE_INVALID_PARA;










407



  }










408



  memcpy(pInfo->subTyps, (char*)subTyps, sizeof(subTyps));




×







409












410



  // fset partition list










411



  memset(pInfo->pLists, 0, sizeof(pInfo->pLists[0]) * TSDB_RETENTION_MAX);




×







412



  for (int32_t j = 0; j < pInfo->tsdbMaxCnt; ++j) {




×







413



    STsdb* pTsdb = SMA_RSMA_GET_TSDB(pVnode, j);




×







414



    pInfo->pLists[j] = tsdbSnapGetFSetPartList(pTsdb->pFS);




×







415



    if (pInfo->pLists[j] == NULL) {




×







416



      return terrno;




×







417



    }










418



  }










419



  return 0;




×







420



}










421












422



static void tsdbPartitionInfoClear(STsdbPartitionInfo* pInfo) {




×







423



  for (int32_t j = 0; j < pInfo->tsdbMaxCnt; ++j) {




×







424



    if (pInfo->pLists[j] == NULL) continue;




×







425



    tsdbFSetPartListDestroy(&pInfo->pLists[j]);




×







426



  }










427



}




×







428












429



static int32_t tsdbPartitionInfoEstSize(STsdbPartitionInfo* pInfo) {




×







430



  int32_t dataLen = 0;




×







431



  for (int32_t j = 0; j < pInfo->tsdbMaxCnt; ++j) {




×







432



    dataLen += sizeof(SSyncTLV);  // subTyps[j]




×







433



    dataLen += tTsdbFSetPartListDataLenCalc(pInfo->pLists[j]);




×







434



  }










435



  return dataLen;




×







436



}










437












438



static int32_t tsdbPartitionInfoSerialize(STsdbPartitionInfo* pInfo, uint8_t* buf, int32_t bufLen) {




×







439



  int32_t tlen = 0;




×







440



  int32_t offset = 0;




×







441



  for (int32_t j = 0; j < pInfo->tsdbMaxCnt; ++j) {




×







442



    SSyncTLV* pSubHead = (void*)((char*)buf + offset);




×







443



    int32_t   valOffset = offset + sizeof(*pSubHead);




×







444



    int32_t   code = tSerializeTsdbFSetPartList(pSubHead->val, bufLen - valOffset, pInfo->pLists[j], &tlen);




×







445



    if (code) {




×







446



      tsdbError("vgId:%d, failed to serialize fset partition list of tsdb %d since %s", pInfo->vgId, j, terrstr());




×







447



      return code;




×







448



    }










449



    pSubHead->typ = pInfo->subTyps[j];




×







450



    pSubHead->len = tlen;




×







451



    offset += sizeof(*pSubHead) + tlen;




×







452



  }










453



  return offset;




×







454



}










455












456



// tsdb replication opts










457



static int32_t tTsdbRepOptsDataLenCalc(STsdbRepOpts* pInfo) {




×







458



  int32_t hdrLen = sizeof(int32_t);




×







459



  int32_t datLen = 0;




×







460












461



  int8_t  msgVer = 0;




×







462



  int64_t reserved64 = 0;




×







463



  int16_t format = 0;




×







464



  hdrLen += sizeof(msgVer);




×







465



  datLen += hdrLen;




×







466



  datLen += sizeof(format);




×







467



  datLen += sizeof(reserved64);




×







468



  datLen += sizeof(*pInfo);




×







469



  return datLen;




×







470



}










471












472



int32_t tSerializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) {




×







473



  int32_t  code = 0;




×







474



  SEncoder encoder = {0};




×







475



  int64_t  reserved64 = 0;




×







476



  int8_t   msgVer = TSDB_SNAP_MSG_VER;




×







477












478



  tEncoderInit(&encoder, buf, bufLen);




×







479












480



  if ((code = tStartEncode(&encoder))) goto _err;




×







481



  if ((code = tEncodeI8(&encoder, msgVer))) goto _err;




×







482



  int16_t format = pOpts->format;




×







483



  if ((code = tEncodeI16(&encoder, format))) goto _err;




×







484



  if ((code = tEncodeI64(&encoder, reserved64))) goto _err;




×







485












486



  tEndEncode(&encoder);




×







487



  int32_t tlen = encoder.pos;




×







488



  tEncoderClear(&encoder);




×







489



  return tlen;




×







490












491



_err:




×







492



  tEncoderClear(&encoder);




×







493



  return code;




×







494



}










495












496



int32_t tDeserializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) {




×







497



  int32_t  code;










498



  SDecoder decoder = {0};




×







499



  int64_t  reserved64 = 0;




×







500



  int8_t   msgVer = 0;




×







501












502



  tDecoderInit(&decoder, buf, bufLen);




×







503












504



  if ((code = tStartDecode(&decoder))) goto _err;




×







505



  if ((code = tDecodeI8(&decoder, &msgVer))) goto _err;




×







506



  if (msgVer != TSDB_SNAP_MSG_VER) goto _err;




×







507



  int16_t format = 0;




×







508



  if ((code = tDecodeI16(&decoder, &format))) goto _err;




×







509



  pOpts->format = format;




×







510



  if ((code = tDecodeI64(&decoder, &reserved64))) goto _err;




×







511












512



  tEndDecode(&decoder);




×







513



  tDecoderClear(&decoder);




×







514



  return 0;




×







515












516



_err:




×







517



  tDecoderClear(&decoder);




×







518



  return code;




×







519



}










520












521



static int32_t tsdbRepOptsEstSize(STsdbRepOpts* pOpts) {




×







522



  int32_t dataLen = 0;




×







523



  dataLen += sizeof(SSyncTLV);




×







524



  dataLen += tTsdbRepOptsDataLenCalc(pOpts);




×







525



  return dataLen;




×







526



}










527












528



static int32_t tsdbRepOptsSerialize(STsdbRepOpts* pOpts, void* buf, int32_t bufLen) {




×







529



  SSyncTLV* pSubHead = buf;




×







530



  int32_t   offset = 0;




×







531



  int32_t   tlen = 0;




×







532



  if ((tlen = tSerializeTsdbRepOpts(pSubHead->val, bufLen, pOpts)) < 0) {




×







533



    return tlen;




×







534



  }










535



  pSubHead->typ = SNAP_DATA_RAW;




×







536



  pSubHead->len = tlen;




×







537



  offset += sizeof(*pSubHead) + tlen;




×







538



  return offset;




×







539



}










540












541



// snap info










542



static int32_t tsdbSnapPrepDealWithSnapInfo(SVnode* pVnode, SSnapshot* pSnap, STsdbRepOpts* pInfo) {




×







543



  if (!pSnap->data) {




×







544



    return 0;




×







545



  }










546



  int32_t code = 0;




×







547












548



  SSyncTLV* pHead = (void*)pSnap->data;




×







549



  int32_t   offset = 0;




×







550












551



  while (offset + sizeof(*pHead) < pHead->len) {




×







552



    SSyncTLV* pField = (void*)(pHead->val + offset);




×







553



    offset += sizeof(*pField) + pField->len;




×







554



    void*   buf = pField->val;




×







555



    int32_t bufLen = pField->len;




×







556












557



    switch (pField->typ) {




×







558



      case SNAP_DATA_TSDB:




×







559



      case SNAP_DATA_RSMA1:










560



      case SNAP_DATA_RSMA2: {










561



      } break;




×







562



      case SNAP_DATA_RAW: {




×







563



        code = tDeserializeTsdbRepOpts(buf, bufLen, pInfo);




×







564



        if (code < 0) {




×







565



          tsdbError("vgId:%d, failed to deserialize tsdb rep opts since %s", TD_VID(pVnode), terrstr());




×







566



          return code;




×







567



        }










568



      } break;




×







569



      default:




×







570



        code = TSDB_CODE_INVALID_MSG;




×







571



        tsdbError("vgId:%d, unexpected subfield type of snap info. typ:%d", TD_VID(pVnode), pField->typ);




×







572



        return code;




×







573



    }










574



  }










575












576



  return code;




×







577



}










578












579



int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) {




×







580



  STsdbPartitionInfo  partitionInfo = {0};




×







581



  int                 code = 0;




×







582



  STsdbPartitionInfo* pInfo = &partitionInfo;




×







583












584



  code = tsdbPartitionInfoInit(pVnode, pInfo);




×







585



  if (code) {




×







586



    goto _out;




×







587



  }










588












589



  // deal with snap info for reply










590



  STsdbRepOpts opts = {.format = TSDB_SNAP_REP_FMT_RAW};




×







591



  if (pSnap->type == TDMT_SYNC_PREP_SNAPSHOT_REPLY) {




×







592



    STsdbRepOpts leaderOpts = {0};




×







593



    if ((code = tsdbSnapPrepDealWithSnapInfo(pVnode, pSnap, &leaderOpts)) < 0) {




×







594



      tsdbError("vgId:%d, failed to deal with snap info for reply since %s", TD_VID(pVnode), terrstr());




×







595



      goto _out;




×







596



    }










597



    opts.format = TMIN(opts.format, leaderOpts.format);




×







598



  }










599












600



  // info data realloc










601



  const int32_t headLen = sizeof(SSyncTLV);




×







602



  int32_t       bufLen = headLen;




×







603



  bufLen += tsdbPartitionInfoEstSize(pInfo);




×







604



  bufLen += tsdbRepOptsEstSize(&opts);




×







605



  if ((code = syncSnapInfoDataRealloc(pSnap, bufLen)) != 0) {




×







606



    tsdbError("vgId:%d, failed to realloc memory for data of snap info. bytes:%d", TD_VID(pVnode), bufLen);




×







607



    goto _out;




×







608



  }










609












610



  // serialization










611



  char*   buf = (void*)pSnap->data;




×







612



  int32_t offset = headLen;




×







613



  int32_t tlen = 0;




×







614












615



  if ((tlen = tsdbPartitionInfoSerialize(pInfo, (uint8_t*)(buf + offset), bufLen - offset)) < 0) {




×







616



    code = tlen;




×







617



    tsdbError("vgId:%d, failed to serialize tsdb partition info since %s", TD_VID(pVnode), terrstr());




×







618



    goto _out;




×







619



  }










620



  offset += tlen;




×







621












622



  if ((tlen = tsdbRepOptsSerialize(&opts, buf + offset, bufLen - offset)) < 0) {




×







623



    code = tlen;




×







624



    tsdbError("vgId:%d, failed to serialize tsdb rep opts since %s", TD_VID(pVnode), terrstr());




×







625



    goto _out;




×







626



  }










627



  offset += tlen;




×







628












629



  // set header of info data










630



  SSyncTLV* pHead = pSnap->data;




×







631



  pHead->typ = pSnap->type;




×







632



  pHead->len = offset - headLen;




×







633












634



  tsdbInfo("vgId:%d, tsdb snap info prepared. type:%s, val length:%d", TD_VID(pVnode), TMSG_INFO(pHead->typ),




×







635



           pHead->len);










636












637



_out:




×







638



  tsdbPartitionInfoClear(pInfo);




×







639



  return code;




×







640



}
























    

  • 

    •