#4747

Committed 21 Sep 2025 11:53PM UTC coverage: 58.002% (-1.1%) from 59.065%

Build # #4747

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

fix: refine python taos error log matching in checkAsan.sh (#33029)

* fix: refine python taos error log matching in checkAsan.sh

* fix: improve python taos error log matching in checkAsan.sh

Run Details

133398 of 293157 branches covered (45.5%)

Branch coverage included in aggregate %.

201778 of 284713 relevant lines covered (70.87%)

5539418.83 hits per line

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

58.45

/source/dnode/vnode/src/vnd/vnodeCommit.c

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

#include "meta.h"
#include "sync.h"
#include "vnd.h"
#include "vnodeInt.h"

extern int32_t tsdbPreCommit(STsdb *pTsdb);
extern int32_t tsdbCommitBegin(STsdb *pTsdb, SCommitInfo *pInfo);
extern int32_t tsdbCommitCommit(STsdb *pTsdb);
extern int32_t tsdbCommitAbort(STsdb *pTsdb);

#define VND_INFO_FNAME_TMP "vnode_tmp.json"

static int vnodeEncodeInfo(const SVnodeInfo *pInfo, char **ppData);
static int vnodeCommitImpl(SCommitInfo *pInfo);

#define WAIT_TIME_MILI_SEC 10  // miliseconds

static int32_t vnodeTryRecycleBufPool(SVnode *pVnode) {
  int32_t code = 0;

  if (pVnode->onRecycle == NULL) {
    if (pVnode->recycleHead == NULL) {
      vDebug("vgId:%d, no recyclable buffer pool", TD_VID(pVnode));
      goto _exit;
    } else {
      vDebug("vgId:%d, buffer pool %p of id %d on recycle queue, try to recycle", TD_VID(pVnode), pVnode->recycleHead,
             pVnode->recycleHead->id);

      pVnode->onRecycle = pVnode->recycleHead;
      if (pVnode->recycleHead == pVnode->recycleTail) {
        pVnode->recycleHead = pVnode->recycleTail = NULL;
      } else {
        pVnode->recycleHead = pVnode->recycleHead->recycleNext;
        pVnode->recycleHead->recyclePrev = NULL;
      }
      pVnode->onRecycle->recycleNext = pVnode->onRecycle->recyclePrev = NULL;
    }
  }

  code = vnodeBufPoolRecycle(pVnode->onRecycle);
  if (code) goto _exit;

_exit:
  if (code) {
    vError("vgId:%d, %s failed since %s", TD_VID(pVnode), __func__, tstrerror(code));
  }
  return code;
}
static int32_t vnodeGetBufPoolToUse(SVnode *pVnode) {
  int32_t code = 0;
  int32_t lino = 0;

  (void)taosThreadMutexLock(&pVnode->mutex);

  int32_t nTry = 0;
  for (;;) {
    ++nTry;

    if (pVnode->freeList) {
      vDebug("vgId:%d, allocate free buffer pool on %d try, pPool:%p id:%d", TD_VID(pVnode), nTry, pVnode->freeList,
             pVnode->freeList->id);

      pVnode->inUse = pVnode->freeList;
      pVnode->inUse->nRef = 1;
      pVnode->freeList = pVnode->inUse->freeNext;
      pVnode->inUse->freeNext = NULL;
      break;
    } else {
      vDebug("vgId:%d, no free buffer pool on %d try, try to recycle...", TD_VID(pVnode), nTry);

      code = vnodeTryRecycleBufPool(pVnode);
      TSDB_CHECK_CODE(code, lino, _exit);

      if (pVnode->freeList == NULL) {
        vDebug("vgId:%d, no free buffer pool on %d try, wait %d ms...", TD_VID(pVnode), nTry, WAIT_TIME_MILI_SEC);

        struct timeval  tv;
        struct timespec ts;
        if (taosGetTimeOfDay(&tv) != 0) {
          continue;
        }
        ts.tv_nsec = tv.tv_usec * 1000 + WAIT_TIME_MILI_SEC * 1000000;
        if (ts.tv_nsec > 999999999l) {
          ts.tv_sec = tv.tv_sec + 1;
          ts.tv_nsec -= 1000000000l;
        } else {
          ts.tv_sec = tv.tv_sec;
        }

        code = taosThreadCondTimedWait(&pVnode->poolNotEmpty, &pVnode->mutex, &ts);
        // ignore timeout error and retry
        if (code == TSDB_CODE_TIMEOUT_ERROR) {
          code = TSDB_CODE_SUCCESS;
        }
        TSDB_CHECK_CODE(code, lino, _exit);
      }
    }
  }

_exit:
  (void)taosThreadMutexUnlock(&pVnode->mutex);
  if (code) {
    vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));
  }
  return code;
}
int vnodeBegin(SVnode *pVnode) {
  int32_t code = 0;
  int32_t lino = 0;

  // alloc buffer pool
  code = vnodeGetBufPoolToUse(pVnode);
  TSDB_CHECK_CODE(code, lino, _exit);

  // begin meta
  code = metaBegin(pVnode->pMeta, META_BEGIN_HEAP_BUFFERPOOL);
  TSDB_CHECK_CODE(code, lino, _exit);

  // begin tsdb
  code = tsdbBegin(pVnode->pTsdb);
  TSDB_CHECK_CODE(code, lino, _exit);

  // begin sma
  if (VND_IS_RSMA(pVnode)) {
    code = smaBegin(pVnode->pSma);
    TSDB_CHECK_CODE(code, lino, _exit);
  }

_exit:
  if (code) {
    terrno = code;
    vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));
  }
  return code;
}

int vnodeShouldCommit(SVnode *pVnode, bool atExit) {
  bool diskAvail = osDataSpaceAvailable();
  bool needCommit = false;

  (void)taosThreadMutexLock(&pVnode->mutex);
  if (pVnode->inUse && diskAvail) {
    needCommit = (pVnode->inUse->size > pVnode->inUse->node.size) ||
                 (atExit && (pVnode->inUse->size > 0 || pVnode->pMeta->changed ||
                             pVnode->state.applied - pVnode->state.committed > 4096));
  }
  vTrace("vgId:%d, should commit:%d, disk available:%d, buffer size:%" PRId64 ", node size:%" PRId64
         ", meta changed:%d"
         ", state:[%" PRId64 ",%" PRId64 "]",
         TD_VID(pVnode), needCommit, diskAvail, pVnode->inUse ? pVnode->inUse->size : 0,
         pVnode->inUse ? pVnode->inUse->node.size : 0, pVnode->pMeta->changed, pVnode->state.applied,
         pVnode->state.committed);
  (void)taosThreadMutexUnlock(&pVnode->mutex);
  return needCommit;
}

int vnodeSaveInfo(const char *dir, const SVnodeInfo *pInfo) {
  int32_t   code = 0;
  int32_t   lino;
  char      fname[TSDB_FILENAME_LEN];
  TdFilePtr pFile = NULL;
  char     *data = NULL;

  snprintf(fname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME_TMP);

  code = vnodeEncodeInfo(pInfo, &data);
  TSDB_CHECK_CODE(code, lino, _exit);

  // save info to a vnode_tmp.json
  pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
  if (pFile == NULL) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

  if (taosWriteFile(pFile, data, strlen(data)) < 0) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

  if (taosFsyncFile(pFile) < 0) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

_exit:
  if (code) {
    vError("vgId:%d %s failed at %s:%d since %s", pInfo->config.vgId, __func__, __FILE__, lino, tstrerror(code));
  } else {
    vInfo("vgId:%d, vnode info is saved, fname:%s replica:%d selfIndex:%d changeVersion:%d", pInfo->config.vgId, fname,
          pInfo->config.syncCfg.replicaNum, pInfo->config.syncCfg.myIndex, pInfo->config.syncCfg.changeVersion);
  }
  if (taosCloseFile(&pFile) != 0) {
    vError("vgId:%d, failed to close file", pInfo->config.vgId);
  }
  taosMemoryFree(data);
  TAOS_RETURN(code);
}

int vnodeCommitInfo(const char *dir) {
  char fname[TSDB_FILENAME_LEN];
  char tfname[TSDB_FILENAME_LEN];

  snprintf(fname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME);
  snprintf(tfname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME_TMP);

  int32_t code = taosRenameFile(tfname, fname);
  if (code < 0) {
    return code;
  }

  vInfo("vnode info is committed, dir:%s", dir);
  return 0;
}

int vnodeLoadInfo(const char *dir, SVnodeInfo *pInfo) {
  int32_t   code = 0;
  int32_t   lino;
  char      fname[TSDB_FILENAME_LEN];
  TdFilePtr pFile = NULL;
  char     *pData = NULL;
  int64_t   size;

  snprintf(fname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME);

  // read info
  pFile = taosOpenFile(fname, TD_FILE_READ);
  if (pFile == NULL) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

  code = taosFStatFile(pFile, &size, NULL);
  TSDB_CHECK_CODE(code, lino, _exit);

  pData = taosMemoryMalloc(size + 1);
  if (pData == NULL) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

  if (taosReadFile(pFile, pData, size) < 0) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

  pData[size] = '\0';

  // decode info
  code = vnodeDecodeInfo(pData, pInfo);
  TSDB_CHECK_CODE(code, lino, _exit);

  pInfo->config.walCfg.committed = pInfo->state.committed;
_exit:
  if (code) {
    vError("vgId:%d %s failed at %s:%d since %s, file:%s", pInfo->config.vgId, __func__, __FILE__, lino,
           tstrerror(code), fname);
  }
  taosMemoryFree(pData);
  if (taosCloseFile(&pFile) != 0) {
    vError("vgId:%d, failed to close file", pInfo->config.vgId);
  }
  return code;
}

static int32_t vnodePrepareCommit(SVnode *pVnode, SCommitInfo *pInfo) {
  int32_t code = 0;
  int32_t lino = 0;
  char    dir[TSDB_FILENAME_LEN] = {0};
  int64_t lastCommitted = pInfo->info.state.committed;

  // wait last commit task
  vnodeAWait(&pVnode->commitTask);

  code = syncNodeGetConfig(pVnode->sync, &pVnode->config.syncCfg);
  TSDB_CHECK_CODE(code, lino, _exit);

  pVnode->state.commitTerm = pVnode->state.applyTerm;

  pInfo->info.config = pVnode->config;
  pInfo->info.state.committed = pVnode->state.applied;
  pInfo->info.state.commitTerm = pVnode->state.applyTerm;
  pInfo->info.state.commitID = ++pVnode->state.commitID;
  pInfo->pVnode = pVnode;
  pInfo->txn = metaGetTxn(pVnode->pMeta);

  // save info
  vnodeGetPrimaryPath(pVnode, false, dir, TSDB_FILENAME_LEN);

  vDebug("vgId:%d, save config while prepare commit", TD_VID(pVnode));
  code = vnodeSaveInfo(dir, &pInfo->info);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = tsdbPreCommit(pVnode->pTsdb);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = metaPrepareAsyncCommit(pVnode->pMeta);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = smaPrepareAsyncCommit(pVnode->pSma);
  TSDB_CHECK_CODE(code, lino, _exit);

  (void)taosThreadMutexLock(&pVnode->mutex);
  pVnode->onCommit = pVnode->inUse;
  pVnode->inUse = NULL;
  (void)taosThreadMutexUnlock(&pVnode->mutex);

_exit:
  if (code) {
    vError("vgId:%d, %s failed at line %d since %s, commit id:%" PRId64, TD_VID(pVnode), __func__, lino,
           tstrerror(code), pVnode->state.commitID);
  } else {
    vDebug("vgId:%d, %s done, commit id:%" PRId64, TD_VID(pVnode), __func__, pInfo->info.state.commitID);
  }

  return code;
}
static void vnodeReturnBufPool(SVnode *pVnode) {
  (void)taosThreadMutexLock(&pVnode->mutex);

  SVBufPool *pPool = pVnode->onCommit;
  int32_t    nRef = atomic_sub_fetch_32(&pPool->nRef, 1);

  pVnode->onCommit = NULL;
  if (nRef == 0) {
    vnodeBufPoolAddToFreeList(pPool);
  } else if (nRef > 0) {
    vDebug("vgId:%d, buffer pool %p of id %d is added to recycle queue", TD_VID(pVnode), pPool, pPool->id);

    if (pVnode->recycleTail == NULL) {
      pPool->recyclePrev = pPool->recycleNext = NULL;
      pVnode->recycleHead = pVnode->recycleTail = pPool;
    } else {
      pPool->recyclePrev = pVnode->recycleTail;
      pPool->recycleNext = NULL;
      pVnode->recycleTail->recycleNext = pPool;
      pVnode->recycleTail = pPool;
    }
  } else {
    vError("vgId:%d, buffer pool %p of id %d nRef:%d", TD_VID(pVnode), pPool, pPool->id, nRef);
  }

  (void)taosThreadMutexUnlock(&pVnode->mutex);
}
static int32_t vnodeCommit(void *arg) {
  int32_t code = 0;

  SCommitInfo *pInfo = (SCommitInfo *)arg;
  SVnode      *pVnode = pInfo->pVnode;

  // commit
  METRICS_TIMING_BLOCK(pVnode->writeMetrics.commit_time, METRIC_LEVEL_HIGH, {
    if ((code = vnodeCommitImpl(pInfo))) {
      vFatal("vgId:%d, failed to commit vnode since %s", TD_VID(pVnode), terrstr());
      taosMsleep(100);
      exit(EXIT_FAILURE);
      goto _exit;
    }
  });

  METRICS_UPDATE(pVnode->writeMetrics.commit_count, METRIC_LEVEL_HIGH, 1);

  vnodeReturnBufPool(pVnode);

_exit:
  taosMemoryFree(arg);
  return code;
}

static void vnodeCommitCancel(void *arg) { taosMemoryFree(arg); }

int vnodeAsyncCommit(SVnode *pVnode) {
  int32_t code = 0;
  int32_t lino = 0;

  SCommitInfo *pInfo = (SCommitInfo *)taosMemoryCalloc(1, sizeof(*pInfo));
  if (NULL == pInfo) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }
  code = vnodePrepareCommit(pVnode, pInfo);
  TSDB_CHECK_CODE(code, lino, _exit);

  // schedule the task
  code = vnodeAsync(COMMIT_TASK_ASYNC, EVA_PRIORITY_HIGH, vnodeCommit, vnodeCommitCancel, pInfo, &pVnode->commitTask);
  TSDB_CHECK_CODE(code, lino, _exit);

_exit:
  if (code) {
    taosMemoryFree(pInfo);
    vError("vgId:%d %s failed at line %d since %s" PRId64, TD_VID(pVnode), __func__, lino, tstrerror(code));
  } else {
    vInfo("vgId:%d, vnode async commit done, commitId:%" PRId64 " term:%" PRId64 " applied:%" PRId64, TD_VID(pVnode),
          pVnode->state.commitID, pVnode->state.applyTerm, pVnode->state.applied);
  }
  return code;
}

int32_t vnodeSyncCommit(SVnode *pVnode) {
  int32_t lino;
  int32_t code = vnodeAsyncCommit(pVnode);
  TSDB_CHECK_CODE(code, lino, _exit);
  vnodeAWait(&pVnode->commitTask);

_exit:
  if (code) {
    vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));
  } else {
    vInfo("vgId:%d, sync commit end", TD_VID(pVnode));
  }

  return code;
}

static int vnodeCommitImpl(SCommitInfo *pInfo) {
  int32_t code = 0;
  int32_t lino = 0;

  char    dir[TSDB_FILENAME_LEN] = {0};
  SVnode *pVnode = pInfo->pVnode;

  vInfo("vgId:%d, start to commit, commitId:%" PRId64 " version:%" PRId64 " term: %" PRId64, TD_VID(pVnode),
        pInfo->info.state.commitID, pInfo->info.state.committed, pInfo->info.state.commitTerm);

  // persist wal before starting
  if ((code = walPersist(pVnode->pWal)) < 0) {
    vError("vgId:%d, failed to persist wal since %s", TD_VID(pVnode), tstrerror(code));
    return code;
  }

  vnodeGetPrimaryPath(pVnode, false, dir, TSDB_FILENAME_LEN);

  code = syncBeginSnapshot(pVnode->sync, pInfo->info.state.committed);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = tsdbCommitBegin(pVnode->pTsdb, pInfo);
  TSDB_CHECK_CODE(code, lino, _exit);

  if (!TSDB_CACHE_NO(pVnode->config)) {
    METRICS_TIMING_BLOCK(pVnode->writeMetrics.last_cache_commit_time, METRIC_LEVEL_HIGH,
                         { code = tsdbCacheCommit(pVnode->pTsdb); });
    METRICS_UPDATE(pVnode->writeMetrics.last_cache_commit_count, METRIC_LEVEL_HIGH, 1);
    TSDB_CHECK_CODE(code, lino, _exit);
  }

  if (VND_IS_RSMA(pVnode)) {
    code = smaCommit(pVnode->pSma, pInfo);
    TSDB_CHECK_CODE(code, lino, _exit);
  }
  // blob storage engine commit
  code = bseCommit(pVnode->pBse);
  // commit info
  code = vnodeCommitInfo(dir);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = tsdbCommitCommit(pVnode->pTsdb);
  TSDB_CHECK_CODE(code, lino, _exit);

  if (VND_IS_RSMA(pVnode)) {
    code = smaFinishCommit(pVnode->pSma);
    TSDB_CHECK_CODE(code, lino, _exit);
  }

  code = metaFinishCommit(pVnode->pMeta, pInfo->txn);
  TSDB_CHECK_CODE(code, lino, _exit);

  pVnode->state.committed = pInfo->info.state.committed;

  if (smaPostCommit(pVnode->pSma) < 0) {
    vError("vgId:%d, failed to post-commit sma since %s", TD_VID(pVnode), tstrerror(terrno));
    return -1;
  }

  code = syncEndSnapshot(pVnode->sync);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = tqCommitOffset(pVnode->pTq);
  TSDB_CHECK_CODE(code, lino, _exit);
  
_exit:
  if (code) {
    vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));
  } else {
    vInfo("vgId:%d, commit end", TD_VID(pVnode));
  }
  return code;
}

bool vnodeShouldRollback(SVnode *pVnode) {
  char    tFName[TSDB_FILENAME_LEN] = {0};
  int32_t offset = 0;

  vnodeGetPrimaryPath(pVnode, false, tFName, TSDB_FILENAME_LEN);
  offset = strlen(tFName);
  snprintf(tFName + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VND_INFO_FNAME_TMP);

  return taosCheckExistFile(tFName);
}

void vnodeRollback(SVnode *pVnode) {
  char    tFName[TSDB_FILENAME_LEN] = {0};
  int32_t offset = 0;

  vnodeGetPrimaryPath(pVnode, false, tFName, TSDB_FILENAME_LEN);
  offset = strlen(tFName);
  snprintf(tFName + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VND_INFO_FNAME_TMP);

  if (taosRemoveFile(tFName) != 0) {
    vError("vgId:%d, failed to remove file %s since %s", TD_VID(pVnode), tFName, tstrerror(terrno));
  }
}

static int vnodeEncodeState(const void *pObj, SJson *pJson) {
  const SVState *pState = (SVState *)pObj;

  TAOS_CHECK_RETURN(tjsonAddIntegerToObject(pJson, "commit version", pState->committed));
  TAOS_CHECK_RETURN(tjsonAddIntegerToObject(pJson, "commit ID", pState->commitID));
  TAOS_CHECK_RETURN(tjsonAddIntegerToObject(pJson, "commit term", pState->commitTerm));

  return 0;
}

static int vnodeDecodeState(const SJson *pJson, void *pObj) {
  SVState *pState = (SVState *)pObj;

  int32_t code;
  tjsonGetNumberValue(pJson, "commit version", pState->committed, code);
  if (code) return code;
  tjsonGetNumberValue(pJson, "commit ID", pState->commitID, code);
  if (code) return code;
  tjsonGetNumberValue(pJson, "commit term", pState->commitTerm, code);
  if (code) return code;

  return 0;
}

static int vnodeEncodeInfo(const SVnodeInfo *pInfo, char **ppData) {
  int32_t code = 0;
  int32_t lino;
  SJson  *pJson = NULL;
  char   *pData = NULL;

  pJson = tjsonCreateObject();
  if (pJson == NULL) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

  code = tjsonAddObject(pJson, "config", vnodeEncodeConfig, (void *)&pInfo->config);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = tjsonAddObject(pJson, "state", vnodeEncodeState, (void *)&pInfo->state);
  TSDB_CHECK_CODE(code, lino, _exit);

  pData = tjsonToString(pJson);
  if (pData == NULL) {
    TSDB_CHECK_CODE(code = terrno, lino, _exit);
  }

  tjsonDelete(pJson);

_exit:
  if (code) {
    tjsonDelete(pJson);
    *ppData = NULL;
  } else {
    *ppData = pData;
  }
  return code;
}

int vnodeDecodeInfo(uint8_t *pData, SVnodeInfo *pInfo) {
  int32_t code = 0;
  int32_t lino;
  SJson  *pJson = NULL;

  pJson = tjsonParse(pData);
  if (pJson == NULL) {
    TSDB_CHECK_CODE(code = TSDB_CODE_INVALID_DATA_FMT, lino, _exit);
  }

  code = tjsonToObject(pJson, "config", vnodeDecodeConfig, (void *)&pInfo->config);
  TSDB_CHECK_CODE(code, lino, _exit);

  code = tjsonToObject(pJson, "state", vnodeDecodeState, (void *)&pInfo->state);
  TSDB_CHECK_CODE(code, lino, _exit);

_exit:
  tjsonDelete(pJson);
  return code;
}

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 "meta.h"
17	#include "sync.h"
18	#include "vnd.h"
19	#include "vnodeInt.h"
20
21	extern int32_t tsdbPreCommit(STsdb *pTsdb);
22	extern int32_t tsdbCommitBegin(STsdb pTsdb, SCommitInfo pInfo);
23	extern int32_t tsdbCommitCommit(STsdb *pTsdb);
24	extern int32_t tsdbCommitAbort(STsdb *pTsdb);
25
26	#define VND_INFO_FNAME_TMP "vnode_tmp.json"
27
28	static int vnodeEncodeInfo(const SVnodeInfo pInfo, char *ppData);
29	static int vnodeCommitImpl(SCommitInfo *pInfo);
30
31	#define WAIT_TIME_MILI_SEC 10 // miliseconds
32
33	static int32_t vnodeTryRecycleBufPool(SVnode *pVnode) {	×
34	int32_t code = 0;	×
35
36	if (pVnode->onRecycle == NULL) {	×
37	if (pVnode->recycleHead == NULL) {	×
38	vDebug("vgId:%d, no recyclable buffer pool", TD_VID(pVnode));	×
39	goto _exit;	×
40	} else {
41	vDebug("vgId:%d, buffer pool %p of id %d on recycle queue, try to recycle", TD_VID(pVnode), pVnode->recycleHead,	×
42	pVnode->recycleHead->id);
43
44	pVnode->onRecycle = pVnode->recycleHead;	×
45	if (pVnode->recycleHead == pVnode->recycleTail) {	×
46	pVnode->recycleHead = pVnode->recycleTail = NULL;	×
47	} else {
48	pVnode->recycleHead = pVnode->recycleHead->recycleNext;	×
49	pVnode->recycleHead->recyclePrev = NULL;	×
50	}
51	pVnode->onRecycle->recycleNext = pVnode->onRecycle->recyclePrev = NULL;	×
52	}
53	}
54
55	code = vnodeBufPoolRecycle(pVnode->onRecycle);	×
56	if (code) goto _exit;	×
57
58	_exit:	×
59	if (code) {	×
60	vError("vgId:%d, %s failed since %s", TD_VID(pVnode), __func__, tstrerror(code));	×
61	}
62	return code;	×
63	}
64	static int32_t vnodeGetBufPoolToUse(SVnode *pVnode) {	34,716✔
65	int32_t code = 0;	34,716✔
66	int32_t lino = 0;	34,716✔
67
68	(void)taosThreadMutexLock(&pVnode->mutex);	34,716✔
69
70	int32_t nTry = 0;	34,716✔
71	for (;;) {
72	++nTry;	34,716✔
73
74	if (pVnode->freeList) {	34,716!
75	vDebug("vgId:%d, allocate free buffer pool on %d try, pPool:%p id:%d", TD_VID(pVnode), nTry, pVnode->freeList,	34,716✔
76	pVnode->freeList->id);
77
78	pVnode->inUse = pVnode->freeList;	34,716✔
79	pVnode->inUse->nRef = 1;	34,716✔
80	pVnode->freeList = pVnode->inUse->freeNext;	34,716✔
81	pVnode->inUse->freeNext = NULL;	34,716✔
82	break;	34,716✔
83	} else {
84	vDebug("vgId:%d, no free buffer pool on %d try, try to recycle...", TD_VID(pVnode), nTry);	×
85
86	code = vnodeTryRecycleBufPool(pVnode);	×
87	TSDB_CHECK_CODE(code, lino, _exit);	×
88
89	if (pVnode->freeList == NULL) {	×
90	vDebug("vgId:%d, no free buffer pool on %d try, wait %d ms...", TD_VID(pVnode), nTry, WAIT_TIME_MILI_SEC);	×
91
92	struct timeval tv;
93	struct timespec ts;
94	if (taosGetTimeOfDay(&tv) != 0) {	×
95	continue;	×
96	}
97	ts.tv_nsec = tv.tv_usec * 1000 + WAIT_TIME_MILI_SEC * 1000000;	×
98	if (ts.tv_nsec > 999999999l) {	×
99	ts.tv_sec = tv.tv_sec + 1;	×
100	ts.tv_nsec -= 1000000000l;	×
101	} else {
102	ts.tv_sec = tv.tv_sec;	×
103	}
104
105	code = taosThreadCondTimedWait(&pVnode->poolNotEmpty, &pVnode->mutex, &ts);	×
106	// ignore timeout error and retry
107	if (code == TSDB_CODE_TIMEOUT_ERROR) {	×
108	code = TSDB_CODE_SUCCESS;	×
109	}
110	TSDB_CHECK_CODE(code, lino, _exit);	×
111	}
112	}
113	}
114
115	_exit:	34,716✔
116	(void)taosThreadMutexUnlock(&pVnode->mutex);	34,716✔
117	if (code) {	34,716!
118	vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));	×
119	}
120	return code;	34,716✔
121	}
122	int vnodeBegin(SVnode *pVnode) {	34,716✔
123	int32_t code = 0;	34,716✔
124	int32_t lino = 0;	34,716✔
125
126	// alloc buffer pool
127	code = vnodeGetBufPoolToUse(pVnode);	34,716✔
128	TSDB_CHECK_CODE(code, lino, _exit);	34,716!
129
130	// begin meta
131	code = metaBegin(pVnode->pMeta, META_BEGIN_HEAP_BUFFERPOOL);	34,716✔
132	TSDB_CHECK_CODE(code, lino, _exit);	34,713!
133
134	// begin tsdb
135	code = tsdbBegin(pVnode->pTsdb);	34,713✔
136	TSDB_CHECK_CODE(code, lino, _exit);	34,713!
137
138	// begin sma
139	if (VND_IS_RSMA(pVnode)) {	34,713!
140	code = smaBegin(pVnode->pSma);	×
141	TSDB_CHECK_CODE(code, lino, _exit);	×
142	}
143
144	_exit:	34,713✔
145	if (code) {	34,713!
146	terrno = code;	×
147	vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));	×
148	}
149	return code;	34,715✔
150	}
151
152	int vnodeShouldCommit(SVnode *pVnode, bool atExit) {	1,873,185✔
153	bool diskAvail = osDataSpaceAvailable();	1,873,185✔
154	bool needCommit = false;	1,873,186✔
155
156	(void)taosThreadMutexLock(&pVnode->mutex);	1,873,186✔
157	if (pVnode->inUse && diskAvail) {	1,873,204!
158	needCommit = (pVnode->inUse->size > pVnode->inUse->node.size) \|\|	1,883,316✔
159	(atExit && (pVnode->inUse->size > 0 \|\| pVnode->pMeta->changed \|\|	10,115✔
160	pVnode->state.applied - pVnode->state.committed > 4096));	3,577✔
161	}
162	vTrace("vgId:%d, should commit:%d, disk available:%d, buffer size:%" PRId64 ", node size:%" PRId64	1,873,204!
163	", meta changed:%d"
164	", state:[%" PRId64 ",%" PRId64 "]",
165	TD_VID(pVnode), needCommit, diskAvail, pVnode->inUse ? pVnode->inUse->size : 0,
166	pVnode->inUse ? pVnode->inUse->node.size : 0, pVnode->pMeta->changed, pVnode->state.applied,
167	pVnode->state.committed);
168	(void)taosThreadMutexUnlock(&pVnode->mutex);	1,873,204✔
169	return needCommit;	1,873,208✔
170	}
171
172	int vnodeSaveInfo(const char dir, const SVnodeInfo pInfo) {	33,582✔
173	int32_t code = 0;	33,582✔
174	int32_t lino;
175	char fname[TSDB_FILENAME_LEN];
176	TdFilePtr pFile = NULL;	33,582✔
177	char *data = NULL;	33,582✔
178
179	snprintf(fname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME_TMP);	33,582✔
180
181	code = vnodeEncodeInfo(pInfo, &data);	33,582✔
182	TSDB_CHECK_CODE(code, lino, _exit);	33,575!
183
184	// save info to a vnode_tmp.json
185	pFile = taosOpenFile(fname, TD_FILE_CREATE \| TD_FILE_WRITE \| TD_FILE_TRUNC \| TD_FILE_WRITE_THROUGH);	33,575✔
186	if (pFile == NULL) {	33,526!
187	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
188	}
189
190	if (taosWriteFile(pFile, data, strlen(data)) < 0) {	33,526!
191	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
192	}
193
194	if (taosFsyncFile(pFile) < 0) {	33,526!
195	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
196	}
197
198	_exit:	33,576✔
199	if (code) {	33,576!
200	vError("vgId:%d %s failed at %s:%d since %s", pInfo->config.vgId, __func__, __FILE__, lino, tstrerror(code));	×
201	} else {
202	vInfo("vgId:%d, vnode info is saved, fname:%s replica:%d selfIndex:%d changeVersion:%d", pInfo->config.vgId, fname,	33,576✔
203	pInfo->config.syncCfg.replicaNum, pInfo->config.syncCfg.myIndex, pInfo->config.syncCfg.changeVersion);
204	}
205	if (taosCloseFile(&pFile) != 0) {	33,580!
206	vError("vgId:%d, failed to close file", pInfo->config.vgId);	×
207	}
208	taosMemoryFree(data);	33,582!
209	TAOS_RETURN(code);	33,582✔
210	}
211
212	int vnodeCommitInfo(const char *dir) {	33,582✔
213	char fname[TSDB_FILENAME_LEN];
214	char tfname[TSDB_FILENAME_LEN];
215
216	snprintf(fname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME);	33,582✔
217	snprintf(tfname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME_TMP);	33,582✔
218
219	int32_t code = taosRenameFile(tfname, fname);	33,582✔
220	if (code < 0) {	33,581!
221	return code;	×
222	}
223
224	vInfo("vnode info is committed, dir:%s", dir);	33,581✔
225	return 0;	33,582✔
226	}
227
228	int vnodeLoadInfo(const char dir, SVnodeInfo pInfo) {	23,454✔
229	int32_t code = 0;	23,454✔
230	int32_t lino;
231	char fname[TSDB_FILENAME_LEN];
232	TdFilePtr pFile = NULL;	23,454✔
233	char *pData = NULL;	23,454✔
234	int64_t size;
235
236	snprintf(fname, TSDB_FILENAME_LEN, "%s%s%s", dir, TD_DIRSEP, VND_INFO_FNAME);	23,454✔
237
238	// read info
239	pFile = taosOpenFile(fname, TD_FILE_READ);	23,454✔
240	if (pFile == NULL) {	23,452✔
241	TSDB_CHECK_CODE(code = terrno, lino, _exit);	9,660!
242	}
243
244	code = taosFStatFile(pFile, &size, NULL);	13,792✔
245	TSDB_CHECK_CODE(code, lino, _exit);	13,793!
246
247	pData = taosMemoryMalloc(size + 1);	13,793!
248	if (pData == NULL) {	13,793!
249	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
250	}
251
252	if (taosReadFile(pFile, pData, size) < 0) {	13,793!
253	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
254	}
255
256	pData[size] = '\0';	13,791✔
257
258	// decode info
259	code = vnodeDecodeInfo(pData, pInfo);	13,791✔
260	TSDB_CHECK_CODE(code, lino, _exit);	13,793!
261
262	pInfo->config.walCfg.committed = pInfo->state.committed;	13,793✔
263	_exit:	23,453✔
264	if (code) {	23,453✔
265	vError("vgId:%d %s failed at %s:%d since %s, file:%s", pInfo->config.vgId, __func__, __FILE__, lino,	9,660✔
266	tstrerror(code), fname);
267	}
268	taosMemoryFree(pData);	23,454!
269	if (taosCloseFile(&pFile) != 0) {	23,452!
270	vError("vgId:%d, failed to close file", pInfo->config.vgId);	×
271	}
272	return code;	23,454✔
273	}
274
275	static int32_t vnodePrepareCommit(SVnode pVnode, SCommitInfo pInfo) {	22,379✔
276	int32_t code = 0;	22,379✔
277	int32_t lino = 0;	22,379✔
278	char dir[TSDB_FILENAME_LEN] = {0};	22,379✔
279	int64_t lastCommitted = pInfo->info.state.committed;	22,379✔
280
281	// wait last commit task
282	vnodeAWait(&pVnode->commitTask);	22,379✔
283
284	code = syncNodeGetConfig(pVnode->sync, &pVnode->config.syncCfg);	22,380✔
285	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
286
287	pVnode->state.commitTerm = pVnode->state.applyTerm;	22,381✔
288
289	pInfo->info.config = pVnode->config;	22,381✔
290	pInfo->info.state.committed = pVnode->state.applied;	22,381✔
291	pInfo->info.state.commitTerm = pVnode->state.applyTerm;	22,381✔
292	pInfo->info.state.commitID = ++pVnode->state.commitID;	22,381✔
293	pInfo->pVnode = pVnode;	22,381✔
294	pInfo->txn = metaGetTxn(pVnode->pMeta);	22,381✔
295
296	// save info
297	vnodeGetPrimaryPath(pVnode, false, dir, TSDB_FILENAME_LEN);	22,379✔
298
299	vDebug("vgId:%d, save config while prepare commit", TD_VID(pVnode));	22,378✔
300	code = vnodeSaveInfo(dir, &pInfo->info);	22,381✔
301	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
302
303	code = tsdbPreCommit(pVnode->pTsdb);	22,381✔
304	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
305
306	code = metaPrepareAsyncCommit(pVnode->pMeta);	22,381✔
307	TSDB_CHECK_CODE(code, lino, _exit);	22,377!
308
309	code = smaPrepareAsyncCommit(pVnode->pSma);	22,377✔
310	TSDB_CHECK_CODE(code, lino, _exit);	22,380!
311
312	(void)taosThreadMutexLock(&pVnode->mutex);	22,380✔
313	pVnode->onCommit = pVnode->inUse;	22,379✔
314	pVnode->inUse = NULL;	22,379✔
315	(void)taosThreadMutexUnlock(&pVnode->mutex);	22,379✔
316
317	_exit:	22,378✔
318	if (code) {	22,378!
319	vError("vgId:%d, %s failed at line %d since %s, commit id:%" PRId64, TD_VID(pVnode), __func__, lino,	×
320	tstrerror(code), pVnode->state.commitID);
321	} else {
322	vDebug("vgId:%d, %s done, commit id:%" PRId64, TD_VID(pVnode), __func__, pInfo->info.state.commitID);	22,378✔
323	}
324
325	return code;	22,380✔
326	}
327	static void vnodeReturnBufPool(SVnode *pVnode) {	22,381✔
328	(void)taosThreadMutexLock(&pVnode->mutex);	22,381✔
329
330	SVBufPool *pPool = pVnode->onCommit;	22,381✔
331	int32_t nRef = atomic_sub_fetch_32(&pPool->nRef, 1);	22,381✔
332
333	pVnode->onCommit = NULL;	22,381✔
334	if (nRef == 0) {	22,381✔
335	vnodeBufPoolAddToFreeList(pPool);	22,266✔
336	} else if (nRef > 0) {	115!
337	vDebug("vgId:%d, buffer pool %p of id %d is added to recycle queue", TD_VID(pVnode), pPool, pPool->id);	115!
338
339	if (pVnode->recycleTail == NULL) {	115!
340	pPool->recyclePrev = pPool->recycleNext = NULL;	115✔
341	pVnode->recycleHead = pVnode->recycleTail = pPool;	115✔
342	} else {
343	pPool->recyclePrev = pVnode->recycleTail;	×
344	pPool->recycleNext = NULL;	×
345	pVnode->recycleTail->recycleNext = pPool;	×
346	pVnode->recycleTail = pPool;	×
347	}
348	} else {
349	vError("vgId:%d, buffer pool %p of id %d nRef:%d", TD_VID(pVnode), pPool, pPool->id, nRef);	×
350	}
351
352	(void)taosThreadMutexUnlock(&pVnode->mutex);	22,381✔
353	}	22,380✔
354	static int32_t vnodeCommit(void *arg) {	22,381✔
355	int32_t code = 0;	22,381✔
356
357	SCommitInfo pInfo = (SCommitInfo )arg;	22,381✔
358	SVnode *pVnode = pInfo->pVnode;	22,381✔
359
360	// commit
361	METRICS_TIMING_BLOCK(pVnode->writeMetrics.commit_time, METRIC_LEVEL_HIGH, {	22,381!
362	if ((code = vnodeCommitImpl(pInfo))) {
363	vFatal("vgId:%d, failed to commit vnode since %s", TD_VID(pVnode), terrstr());
364	taosMsleep(100);
365	exit(EXIT_FAILURE);
366	goto _exit;
367	}
368	});
369
370	METRICS_UPDATE(pVnode->writeMetrics.commit_count, METRIC_LEVEL_HIGH, 1);	22,381!
371
372	vnodeReturnBufPool(pVnode);	22,381✔
373
374	_exit:	22,381✔
375	taosMemoryFree(arg);	22,381!
376	return code;	22,381✔
377	}
378
379	static void vnodeCommitCancel(void *arg) { taosMemoryFree(arg); }	×
380
381	int vnodeAsyncCommit(SVnode *pVnode) {	22,381✔
382	int32_t code = 0;	22,381✔
383	int32_t lino = 0;	22,381✔
384
385	SCommitInfo pInfo = (SCommitInfo )taosMemoryCalloc(1, sizeof(*pInfo));	22,381!
386	if (NULL == pInfo) {	22,377!
387	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
388	}
389	code = vnodePrepareCommit(pVnode, pInfo);	22,377✔
390	TSDB_CHECK_CODE(code, lino, _exit);	22,380!
391
392	// schedule the task
393	code = vnodeAsync(COMMIT_TASK_ASYNC, EVA_PRIORITY_HIGH, vnodeCommit, vnodeCommitCancel, pInfo, &pVnode->commitTask);	22,380✔
394	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
395
396	_exit:	22,381✔
397	if (code) {	22,381!
398	taosMemoryFree(pInfo);	×
399	vError("vgId:%d %s failed at line %d since %s" PRId64, TD_VID(pVnode), __func__, lino, tstrerror(code));	×
400	} else {
401	vInfo("vgId:%d, vnode async commit done, commitId:%" PRId64 " term:%" PRId64 " applied:%" PRId64, TD_VID(pVnode),	22,381✔
402	pVnode->state.commitID, pVnode->state.applyTerm, pVnode->state.applied);
403	}
404	return code;	22,381✔
405	}
406
407	int32_t vnodeSyncCommit(SVnode *pVnode) {	160✔
408	int32_t lino;
409	int32_t code = vnodeAsyncCommit(pVnode);	160✔
410	TSDB_CHECK_CODE(code, lino, _exit);	160!
411	vnodeAWait(&pVnode->commitTask);	160✔
412
413	_exit:	160✔
414	if (code) {	160!
415	vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));	×
416	} else {
417	vInfo("vgId:%d, sync commit end", TD_VID(pVnode));	160!
418	}
419
420	return code;	160✔
421	}
422
423	static int vnodeCommitImpl(SCommitInfo *pInfo) {	22,380✔
424	int32_t code = 0;	22,380✔
425	int32_t lino = 0;	22,380✔
426
427	char dir[TSDB_FILENAME_LEN] = {0};	22,380✔
428	SVnode *pVnode = pInfo->pVnode;	22,380✔
429
430	vInfo("vgId:%d, start to commit, commitId:%" PRId64 " version:%" PRId64 " term: %" PRId64, TD_VID(pVnode),	22,380✔
431	pInfo->info.state.commitID, pInfo->info.state.committed, pInfo->info.state.commitTerm);
432
433	// persist wal before starting
434	if ((code = walPersist(pVnode->pWal)) < 0) {	22,384!
435	vError("vgId:%d, failed to persist wal since %s", TD_VID(pVnode), tstrerror(code));	×
436	return code;	×
437	}
438
439	vnodeGetPrimaryPath(pVnode, false, dir, TSDB_FILENAME_LEN);	22,381✔
440
441	code = syncBeginSnapshot(pVnode->sync, pInfo->info.state.committed);	22,381✔
442	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
443
444	code = tsdbCommitBegin(pVnode->pTsdb, pInfo);	22,381✔
445	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
446
447	if (!TSDB_CACHE_NO(pVnode->config)) {	22,381✔
448	METRICS_TIMING_BLOCK(pVnode->writeMetrics.last_cache_commit_time, METRIC_LEVEL_HIGH,	176!
449	{ code = tsdbCacheCommit(pVnode->pTsdb); });
450	METRICS_UPDATE(pVnode->writeMetrics.last_cache_commit_count, METRIC_LEVEL_HIGH, 1);	176!
451	TSDB_CHECK_CODE(code, lino, _exit);	176!
452	}
453
454	if (VND_IS_RSMA(pVnode)) {	22,381!
455	code = smaCommit(pVnode->pSma, pInfo);	×
456	TSDB_CHECK_CODE(code, lino, _exit);	×
457	}
458	// blob storage engine commit
459	code = bseCommit(pVnode->pBse);	22,381✔
460	// commit info
461	code = vnodeCommitInfo(dir);	22,381✔
462	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
463
464	code = tsdbCommitCommit(pVnode->pTsdb);	22,381✔
465	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
466
467	if (VND_IS_RSMA(pVnode)) {	22,381!
468	code = smaFinishCommit(pVnode->pSma);	×
469	TSDB_CHECK_CODE(code, lino, _exit);	×
470	}
471
472	code = metaFinishCommit(pVnode->pMeta, pInfo->txn);	22,381✔
473	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
474
475	pVnode->state.committed = pInfo->info.state.committed;	22,381✔
476
477	if (smaPostCommit(pVnode->pSma) < 0) {	22,381!
478	vError("vgId:%d, failed to post-commit sma since %s", TD_VID(pVnode), tstrerror(terrno));	×
479	return -1;	×
480	}
481
482	code = syncEndSnapshot(pVnode->sync);	22,381✔
483	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
484
485	code = tqCommitOffset(pVnode->pTq);	22,381✔
486	TSDB_CHECK_CODE(code, lino, _exit);	22,381!
487
488	_exit:	22,381✔
489	if (code) {	22,381!
490	vError("vgId:%d, %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));	×
491	} else {
492	vInfo("vgId:%d, commit end", TD_VID(pVnode));	22,381✔
493	}
494	return code;	22,381✔
495	}
496
497	bool vnodeShouldRollback(SVnode *pVnode) {	12,339✔
498	char tFName[TSDB_FILENAME_LEN] = {0};	12,339✔
499	int32_t offset = 0;	12,339✔
500
501	vnodeGetPrimaryPath(pVnode, false, tFName, TSDB_FILENAME_LEN);	12,339✔
502	offset = strlen(tFName);	12,339✔
503	snprintf(tFName + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VND_INFO_FNAME_TMP);	12,339✔
504
505	return taosCheckExistFile(tFName);	12,339✔
506	}
507
508	void vnodeRollback(SVnode *pVnode) {	×
509	char tFName[TSDB_FILENAME_LEN] = {0};	×
510	int32_t offset = 0;	×
511
512	vnodeGetPrimaryPath(pVnode, false, tFName, TSDB_FILENAME_LEN);	×
513	offset = strlen(tFName);	×
514	snprintf(tFName + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VND_INFO_FNAME_TMP);	×
515
516	if (taosRemoveFile(tFName) != 0) {	×
517	vError("vgId:%d, failed to remove file %s since %s", TD_VID(pVnode), tFName, tstrerror(terrno));	×
518	}
519	}	×
520
521	static int vnodeEncodeState(const void pObj, SJson pJson) {	33,582✔
522	const SVState pState = (SVState )pObj;	33,582✔
523
524	TAOS_CHECK_RETURN(tjsonAddIntegerToObject(pJson, "commit version", pState->committed));	33,582!
525	TAOS_CHECK_RETURN(tjsonAddIntegerToObject(pJson, "commit ID", pState->commitID));	33,582!
526	TAOS_CHECK_RETURN(tjsonAddIntegerToObject(pJson, "commit term", pState->commitTerm));	33,582✔
527
528	return 0;	33,580✔
529	}
530
531	static int vnodeDecodeState(const SJson pJson, void pObj) {	13,888✔
532	SVState pState = (SVState )pObj;	13,888✔
533
534	int32_t code;
535	tjsonGetNumberValue(pJson, "commit version", pState->committed, code);	13,888✔
536	if (code) return code;	13,888!
537	tjsonGetNumberValue(pJson, "commit ID", pState->commitID, code);	13,888✔
538	if (code) return code;	13,887!
539	tjsonGetNumberValue(pJson, "commit term", pState->commitTerm, code);	13,887✔
540	if (code) return code;	13,888!
541
542	return 0;	13,888✔
543	}
544
545	static int vnodeEncodeInfo(const SVnodeInfo pInfo, char *ppData) {	33,582✔
546	int32_t code = 0;	33,582✔
547	int32_t lino;
548	SJson *pJson = NULL;	33,582✔
549	char *pData = NULL;	33,582✔
550
551	pJson = tjsonCreateObject();	33,582✔
552	if (pJson == NULL) {	33,581!
553	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
554	}
555
556	code = tjsonAddObject(pJson, "config", vnodeEncodeConfig, (void *)&pInfo->config);	33,581✔
557	TSDB_CHECK_CODE(code, lino, _exit);	33,582!
558
559	code = tjsonAddObject(pJson, "state", vnodeEncodeState, (void *)&pInfo->state);	33,582✔
560	TSDB_CHECK_CODE(code, lino, _exit);	33,581!
561
562	pData = tjsonToString(pJson);	33,581✔
563	if (pData == NULL) {	33,575!
564	TSDB_CHECK_CODE(code = terrno, lino, _exit);	×
565	}
566
567	tjsonDelete(pJson);	33,575✔
568
569	_exit:	33,577✔
570	if (code) {	33,577!
571	tjsonDelete(pJson);	×
572	*ppData = NULL;	×
573	} else {
574	*ppData = pData;	33,577✔
575	}
576	return code;	33,577✔
577	}
578
579	int vnodeDecodeInfo(uint8_t pData, SVnodeInfo pInfo) {	13,885✔
580	int32_t code = 0;	13,885✔
581	int32_t lino;
582	SJson *pJson = NULL;	13,885✔
583
584	pJson = tjsonParse(pData);	13,885✔
585	if (pJson == NULL) {	13,881!
586	TSDB_CHECK_CODE(code = TSDB_CODE_INVALID_DATA_FMT, lino, _exit);	×
587	}
588
589	code = tjsonToObject(pJson, "config", vnodeDecodeConfig, (void *)&pInfo->config);	13,881✔
590	TSDB_CHECK_CODE(code, lino, _exit);	13,888!
591
592	code = tjsonToObject(pJson, "state", vnodeDecodeState, (void *)&pInfo->state);	13,888✔
593	TSDB_CHECK_CODE(code, lino, _exit);	13,888!
594
595	_exit:	13,888✔
596	tjsonDelete(pJson);	13,888✔
597	return code;	13,888✔
598	}

taosdata / TDengine / #4747

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