#3842

Committed 07 Apr 2025 11:21AM UTC coverage: 62.696% (-0.3%) from 63.027%

Build # #3842

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

merge: from main to 3.0 branch (#30679)

Run Details

154855 of 315075 branches covered (49.15%)

Branch coverage included in aggregate %.

6 of 8 new or added lines in 5 files covered. (75.0%)

2309 existing lines in 130 files now uncovered.

240176 of 314995 relevant lines covered (76.25%)

19119980.29 hits per line

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

62.01

/source/libs/sync/src/syncRaftLog.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/>.
 */

#define _DEFAULT_SOURCE
#include "syncRaftLog.h"
#include "syncRaftCfg.h"
#include "syncRaftStore.h"
#include "syncUtil.h"

// log[m .. n]

// public function
static int32_t   raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncIndex snapshotIndex);
static int32_t   raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry, bool forceSync);
static int32_t   raftLogTruncate(struct SSyncLogStore* pLogStore, SyncIndex fromIndex);
static bool      raftLogExist(struct SSyncLogStore* pLogStore, SyncIndex index);
static int32_t   raftLogUpdateCommitIndex(SSyncLogStore* pLogStore, SyncIndex index);
static SyncIndex raftlogCommitIndex(SSyncLogStore* pLogStore);
static int32_t   raftLogGetLastEntry(SSyncLogStore* pLogStore, SSyncRaftEntry** ppLastEntry);

SSyncLogStore* logStoreCreate(SSyncNode* pSyncNode) {
  SSyncLogStore* pLogStore = taosMemoryCalloc(1, sizeof(SSyncLogStore));
  if (pLogStore == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  // pLogStore->pCache = taosLRUCacheInit(10 * 1024 * 1024, 1, .5);
  pLogStore->pCache = taosLRUCacheInit(30 * 1024 * 1024, 1, .5);
  if (pLogStore->pCache == NULL) {
    taosMemoryFree(pLogStore);
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  pLogStore->cacheHit = 0;
  pLogStore->cacheMiss = 0;

  taosLRUCacheSetStrictCapacity(pLogStore->pCache, false);

  pLogStore->data = taosMemoryMalloc(sizeof(SSyncLogStoreData));
  if (!pLogStore->data) {
    taosMemoryFree(pLogStore);
    taosLRUCacheCleanup(pLogStore->pCache);
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  SSyncLogStoreData* pData = pLogStore->data;
  pData->pSyncNode = pSyncNode;
  pData->pWal = pSyncNode->pWal;
  if (pData->pWal == NULL) {
    terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
    return NULL;
  }

  (void)taosThreadMutexInit(&(pData->mutex), NULL);
  pData->pWalHandle = walOpenReader(pData->pWal, NULL, 0);
  if (!pData->pWalHandle) {
    taosMemoryFree(pLogStore);
    taosLRUCacheCleanup(pLogStore->pCache);
    (void)taosThreadMutexDestroy(&(pData->mutex));
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  pLogStore->syncLogUpdateCommitIndex = raftLogUpdateCommitIndex;
  pLogStore->syncLogCommitIndex = raftlogCommitIndex;
  pLogStore->syncLogRestoreFromSnapshot = raftLogRestoreFromSnapshot;
  pLogStore->syncLogBeginIndex = raftLogBeginIndex;
  pLogStore->syncLogEndIndex = raftLogEndIndex;
  pLogStore->syncLogIsEmpty = raftLogIsEmpty;
  pLogStore->syncLogEntryCount = raftLogEntryCount;
  pLogStore->syncLogLastIndex = raftLogLastIndex;
  pLogStore->syncLogIndexRetention = raftLogIndexRetention;
  pLogStore->syncLogLastTerm = raftLogLastTerm;
  pLogStore->syncLogAppendEntry = raftLogAppendEntry;
  pLogStore->syncLogGetEntry = raftLogGetEntry;
  pLogStore->syncLogTruncate = raftLogTruncate;
  pLogStore->syncLogWriteIndex = raftLogWriteIndex;
  pLogStore->syncLogExist = raftLogExist;

  return pLogStore;
}

void logStoreDestory(SSyncLogStore* pLogStore) {
  if (pLogStore != NULL) {
    SSyncLogStoreData* pData = pLogStore->data;

    (void)taosThreadMutexLock(&(pData->mutex));
    if (pData->pWalHandle != NULL) {
      walCloseReader(pData->pWalHandle);
      pData->pWalHandle = NULL;
    }
    (void)taosThreadMutexUnlock(&(pData->mutex));
    (void)taosThreadMutexDestroy(&(pData->mutex));

    taosMemoryFree(pLogStore->data);

    taosLRUCacheEraseUnrefEntries(pLogStore->pCache);
    taosLRUCacheCleanup(pLogStore->pCache);

    taosMemoryFree(pLogStore);
  }
}

// log[m .. n]
static int32_t raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncIndex snapshotIndex) {
  if (!(snapshotIndex >= 0)) return TSDB_CODE_SYN_INTERNAL_ERROR;

  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  int32_t            code = walRestoreFromSnapshot(pWal, snapshotIndex);
  if (code != 0) {
    int32_t     err = code;
    const char* errStr = tstrerror(err);
    int32_t     sysErr = ERRNO;
    const char* sysErrStr = strerror(ERRNO);

    sNError(pData->pSyncNode,
            "wal restore from snapshot error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", snapshotIndex,
            err, errStr, sysErr, sysErrStr);
    TAOS_RETURN(err);
  }

  TAOS_RETURN(TSDB_CODE_SUCCESS);
}

SyncIndex raftLogBeginIndex(struct SSyncLogStore* pLogStore) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  SyncIndex          firstVer = walGetFirstVer(pWal);
  return firstVer;
}

SyncIndex raftLogEndIndex(struct SSyncLogStore* pLogStore) { return raftLogLastIndex(pLogStore); }

bool raftLogIsEmpty(struct SSyncLogStore* pLogStore) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  return walIsEmpty(pWal);
}

int32_t raftLogEntryCount(struct SSyncLogStore* pLogStore) {
  SyncIndex beginIndex = raftLogBeginIndex(pLogStore);
  SyncIndex endIndex = raftLogEndIndex(pLogStore);
  int32_t   count = endIndex - beginIndex + 1;
  return count > 0 ? count : 0;
}

SyncIndex raftLogLastIndex(struct SSyncLogStore* pLogStore) {
  SyncIndex          lastIndex;
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  SyncIndex          lastVer = walGetLastVer(pWal);

  return lastVer;
}

SyncIndex raftLogIndexRetention(struct SSyncLogStore* pLogStore, int64_t bytes) {
  SyncIndex          lastIndex;
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  SyncIndex          lastVer = walGetVerRetention(pWal, bytes);

  return lastVer;
}

SyncIndex raftLogWriteIndex(struct SSyncLogStore* pLogStore) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  SyncIndex          lastVer = walGetLastVer(pWal);
  return lastVer + 1;
}

static bool raftLogExist(struct SSyncLogStore* pLogStore, SyncIndex index) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  bool               b = walLogExist(pWal, index);
  return b;
}

// if success, return last term
// if not log, return 0
// if error, return SYNC_TERM_INVALID
SyncTerm raftLogLastTerm(struct SSyncLogStore* pLogStore) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  if (walIsEmpty(pWal)) {
    return 0;
  } else {
    SSyncRaftEntry* pLastEntry;
    int32_t         code = raftLogGetLastEntry(pLogStore, &pLastEntry);
    if (code == 0 && pLastEntry != NULL) {
      SyncTerm lastTerm = pLastEntry->term;
      taosMemoryFree(pLastEntry);
      return lastTerm;
    } else {
      return SYNC_TERM_INVALID;
    }
  }

  // can not be here!
  return SYNC_TERM_INVALID;
}

static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry, bool forceSync) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;

  SWalSyncInfo syncMeta = {0};
  syncMeta.isWeek = pEntry->isWeak;
  syncMeta.seqNum = pEntry->seqNum;
  syncMeta.term = pEntry->term;

  int64_t tsWriteBegin = taosGetTimestampNs();
  int32_t code = walAppendLog(pWal, pEntry->index, pEntry->originalRpcType, syncMeta, pEntry->data, pEntry->dataLen,
                              &pEntry->originRpcTraceId);
  int64_t tsWriteEnd = taosGetTimestampNs();
  int64_t tsElapsed = tsWriteEnd - tsWriteBegin;

  if (TSDB_CODE_SUCCESS != code) {
    int32_t     err = terrno;
    const char* errStr = tstrerror(err);
    int32_t     sysErr = ERRNO;
    const char* sysErrStr = strerror(ERRNO);

    sNError(pData->pSyncNode, "wal write error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s",
            pEntry->index, err, errStr, sysErr, sysErrStr);

    TAOS_RETURN(err);
  }

  code = walFsync(pWal, forceSync);
  if (TSDB_CODE_SUCCESS != code) {
    sNError(pData->pSyncNode, "wal fsync failed since %s", tstrerror(code));
    TAOS_RETURN(code);
  }

  sGDebug(&pEntry->originRpcTraceId,
          "vgId:%d, index:%" PRId64 ", persist raft entry, type:%s origin type:%s elapsed:%" PRId64,
          pData->pSyncNode->vgId, pEntry->index, TMSG_INFO(pEntry->msgType), TMSG_INFO(pEntry->originalRpcType),
          tsElapsed);
  TAOS_RETURN(TSDB_CODE_SUCCESS);
}

// entry found, return 0
// entry not found, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
// other error, return -1
int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncRaftEntry** ppEntry) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  int32_t            code = 0;

  *ppEntry = NULL;

  int64_t ts1 = taosGetTimestampNs();
  (void)taosThreadMutexLock(&(pData->mutex));

  SWalReader* pWalHandle = pData->pWalHandle;
  if (pWalHandle == NULL) {
    sError("vgId:%d, wal handle is NULL", pData->pSyncNode->vgId);
    (void)taosThreadMutexUnlock(&(pData->mutex));

    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
  }

  int64_t ts2 = taosGetTimestampNs();
  code = walReadVer(pWalHandle, index);
  walReadReset(pWalHandle);
  int64_t ts3 = taosGetTimestampNs();

  // code = walReadVerCached(pWalHandle, index);
  if (code != 0) {
    int32_t     err = code;
    const char* errStr = tstrerror(err);
    int32_t     sysErr = ERRNO;
    const char* sysErrStr = strerror(ERRNO);

    if (terrno == TSDB_CODE_WAL_LOG_NOT_EXIST) {
      sNTrace(pData->pSyncNode, "wal read not exist, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", index,
              err, errStr, sysErr, sysErrStr);
    } else {
      sNTrace(pData->pSyncNode, "wal read error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", index, err,
              errStr, sysErr, sysErrStr);
    }

    /*
        int32_t saveErr = terrno;
        walCloseReadHandle(pWalHandle);
        terrno = saveErr;
    */

    (void)taosThreadMutexUnlock(&(pData->mutex));

    TAOS_RETURN(code);
  }

  *ppEntry = syncEntryBuild(pWalHandle->pHead->head.bodyLen);
  if (*ppEntry == NULL) return TSDB_CODE_SYN_INTERNAL_ERROR;
  (*ppEntry)->msgType = TDMT_SYNC_CLIENT_REQUEST;
  (*ppEntry)->originalRpcType = pWalHandle->pHead->head.msgType;
  (*ppEntry)->seqNum = pWalHandle->pHead->head.syncMeta.seqNum;
  (*ppEntry)->isWeak = pWalHandle->pHead->head.syncMeta.isWeek;
  (*ppEntry)->term = pWalHandle->pHead->head.syncMeta.term;
  (*ppEntry)->index = index;
  if ((*ppEntry)->dataLen != pWalHandle->pHead->head.bodyLen) return TSDB_CODE_SYN_INTERNAL_ERROR;
  (void)memcpy((*ppEntry)->data, pWalHandle->pHead->head.body, pWalHandle->pHead->head.bodyLen);

  /*
    int32_t saveErr = terrno;
    walCloseReadHandle(pWalHandle);
    terrno = saveErr;
  */

  (void)taosThreadMutexUnlock(&(pData->mutex));
  int64_t ts4 = taosGetTimestampNs();

  int64_t tsElapsed = ts4 - ts1;
  int64_t tsElapsedLock = ts2 - ts1;
  int64_t tsElapsedRead = ts3 - ts2;
  int64_t tsElapsedBuild = ts4 - ts3;

  sNTrace(pData->pSyncNode,
          "read index:%" PRId64 ", elapsed:%" PRId64 ", elapsed-lock:%" PRId64 ", elapsed-read:%" PRId64
          ", elapsed-build:%" PRId64,
          index, tsElapsed, tsElapsedLock, tsElapsedRead, tsElapsedBuild);

  TAOS_RETURN(code);
}

// truncate semantic
static int32_t raftLogTruncate(struct SSyncLogStore* pLogStore, SyncIndex fromIndex) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;

  int32_t code = walRollback(pWal, fromIndex);
  if (code != 0) {
    int32_t     err = code;
    const char* errStr = tstrerror(err);
    int32_t     sysErr = ERRNO;
    const char* sysErrStr = strerror(ERRNO);
    sError("vgId:%d, wal truncate error, from-index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s",
           pData->pSyncNode->vgId, fromIndex, err, errStr, sysErr, sysErrStr);
  }

  // event log
  sNTrace(pData->pSyncNode, "log truncate, from-index:%" PRId64, fromIndex);

  TAOS_RETURN(code);
}

// entry found, return 0
// entry not found, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
// other error, return -1
static int32_t raftLogGetLastEntry(SSyncLogStore* pLogStore, SSyncRaftEntry** ppLastEntry) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  if (ppLastEntry == NULL) return TSDB_CODE_SYN_INTERNAL_ERROR;

  *ppLastEntry = NULL;
  if (walIsEmpty(pWal)) {
    TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST);
  } else {
    SyncIndex lastIndex = raftLogLastIndex(pLogStore);
    if (!(lastIndex >= SYNC_INDEX_BEGIN)) return TSDB_CODE_SYN_INTERNAL_ERROR;
    int32_t code = raftLogGetEntry(pLogStore, lastIndex, ppLastEntry);

    TAOS_RETURN(code);
  }

  TAOS_RETURN(TSDB_CODE_FAILED);
}

int32_t raftLogUpdateCommitIndex(SSyncLogStore* pLogStore, SyncIndex index) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;

  // need not update
  SyncIndex snapshotVer = walGetSnapshotVer(pWal);
  SyncIndex walCommitVer = walGetCommittedVer(pWal);
  SyncIndex wallastVer = walGetLastVer(pWal);

  if (index < snapshotVer || index > wallastVer) {
    // ignore
    TAOS_RETURN(TSDB_CODE_SUCCESS);
  }

  int32_t code = walCommit(pWal, index);
  if (code != 0) {
    int32_t     err = code;
    const char* errStr = tstrerror(err);
    int32_t     sysErr = ERRNO;
    const char* sysErrStr = strerror(ERRNO);
    sError("vgId:%d, index:%" PRId64 ", raft entry update commit index error, code:0x%x msg:%s syserr:%d sysmsg:%s",
           pData->pSyncNode->vgId, index, err, errStr, sysErr, sysErrStr);

    TAOS_RETURN(code);
  }

  TAOS_RETURN(TSDB_CODE_SUCCESS);
}

SyncIndex raftlogCommitIndex(SSyncLogStore* pLogStore) {
  SSyncLogStoreData* pData = pLogStore->data;
  return pData->pSyncNode->commitIndex;
}

SyncIndex logStoreFirstIndex(SSyncLogStore* pLogStore) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;
  return walGetFirstVer(pWal);
}

SyncIndex logStoreWalCommitVer(SSyncLogStore* pLogStore) {
  SSyncLogStoreData* pData = pLogStore->data;
  SWal*              pWal = pData->pWal;

  return walGetCommittedVer(pWal);
}

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	#define _DEFAULT_SOURCE
17	#include "syncRaftLog.h"
18	#include "syncRaftCfg.h"
19	#include "syncRaftStore.h"
20	#include "syncUtil.h"
21
22	// log[m .. n]
23
24	// public function
25	static int32_t raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncIndex snapshotIndex);
26	static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry, bool forceSync);
27	static int32_t raftLogTruncate(struct SSyncLogStore* pLogStore, SyncIndex fromIndex);
28	static bool raftLogExist(struct SSyncLogStore* pLogStore, SyncIndex index);
29	static int32_t raftLogUpdateCommitIndex(SSyncLogStore* pLogStore, SyncIndex index);
30	static SyncIndex raftlogCommitIndex(SSyncLogStore* pLogStore);
31	static int32_t raftLogGetLastEntry(SSyncLogStore* pLogStore, SSyncRaftEntry** ppLastEntry);
32
33	SSyncLogStore* logStoreCreate(SSyncNode* pSyncNode) {	14,331✔
34	SSyncLogStore* pLogStore = taosMemoryCalloc(1, sizeof(SSyncLogStore));	14,331!
35	if (pLogStore == NULL) {	14,332!
36	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
37	return NULL;	×
38	}
39
40	// pLogStore->pCache = taosLRUCacheInit(10 * 1024 * 1024, 1, .5);
41	pLogStore->pCache = taosLRUCacheInit(30 * 1024 * 1024, 1, .5);	14,332✔
42	if (pLogStore->pCache == NULL) {	14,332!
43	taosMemoryFree(pLogStore);	×
44	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
45	return NULL;	×
46	}
47
48	pLogStore->cacheHit = 0;	14,332✔
49	pLogStore->cacheMiss = 0;	14,332✔
50
51	taosLRUCacheSetStrictCapacity(pLogStore->pCache, false);	14,332✔
52
53	pLogStore->data = taosMemoryMalloc(sizeof(SSyncLogStoreData));	14,332!
54	if (!pLogStore->data) {	14,332!
55	taosMemoryFree(pLogStore);	×
56	taosLRUCacheCleanup(pLogStore->pCache);	×
57	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
58	return NULL;	×
59	}
60
61	SSyncLogStoreData* pData = pLogStore->data;	14,332✔
62	pData->pSyncNode = pSyncNode;	14,332✔
63	pData->pWal = pSyncNode->pWal;	14,332✔
64	if (pData->pWal == NULL) {	14,332!
65	terrno = TSDB_CODE_SYN_INTERNAL_ERROR;	×
66	return NULL;	×
67	}
68
69	(void)taosThreadMutexInit(&(pData->mutex), NULL);	14,332✔
70	pData->pWalHandle = walOpenReader(pData->pWal, NULL, 0);	14,332✔
71	if (!pData->pWalHandle) {	14,330!
72	taosMemoryFree(pLogStore);	×
73	taosLRUCacheCleanup(pLogStore->pCache);	×
74	(void)taosThreadMutexDestroy(&(pData->mutex));	×
75	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
76	return NULL;	×
77	}
78
79	pLogStore->syncLogUpdateCommitIndex = raftLogUpdateCommitIndex;	14,330✔
80	pLogStore->syncLogCommitIndex = raftlogCommitIndex;	14,330✔
81	pLogStore->syncLogRestoreFromSnapshot = raftLogRestoreFromSnapshot;	14,330✔
82	pLogStore->syncLogBeginIndex = raftLogBeginIndex;	14,330✔
83	pLogStore->syncLogEndIndex = raftLogEndIndex;	14,330✔
84	pLogStore->syncLogIsEmpty = raftLogIsEmpty;	14,330✔
85	pLogStore->syncLogEntryCount = raftLogEntryCount;	14,330✔
86	pLogStore->syncLogLastIndex = raftLogLastIndex;	14,330✔
87	pLogStore->syncLogIndexRetention = raftLogIndexRetention;	14,330✔
88	pLogStore->syncLogLastTerm = raftLogLastTerm;	14,330✔
89	pLogStore->syncLogAppendEntry = raftLogAppendEntry;	14,330✔
90	pLogStore->syncLogGetEntry = raftLogGetEntry;	14,330✔
91	pLogStore->syncLogTruncate = raftLogTruncate;	14,330✔
92	pLogStore->syncLogWriteIndex = raftLogWriteIndex;	14,330✔
93	pLogStore->syncLogExist = raftLogExist;	14,330✔
94
95	return pLogStore;	14,330✔
96	}
97
98	void logStoreDestory(SSyncLogStore* pLogStore) {	14,327✔
99	if (pLogStore != NULL) {	14,327!
100	SSyncLogStoreData* pData = pLogStore->data;	14,327✔
101
102	(void)taosThreadMutexLock(&(pData->mutex));	14,327✔
103	if (pData->pWalHandle != NULL) {	14,331!
104	walCloseReader(pData->pWalHandle);	14,331✔
105	pData->pWalHandle = NULL;	14,329✔
106	}
107	(void)taosThreadMutexUnlock(&(pData->mutex));	14,329✔
108	(void)taosThreadMutexDestroy(&(pData->mutex));	14,330✔
109
110	taosMemoryFree(pLogStore->data);	14,328!
111
112	taosLRUCacheEraseUnrefEntries(pLogStore->pCache);	14,328✔
113	taosLRUCacheCleanup(pLogStore->pCache);	14,331✔
114
115	taosMemoryFree(pLogStore);	14,329!
116	}
117	}	14,330✔
118
119	// log[m .. n]
120	static int32_t raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncIndex snapshotIndex) {	59✔
121	if (!(snapshotIndex >= 0)) return TSDB_CODE_SYN_INTERNAL_ERROR;	59!
122
123	SSyncLogStoreData* pData = pLogStore->data;	59✔
124	SWal* pWal = pData->pWal;	59✔
125	int32_t code = walRestoreFromSnapshot(pWal, snapshotIndex);	59✔
126	if (code != 0) {	59!
127	int32_t err = code;	×
128	const char* errStr = tstrerror(err);	×
129	int32_t sysErr = ERRNO;	×
130	const char* sysErrStr = strerror(ERRNO);	×
131
132	sNError(pData->pSyncNode,	×
133	"wal restore from snapshot error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", snapshotIndex,
134	err, errStr, sysErr, sysErrStr);
135	TAOS_RETURN(err);	×
136	}
137
138	TAOS_RETURN(TSDB_CODE_SUCCESS);	59✔
139	}
140
141	SyncIndex raftLogBeginIndex(struct SSyncLogStore* pLogStore) {	255,159✔
142	SSyncLogStoreData* pData = pLogStore->data;	255,159✔
143	SWal* pWal = pData->pWal;	255,159✔
144	SyncIndex firstVer = walGetFirstVer(pWal);	255,159✔
145	return firstVer;	255,160✔
146	}
147
148	SyncIndex raftLogEndIndex(struct SSyncLogStore* pLogStore) { return raftLogLastIndex(pLogStore); }	31,336✔
149
150	bool raftLogIsEmpty(struct SSyncLogStore* pLogStore) {	31,336✔
151	SSyncLogStoreData* pData = pLogStore->data;	31,336✔
152	SWal* pWal = pData->pWal;	31,336✔
153	return walIsEmpty(pWal);	31,336✔
154	}
155
156	int32_t raftLogEntryCount(struct SSyncLogStore* pLogStore) {	×
157	SyncIndex beginIndex = raftLogBeginIndex(pLogStore);	×
158	SyncIndex endIndex = raftLogEndIndex(pLogStore);	×
159	int32_t count = endIndex - beginIndex + 1;	×
160	return count > 0 ? count : 0;	×
161	}
162
163	SyncIndex raftLogLastIndex(struct SSyncLogStore* pLogStore) {	46,930,295✔
164	SyncIndex lastIndex;
165	SSyncLogStoreData* pData = pLogStore->data;	46,930,295✔
166	SWal* pWal = pData->pWal;	46,930,295✔
167	SyncIndex lastVer = walGetLastVer(pWal);	46,930,295✔
168
169	return lastVer;	46,930,858✔
170	}
171
172	SyncIndex raftLogIndexRetention(struct SSyncLogStore* pLogStore, int64_t bytes) {	846✔
173	SyncIndex lastIndex;
174	SSyncLogStoreData* pData = pLogStore->data;	846✔
175	SWal* pWal = pData->pWal;	846✔
176	SyncIndex lastVer = walGetVerRetention(pWal, bytes);	846✔
177
178	return lastVer;	846✔
179	}
180
181	SyncIndex raftLogWriteIndex(struct SSyncLogStore* pLogStore) {	×
182	SSyncLogStoreData* pData = pLogStore->data;	×
183	SWal* pWal = pData->pWal;	×
184	SyncIndex lastVer = walGetLastVer(pWal);	×
185	return lastVer + 1;	×
186	}
187
188	static bool raftLogExist(struct SSyncLogStore* pLogStore, SyncIndex index) {	×
189	SSyncLogStoreData* pData = pLogStore->data;	×
190	SWal* pWal = pData->pWal;	×
191	bool b = walLogExist(pWal, index);	×
192	return b;	×
193	}
194
195	// if success, return last term
196	// if not log, return 0
197	// if error, return SYNC_TERM_INVALID
198	SyncTerm raftLogLastTerm(struct SSyncLogStore* pLogStore) {	17,872✔
199	SSyncLogStoreData* pData = pLogStore->data;	17,872✔
200	SWal* pWal = pData->pWal;	17,872✔
201	if (walIsEmpty(pWal)) {	17,872✔
202	return 0;	13,077✔
203	} else {
204	SSyncRaftEntry* pLastEntry;
205	int32_t code = raftLogGetLastEntry(pLogStore, &pLastEntry);	4,795✔
206	if (code == 0 && pLastEntry != NULL) {	4,795!
207	SyncTerm lastTerm = pLastEntry->term;	4,795✔
208	taosMemoryFree(pLastEntry);	4,795!
209	return lastTerm;	4,795✔
210	} else {
211	return SYNC_TERM_INVALID;	×
212	}
213	}
214
215	// can not be here!
216	return SYNC_TERM_INVALID;
217	}
218
219	static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry, bool forceSync) {	11,655,255✔
220	SSyncLogStoreData* pData = pLogStore->data;	11,655,255✔
221	SWal* pWal = pData->pWal;	11,655,255✔
222
223	SWalSyncInfo syncMeta = {0};	11,655,255✔
224	syncMeta.isWeek = pEntry->isWeak;	11,655,255✔
225	syncMeta.seqNum = pEntry->seqNum;	11,655,255✔
226	syncMeta.term = pEntry->term;	11,655,255✔
227
228	int64_t tsWriteBegin = taosGetTimestampNs();	11,655,466✔
229	int32_t code = walAppendLog(pWal, pEntry->index, pEntry->originalRpcType, syncMeta, pEntry->data, pEntry->dataLen,	11,655,466✔
230	&pEntry->originRpcTraceId);	11,655,466✔
231	int64_t tsWriteEnd = taosGetTimestampNs();	11,655,532✔
232	int64_t tsElapsed = tsWriteEnd - tsWriteBegin;	11,655,532✔
233
234	if (TSDB_CODE_SUCCESS != code) {	11,655,532!
235	int32_t err = terrno;	×
236	const char* errStr = tstrerror(err);	×
237	int32_t sysErr = ERRNO;	×
238	const char* sysErrStr = strerror(ERRNO);	×
239
240	sNError(pData->pSyncNode, "wal write error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s",	×
241	pEntry->index, err, errStr, sysErr, sysErrStr);
242
243	TAOS_RETURN(err);	×
244	}
245
246	code = walFsync(pWal, forceSync);	11,655,532✔
247	if (TSDB_CODE_SUCCESS != code) {	11,655,373!
248	sNError(pData->pSyncNode, "wal fsync failed since %s", tstrerror(code));	×
249	TAOS_RETURN(code);	×
250	}
251
252	sGDebug(&pEntry->originRpcTraceId,	11,655,373!
253	"vgId:%d, index:%" PRId64 ", persist raft entry, type:%s origin type:%s elapsed:%" PRId64,
254	pData->pSyncNode->vgId, pEntry->index, TMSG_INFO(pEntry->msgType), TMSG_INFO(pEntry->originalRpcType),
255	tsElapsed);
256	TAOS_RETURN(TSDB_CODE_SUCCESS);	11,655,390✔
257	}
258
259	// entry found, return 0
260	// entry not found, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
261	// other error, return -1
262	int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncRaftEntry** ppEntry) {	1,397,762✔
263	SSyncLogStoreData* pData = pLogStore->data;	1,397,762✔
264	SWal* pWal = pData->pWal;	1,397,762✔
265	int32_t code = 0;	1,397,762✔
266
267	*ppEntry = NULL;	1,397,762✔
268
269	int64_t ts1 = taosGetTimestampNs();	1,397,771✔
270	(void)taosThreadMutexLock(&(pData->mutex));	1,397,771✔
271
272	SWalReader* pWalHandle = pData->pWalHandle;	1,397,774✔
273	if (pWalHandle == NULL) {	1,397,774!
274	sError("vgId:%d, wal handle is NULL", pData->pSyncNode->vgId);	×
275	(void)taosThreadMutexUnlock(&(pData->mutex));	×
276
277	TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);	×
278	}
279
280	int64_t ts2 = taosGetTimestampNs();	1,397,768✔
281	code = walReadVer(pWalHandle, index);	1,397,768✔
282	walReadReset(pWalHandle);	1,397,765✔
283	int64_t ts3 = taosGetTimestampNs();	1,397,772✔
284
285	// code = walReadVerCached(pWalHandle, index);
286	if (code != 0) {	1,397,772✔
287	int32_t err = code;	430✔
288	const char* errStr = tstrerror(err);	430✔
289	int32_t sysErr = ERRNO;	430✔
290	const char* sysErrStr = strerror(ERRNO);	430✔
291
292	if (terrno == TSDB_CODE_WAL_LOG_NOT_EXIST) {	430!
293	sNTrace(pData->pSyncNode, "wal read not exist, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", index,	430!
294	err, errStr, sysErr, sysErrStr);
295	} else {
296	sNTrace(pData->pSyncNode, "wal read error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", index, err,	×
297	errStr, sysErr, sysErrStr);
298	}
299
300	/*
301	int32_t saveErr = terrno;
302	walCloseReadHandle(pWalHandle);
303	terrno = saveErr;
304	*/
305
306	(void)taosThreadMutexUnlock(&(pData->mutex));	430✔
307
308	TAOS_RETURN(code);	430✔
309	}
310
311	*ppEntry = syncEntryBuild(pWalHandle->pHead->head.bodyLen);	1,397,342✔
312	if (*ppEntry == NULL) return TSDB_CODE_SYN_INTERNAL_ERROR;	1,397,292!
313	(*ppEntry)->msgType = TDMT_SYNC_CLIENT_REQUEST;	1,397,292✔
314	(*ppEntry)->originalRpcType = pWalHandle->pHead->head.msgType;	1,397,292✔
315	(*ppEntry)->seqNum = pWalHandle->pHead->head.syncMeta.seqNum;	1,397,292✔
316	(*ppEntry)->isWeak = pWalHandle->pHead->head.syncMeta.isWeek;	1,397,292✔
317	(*ppEntry)->term = pWalHandle->pHead->head.syncMeta.term;	1,397,292✔
318	(*ppEntry)->index = index;	1,397,292✔
319	if ((*ppEntry)->dataLen != pWalHandle->pHead->head.bodyLen) return TSDB_CODE_SYN_INTERNAL_ERROR;	1,397,292!
320	(void)memcpy((*ppEntry)->data, pWalHandle->pHead->head.body, pWalHandle->pHead->head.bodyLen);	1,397,292✔
321
322	/*
323	int32_t saveErr = terrno;
324	walCloseReadHandle(pWalHandle);
325	terrno = saveErr;
326	*/
327
328	(void)taosThreadMutexUnlock(&(pData->mutex));	1,397,292✔
329	int64_t ts4 = taosGetTimestampNs();	1,397,344✔
330
331	int64_t tsElapsed = ts4 - ts1;	1,397,344✔
332	int64_t tsElapsedLock = ts2 - ts1;	1,397,344✔
333	int64_t tsElapsedRead = ts3 - ts2;	1,397,344✔
334	int64_t tsElapsedBuild = ts4 - ts3;	1,397,344✔
335
336	sNTrace(pData->pSyncNode,	1,397,344!
337	"read index:%" PRId64 ", elapsed:%" PRId64 ", elapsed-lock:%" PRId64 ", elapsed-read:%" PRId64
338	", elapsed-build:%" PRId64,
339	index, tsElapsed, tsElapsedLock, tsElapsedRead, tsElapsedBuild);
340
341	TAOS_RETURN(code);	1,397,344✔
342	}
343
344	// truncate semantic
345	static int32_t raftLogTruncate(struct SSyncLogStore* pLogStore, SyncIndex fromIndex) {	5✔
346	SSyncLogStoreData* pData = pLogStore->data;	5✔
347	SWal* pWal = pData->pWal;	5✔
348
349	int32_t code = walRollback(pWal, fromIndex);	5✔
350	if (code != 0) {	5!
351	int32_t err = code;	×
352	const char* errStr = tstrerror(err);	×
353	int32_t sysErr = ERRNO;	×
354	const char* sysErrStr = strerror(ERRNO);	×
355	sError("vgId:%d, wal truncate error, from-index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s",	×
356	pData->pSyncNode->vgId, fromIndex, err, errStr, sysErr, sysErrStr);
357	}
358
359	// event log
360	sNTrace(pData->pSyncNode, "log truncate, from-index:%" PRId64, fromIndex);	5!
361
362	TAOS_RETURN(code);	5✔
363	}
364
365	// entry found, return 0
366	// entry not found, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
367	// other error, return -1
368	static int32_t raftLogGetLastEntry(SSyncLogStore* pLogStore, SSyncRaftEntry** ppLastEntry) {	4,795✔
369	SSyncLogStoreData* pData = pLogStore->data;	4,795✔
370	SWal* pWal = pData->pWal;	4,795✔
371	if (ppLastEntry == NULL) return TSDB_CODE_SYN_INTERNAL_ERROR;	4,795!
372
373	*ppLastEntry = NULL;	4,795✔
374	if (walIsEmpty(pWal)) {	4,795!
375	TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST);	×
376	} else {
377	SyncIndex lastIndex = raftLogLastIndex(pLogStore);	4,795✔
378	if (!(lastIndex >= SYNC_INDEX_BEGIN)) return TSDB_CODE_SYN_INTERNAL_ERROR;	4,795!
379	int32_t code = raftLogGetEntry(pLogStore, lastIndex, ppLastEntry);	4,795✔
380
381	TAOS_RETURN(code);	4,795✔
382	}
383
384	TAOS_RETURN(TSDB_CODE_FAILED);
385	}
386
387	int32_t raftLogUpdateCommitIndex(SSyncLogStore* pLogStore, SyncIndex index) {	11,638,368✔
388	SSyncLogStoreData* pData = pLogStore->data;	11,638,368✔
389	SWal* pWal = pData->pWal;	11,638,368✔
390
391	// need not update
392	SyncIndex snapshotVer = walGetSnapshotVer(pWal);	11,638,368✔
393	SyncIndex walCommitVer = walGetCommittedVer(pWal);	11,638,427✔
394	SyncIndex wallastVer = walGetLastVer(pWal);	11,638,565✔
395
396	if (index < snapshotVer \|\| index > wallastVer) {	11,638,630!
397	// ignore
UNCOV 398	TAOS_RETURN(TSDB_CODE_SUCCESS);	×
399	}
400
401	int32_t code = walCommit(pWal, index);	11,638,680✔
402	if (code != 0) {	11,638,640!
403	int32_t err = code;	×
404	const char* errStr = tstrerror(err);	×
405	int32_t sysErr = ERRNO;	×
406	const char* sysErrStr = strerror(ERRNO);	×
407	sError("vgId:%d, index:%" PRId64 ", raft entry update commit index error, code:0x%x msg:%s syserr:%d sysmsg:%s",	×
408	pData->pSyncNode->vgId, index, err, errStr, sysErr, sysErrStr);
409
410	TAOS_RETURN(code);	×
411	}
412
413	TAOS_RETURN(TSDB_CODE_SUCCESS);	11,638,640✔
414	}
415
416	SyncIndex raftlogCommitIndex(SSyncLogStore* pLogStore) {	14,331✔
417	SSyncLogStoreData* pData = pLogStore->data;	14,331✔
418	return pData->pSyncNode->commitIndex;	14,331✔
419	}
420
421	SyncIndex logStoreFirstIndex(SSyncLogStore* pLogStore) {	×
422	SSyncLogStoreData* pData = pLogStore->data;	×
423	SWal* pWal = pData->pWal;	×
424	return walGetFirstVer(pWal);	×
425	}
426
427	SyncIndex logStoreWalCommitVer(SSyncLogStore* pLogStore) {	×
428	SSyncLogStoreData* pData = pLogStore->data;	×
429	SWal* pWal = pData->pWal;	×
430
431	return walGetCommittedVer(pWal);	×
432	}

taosdata / TDengine / #3842

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